======Introduction à la programmation dans Arduino =====



=====La syntaxe=====


Les langages de programmation diffèrent des langages dits 'naturels' : dans un échange entre deux personnes, outre les règles d'une langue, les approximations verbales, les gestes ou l'intonation qui sont de nature culturelles, permettent de détecter et suivre le sens d'une conversation (ou encore d'y introduire de l'humour, des erreurs et des inadéquations).

Dans les langages informatiques un programme est régit par une syntaxe rigide.  Elle se compose de définitions, de règles et de structures.  Voici quelques règles générales du langage de programmation Arduino.

  Chaque ligne est terminée par un ';' (sauf pour les fonctions)
  Le code d'une fonction s'inscrit à l'intérieur d'accolades '{}'
  Les arguments d'une fonction sont placés entre parenthèses '()'
  
  
=====La structure de base=====

Chaque programme Arduino se divise en trois parties :
 ==1. Déclaration de variables==
<sxh java>
int uneVariable = 42; // une déclaration de variable de type 'int' (nombre entier), portant le nom 'uneVariable' et avec la valeur 42
</sxh>


 ==2. Initialisation des entrées et des sorties==
<sxh java>
void setup() { // fonction d'initialisation, s'exécute une seule fois
// les broches sont déclarées ici en entrées ou en sortie 
// ou encore la communication sérielle est établie 

}
</sxh>

 ==3. La fonction loop==
<sxh java>
void loop() {
// Le code placé à l'intérieur des accolades se répète en boucle.
}
</sxh>


exemple: [[01.Communication_sérielle]]

exemple: [[01.Blink]]

=====Les variables=====

===Définition===

Un espace réservé dans la mémoire de l'ordinateur pour y stocker de l'information on y réfère par un nom.
Les noms des variables peuvent être de simples lettres (comme x ou y) ou être plus descriptifs (moyenne, vitesse, joltCola).  La casse doit être respectée (y et Y sont des variables différentes) les noms de variables doivent débuter par une lettre et ne pas contenir d'accents, d'espaces, de points, de virgules et de noms réservés du langage Arduino.

Types de variables les plus courants :
<sxh java>
int x = 42;     // le plus courant, nombre entier qui peut varier de -32,768 à 32,767
boolean merciBoole = TRUE;  // Peut garder une valeur soit vraie ou fausse
float seitan = 6.66; // un nombre fractionnaire 
</sxh>


