====== Découvrir le code avec Arduino ====== {{tag> Arduino support guide}} ===== Structure et boucle ===== 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 } ===== Les variables ===== 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. ^ Type ^ Nb Octets ^ Valeurs ^ | **boolean** | 1| 0 ou 1, true ou false, high ou low| | **char** | 1| pour stocker des caractères | | **byte** | 1| de 0 à 255 | | **int** | 2 en 8 bits | de -32768 à 32767 | | **word** | 2| de 0 à 65535 (entier non signé) | | **long** | 4 | de -2 147 483 648 à 2 147 483 647 | | **unsigned long** | 4 | de 0 à 4 294 967 295 | | **float** | 4 | de - 3.4 x10 // puissance 38// à 3.4 x10 // puissance 38// | ==== portée des variables==== 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 } } ==== constantes & #define ==== On déclare deux genres de variables: - 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. - 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 Parfois les constantes sont déclarées en amont du code avec le mot-clé **#define**. Dans ce cas le traitement se fait avant le compilateur, qui ne connaîtra jamais le nom de la variable : il sera remplacé partout par sa valeur avant d'être compilé. **On ne pourra pas faire de test sur la variable au cours du programme !** //Apriori// c'est pratique pour stocker et jouer avec des variables type **string** et/ou pour vérifier / debugger certains scripts, mais il me semble qu'il vaut mieux éviter cette syntaxe quand on débute. [[https://forum.arduino.cc/index.php?topic=44023.0|+ d'infos sur ce point ici en anglais.]] ==== + Ressources : ==== === leurs types === * [[https://www.locoduino.org/spip.php?article11|Types, constantes & variables sur LOCODUINO]]. * [[http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.DeclarationVariables|Déclaration des Variables chez Mon Club Elec .fr ]] * [[http://diwo.bq.com/fr/les-variables-sur-arduino/| les variables Arduino sur DIWO]] === leur portée === * [[http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.PorteeVariables| expliquée sur Mon Club Elec]] ===== Envoyer / Recevoir ===== ===== Numérique / Analogique =====