Découvrir le code avec Arduino

Lorsqu'on ouvre un nouveau programme avec l'IDE Arduino, deux blocs sont déjà en place : setup() et loop(). Ces blocs sont nécessaires au fonctionnement d'un programme Arduino. Le premier bloc contiendra les instructions d'initialisation et ne sera joué qu'une fois au démarrage du montage, tandis que le second sera lu et relu en boucle par le programme pour animer le montage.

Le mot-clé void précise que ces fonctions ne renvoient rien au programme. Il est possible de créer des fonctions qui renvoient un certain type de variable.

Pour déjouer le caractère continu du loop on pourra créer des fonctions, boucles et conditions logiques.

 
void setup() {
  // le code ici ne sera interprété qu'une seule fois
  // initialisation
}
 
void loop() {
  // ici les instructions seront jouées en boucle
  // c'est le cœur du programme
}

Comme des mots-valises dans lesquels où on peut ranger/stocker les infos utiles,
pour les appeler plus facilement (on choisit le nom) et pour pouvoir utiliser des données dont on ne connait pas encore la valeur. (variables calculées par le programme).

On type les variables pour qu'elles soient lisibles par le programme et que le compilateur sache quel espace leur réserver dans la mémoire du calculateur.

Les variables binaires boolean occupent un octet (et pas un byte).

Les float ne peuvent dépasser une précision de 6 à 7 chiffes en tout (avant et après la virgule). Les double proviennent d'autres langages et, en Arduino ils ont la même taille et la même précision que les float.

Selon l'endroit et la manière dont elles sont déclarées :

• Globales : déclarées en dehors de toutes accolades elles sont visibles et utilisables par tout le pgm.
• Locales : déclarées au sein d'une fonction elles ne sont utilisables qu'entre ses accolades. Elles ne sont pas conservées par le programme au-delà de l'exécution de leur fonction et seront recréées au prochain appel, typiquement les indices de boucles for et while…

Au delà de cette portée on peut caractériser certaines variables selon 2 mots clés :

• static : cette variable locale est conservée au delà de l'exécution de sa fonction, sa valeur sera stockée en mémoire entre 2 appels à la fonction.
• volatile : ce qualificatif est utile pour gérer les interruptions … ? à creuser .

// exemples de déclaration
const byte PinLed = 3; // pinLed est globale 
// elle sera utilisable partout dans le pgm
 
void loop(){
int Compteur = 0; // Compteur appartient au loop 
// elle ne peut pas être utilisé dans le setup
 
for (i=0; i++; i<100){
// i est une variable utile seulement à cette boucle for
}
}

On déclare deux genres de variables:

1. celles dont les valeurs ne changeront pas, par exemple les n° de broches utilisées par les composants. Dans ce cas on déclare une constante en précisant const avant le type.
2. celles dont la valeur va réellement varier au fur et à mesure de l’exécution du programme, et pour lesquelles on a donc besoin d'espace de calcul.

// exemples de déclaration
const byte PinLed = 3; // la broche de ma LED, reste identique
boolean EtatLed = 0; // l'etat de ma LED, changera
int Compteur = 0; // changera au cours du programme

leurs types

• Types, constantes & variables sur LOCODUINO.
• Déclaration des Variables chez Mon Club Elec .fr
• les variables Arduino sur DIWO

leur portée

• expliquée sur Mon Club Elec