[[http://arduino.cc/en/Reference/HomePage|Autres types de variables]]

===La déclaration de variables===

La création d'une variable est appelé “déclaration”. La déclaration d'une variable se fait en précédent le nom de la variable de son type.

<sxh java>
int vitesseMoteur; // À sa création, la variable est indéfinie (undefined), elle ne contient aucune valeur. 
// Pour lui assigner une valeur nous utilisons l'opérateur d'affectation '='.
</sxh>

===L'affectation d'une variable===

L'opérateur d'affectation le plus simple est le signe “=”. Le premier réflexe est de penser que ce signe veut dire “égal à”. Ce n'est pas le cas. Contrairement à l'algèbre, il signifie que l'opérande de gauche se voit affecter la valeur de l'expression qui est à droite du signe égal.

On peut donc affecter une valeur à une variable comme ceci :

<sxh java>
int x = 5; //  la variable type 'nombre entier' et portant le nom 'x' se voit affecter la valeur 5
</sxh>

Les variables peuvent être re-affectée comme ceci :

<sxh java>
int vitesseMoteur = 42;
int vitesseMoteur = vitesseMoteur+624; // Dans ce cas la nouvelle valeur de vitesseMoteur est 666
</sxh>

===Le cycle des variables (roll-over)===

Lorsque les valeurs des variables dépassent leur borne maximale ou minimale (définie par le type de variable), elles 'cyclent'. Par exemple, pour un type de variable 'int' qui se nomme 'x' la borne maximale est de 32 767, si on ajoute '1' à cette valeur, la nouvelle valeur de x sera -32 768.  Ceci est une source d'erreur fréquente.

<sxh java>
   int x = 32 768;  // crée une variable x de type int (avec des bornes de -32 768 et 32 768)
   x = x + 1;       // x a maintenant une valeur de -32,768 et non 32769
   </sxh>
   
Exemple : [[01.Augmenter la valeur d'une variable]]

Exemple : [[01.0.Fade]] Changer la luminosité d'une DEL 

Exemple : [[01.1.Fade_avec_condition]] Dans l'exemple précédent, la valeur de luminosité continue à augmenter. Cet exemple montre comment remettre la valeur à '0' lorsque la luminosité est plus grande que '255' (sa valeur maximale).

Exemple : [[01_2_fade|]]

Exemple : [[01.DC_progressif]]. Une variable change la vitesse de rotation d'un moteur DC

Exercice : Faire varier la vitesse d'un moteur 'pas à pas' (stepper).  Utilisez une variable dans l'appel de fonction delay();

=====Les fonctions=====


==== Introduction ====

Lorsque nous programmons, il arrive régulièrement que nous devions répéter une suite d'opérations à plusieurs reprises dans notre programme.  Si la répétition s'exécute un nombre de fois déterminées, nous pourrions nous contenter de faire un copier coller.  Par contre, si la répétition est dépendante de facteurs externes ou qu'elle peut varier à chaque exécution, le copier coller ne suffira plus.  La plupart des langages nous permettent de regrouper ces opérations dans une structure que nous pouvons faire rouler lorsque nous en avons besoin.  Dans l'environnement Arduino, cette structure s'appelle une fonction. 


==== Déclaration de fonction ====

<sxh java>
int maFonctionMultiplicatrice(int x, int y){ // une fonction portant le nom "maFonction" qui accepte deux arguments (x et y)
  int resultat; // déclaration de variable de type nombre entier
  resultat = x * y; // multiplication de x et y et assignation de la valeur résultante dans la variable 'resultat'
  return resultat; // pour retourner la valeur au reste du programme
}

</sxh>

  * Le type de données qui sera retournée par la fonction, dans ce cas, ce sera un nombre entier "int".  Si la fonction ne retourne rien au reste du programme, nous inscrivons "void".
  *  le nom de la fonction, ici "maFonction", ce nom doit respecter les mêmes règles que les variables et ne doit pas être un mot réservé du langage Arduino.
  *  Les parenthèses, toujours présentes.  Elles nous permettent d'envoyer de l'information à la fonction lors de l'exécution.  Elles doivent toujours être présentes, même lorsqu'il n'y a rien à transmettre elles restent alors vides.
  * le code de la fonction s'inscrit à l'intérieur des accolades '{}'
 
==== Appel de fonction ====

<sxh java>
uneNouvelleVariable = maFonctionMultiplicatrice(6, 7);
</sxh>

Lorsque la fonction est ainsi appelée, elle est exécutée immédiatement et lorsqu'elle est complétée, l'exécution du programme reprend à partir du point d'appel de la fonction et l'énoncé suivant sera exécuté.



==== Valeur de retour ====


Avec le mot réservé "return", la fonction est capable de renvoyer une valeur au programme appelant. Cette valeur est contenue dans une donnée en tout point comparable à une variable typée.

<sxh java>

{
    ...
    return monResultat;                // renvoyer le résultat
}

</sxh>

=====Les librairies=====

Définition : une librairie est un ensemble de fonctions liées car elles facilitent certaines tâches. Par exemple la libraire 'Servo' pour contrôler un servo moteur.

Une librairie est ajoutée au projet de la façon suivante dans le code source:

<sxh java>
#include <Servo.h>
</sxh>
=====Les énoncés conditionnels===== 

Il existe quatre types d'énoncés conditionnels : les boucles 'for' et 'while' et les conditions 'if...else' et 'switch/case'. Ils servent à exécuter une section de code lorsqu'une certaine condition est vraie.

===boucle for===

<sxh java>
// Le code entre accolades sera exécuté à répétition tant que 
// la valeur de 'i' reste inférieure à 100.  Cette structure est 
// utile comme compteur.

for(int i=0;i<100;i++)
 {
 Serial.println(i); // afficher la valeur de 'i' dans la console
 delay(1000);       // pause de 1 seconde
 }
</sxh>


===boucle while===

Le code entre accolades est exécuté tant que la condition est vraie. Cette structure est utile pour des événements comme des interrupteurs ou pour exécuter du code tant que la valeur d'un senseur est inférieure ou supérieure à un seuil donné.

<sxh java>
// le code sera exécuté tant que la valeur d'un interrupteur est 'HIGH'
  while (digitalRead(monBouton) == HIGH) {
    executeCetteFonction(); 
  }
  
</sxh> 
===if===

<sxh java>
// Si la valeur de monSenseur est plus grande que 42 alors 
// le code entre les accolades sera exécuté.  

if(monSenseur > 42)
 {
    //allume une DEL!
    digitalWrite(13,HIGH);
 }
</sxh>



===switch/case===

Comme un 'if' avec plusieurs conditions.  

<sxh java>

  switch (maVariable) 
  {
    case 42:
      //exécuter cette partie lorsque maVariable est égale à '42'
      break;
    case 666:
      //exécuter cette partie lorsque maVariable est égale à '666'
      break;
    default: 
      // si aucune condition n'est vraie, cette partie est exécutée
      // cette partie est optionnelle
  }
</sxh>
=====Sources=====
  * [[https://fr.flossmanuals.net/arduino/programmer-arduino/]]
  * [[https://tutoarduino.com/portfolio-items/tpbd1-partie-2-familiarisons-nous-avec-la-programmation/?portfolioID=975]]
    * Le site semble être en panne...  Accéder la page dans la Wayback Machine: [[https://web.archive.org/web/20170619221138/https://tutoarduino.com/portfolio-items/tpbd1-partie-2-familiarisons-nous-avec-la-programmation/?portfolioID=975]]
  * [[http://arduino.cc/en/Reference/HomePage]]