Projet Arduino. Apprendre les bases de l électronique avec une carte Arduino JO BONNÉ. Lycée JEAN-MONNET BRUXELLES A.E.F.E.

Projet Arduino Apprendre les bases de l électronique avec une carte Arduino JO BONNÉ Lycée JEAN-MONNET BRUXELLES A.E.F.E. 9 janvier 2017 en cours de construction Résumé La carte Arduino connaît depuis quelques années un succès 1 planétaire. Elle permet la réalisation de projets du domaine technologique au domaine artistique 2. Les logiciels Arduino et Processing ont été bien conçus pour pouvoir écrire des programmes relativement simples pour aborder la programmation avec plaisir. Les bases de l électricité peuvent être ainsi reprises et progressivement étendues de façons ludique et expérimentale, c est la vocation de ce document. L effort d apprentissage est largement récompensé : la carte Arduino ne se limite pas uniquement aux fonctions de base. Le microcontrôleur qui la gère recèle ne nombreuses possibilités d extensions et son logiciel est suffisamment ouvert pour aller bien au delà des exemples qu il présente dans son menu. Il est notamment possible d écrire directement en langage C et en langage C++. Des montages complexes peuvent alors être réalisés nécessitant une exécution rapide des lignes de code. Ce document a été essentiellement réalisé par programmation : Le texte avec LATEX, [4] Les schémas électriques avec Tik Z, package de LATEX, [8] Le logiciel Fritzing pour incorporer les images, [5] Les lignes de code avec : Le langage Arduino, Le langage Processing, Les bibliothèques controlp5 et G4P de Processing, Le langage C pour les approfondissements. Tous ces logiciels sont gratuits. 1. Prix 23 On peut découvrir les nombreux montages de l électronique de base et de faible puissance à bas coût en utilisant une plaque de prototypage «breadboard» (coût inférieur à 8 ) pour les réaliser. 2. Arduino a conquis sa place dans les arts numériques 1

Sommaire 1 Matériel et logiciel 4 1.1 Alimentation................................................................ 4 I Les fonctions de bases 5 2 Sorties numériques - digital output 6 2.1 Présentation................................................................ 6 2.2 Programmation d une sortie numérique............................................... 6 2.3 Logique inversée............................................................. 7 2.4 Le moniteur série intégré à l IDE Arduino............................................... 7 2.4.1 Son utilisation........................................................... 7 2.4.2 Amélioration........................................................... 8 3 Sorties PWM Pulse Width Modulation ou Modulation de Largeur d Impulsion 9 3.1 Présentation................................................................ 9 3.2 Programmation d une sortie PWM................................................... 9 3.3 Commande d une sortie PWM par le moniteur série........................................ 9 4 Signal carré de fréquence audible ou ultrasonore 11 5 Entrées numériques - digital input 12 5.1 État d une entrée numérique...................................................... 12 6 Entrées analogiques - analogic input 13 7 Gestion des durées 14 7.1 Pause.................................................................... 14 7.2 Instant................................................................... 14 8 Résumé : principales commandes spécifiques de la carte Arduino 16 II Éléments de programmation avec le logiciel Arduino 17 9 Déclaration de variable 17 10 Conversions 17 11 Opérateurs logiques 17 12 Condition 17 13 Branchement 18 14 Itération avec for ou while 18 15 Changement d échelle 18 III Éléments de programmation avec le logiciel Processing 19 16 Introduction 19 17 Sélection de commandes Processing 19 17.1 Commandes générales.......................................................... 19 17.2 Commandes spécifiques de la souris................................................. 19 17.3 Commandes spécifiques du clavier.................................................. 19 18 Commande d une sortie numérique par Processing 20 19 Commande d une sortie PWM par Processing 21 20 Graphe d une conversion analogique-numérique avec Processing 22 IV Quelques bibliothèques de Processing 23 21 Introduction 23 22 La bibliothèque controlp5 23 22.1 Commande d une sortie numérique.................................................. 23 22.2 Commande d une sortie PWM..................................................... 24 23 La bibliothèque G4P 25 23.1 Commande d une sortie numérique.................................................. 25 23.2 Commande d une sortie PWM..................................................... 26 V Approfondissements 27 2

24 Quelques registres du microcontrôleur Atmega 328 de l Arduino Uno 28 25 Langage Arduino et langage C 28 25.1 Base 10 ou décimale base 2 ou binaire base 16 ou hexadécimale............................... 28 25.2 Règles d écriture communément admises.............................................. 29 25.3 Comparaisons et opérations logiques................................................. 29 25.3.1 Comparaisons logiques..................................................... 29 25.3.2 Opérations logiques et masque................................................. 29 25.3.3 Décalages............................................................. 29 26 Fonctions de base en langage C 29 26.1 Opérations dans un registre....................................................... 29 26.1.1 Déclaration d une broche en sortie.............................................. 29 26.2 Sorties numériques............................................................ 30 26.3 Sorties PWM................................................................ 31 26.3.1 Modification de la fréquence du signal PWM......................................... 32 26.4 Entrées numériques........................................................... 32 26.5 Timer.................................................................... 32 26.6 Interruptions - Interrupt Service Routine................................................. 33 26.6.1 Exploitation des timers et des interruptions......................................... 33 ANNEXES 35 A Compléments d électricité 35 A.1 Loi des nœuds............................................................... 35 A.2 Loi des mailles............................................................... 35 A.3 Résistance................................................................. 35 A.3.1 Généralités............................................................. 35 A.3.2 Potentiomètre........................................................... 35 A.3.3 Photorésistance.......................................................... 36 A.3.4 CTN................................................................. 36 A.3.5 CTP................................................................. 36 A.3.6 Varistance............................................................. 36 A.4 Diode au germanium ou au silicium.................................................. 36 A.5 Diode LED................................................................. 36 A.6 Diode Zener................................................................ 36 A.7 Photodiode................................................................. 37 A.8 Transistor.................................................................. 37 A.8.1 Variétés............................................................... 37 A.8.2 En amplificateur......................................................... 37 A.8.3 En tout ou rien.......................................................... 37 A.8.4 Phototransistor.......................................................... 37 A.8.5 Transistor à effet de champ................................................... 37 A.9 L amplificateur opérationnel...................................................... 38 A.9.1 Utilisation en comparateur................................................... 38 A.9.2 Quelques utilisations en amplificateur de tension...................................... 38 A.9.2.1 montage suiveur.................................................... 38 A.9.2.2 montage inverseur................................................... 39 A.9.2.3 montage non-inverseur................................................ 39 A.10 Thyristor.................................................................. 39 A.11 Relais.................................................................... 39 A.12 Triac..................................................................... 39 A.13 Optodiac-optotriac............................................................ 39 B Bibliothèque 40 B.1 Programme sans bibliothèque mais avec des fonctions....................................... 40 B.2 Programme avec bibliothèque..................................................... 40 C Expériences diverses 41 C.1 Afficher le potentiel du curseur d un potentiomètre......................................... 41 C.2 Montrer la relation tension-intensité lumineuse reçue par une photorésistance........................ 41 C.3 Afficher la tension de seuil d une diode................................................ 41 Glossaire 42 Références bibliographiques 43 3

1 Matériel et logiciel Carte Arduino Uno IDE Arduino Les expériences décrites dans ce document ont été réalisées avec un ordinateur géré par le système d exploitation Ubuntu 16.04 LTS 3. Avec le Terminal d Ubuntu, on peut installer le logiciel de gestion d une carte Arduino Uno par sudo apt-get install arduino suivi du mot de passe. Une icône Arduino IDE apparaît dans le Launcher. On n obtient pas forcément la toute dernière version par cette méthode. 4 Une carte Arduino Uno R3 est connectée sur un port USB 2.0. Elle n est pas toujours reconnue automatiquement par Ubuntu. Pour que Arduino IDE puisse gérer la carte, on peut procéder ainsi à partir du Terminal : sudo arduino suivi du mot de passe. Voir la référence [1] Le logiciel s ouvre avec l indication du port utilisé en bas à droite. Par exemple : \dev\ttyacm0 sur Ubuntu. Le menu Outils/Port série/ doit normalement indiquer le port utilisé. Pour vérifier si la connexion entre l ordinateur et la carte fonctionne bien : Dans Aduino IDE : Fichier/Exemples/01.Basics/Blink Téléverser (icône ) Si la communication est bonne, pendant le chargement du programme dans la carte, les LEDs TX et RX clignotent, puis la LED placée entre la broche 13 et la masse GND clignote. Remarque : L exemple Fichier/Exemples/01.Basics/BareMinimum est le programme minimum que peut charger la carte. La LED 13 reste alors constamment allumée. 5 1.1 Alimentation La carte peut être alimentée : Par le câble USB, Par adaptateur secteur 7 V à 12 V ou par des piles sur le jack ( au centre) Avec une alimentation externe entre 7 V à 12 V avec sur la broche V in et sur GND. Avec une alimentation régulée de 5 V sur la broche 5 V. (à éviter) Lorsque la carte est alimentée, certaines broches deviennent génératrices de tension régulée : La broche 3,3 V La broche 5 V 3. Tous les logiciels utilisés dans ce document sont multiplateformes. 4. https://www.arduino.cc/en/main/software permet de télécharger la dernière version (1.6.12 en octobre 2016). Après extraction du dossier téléchargé, dans le Terminal, accéder au dossier arduino-1.6.12 puis taper./install.sh pour installer Arduino IDE 5. Important : Avant de démarrer un nouveau projet, il se peut que la mémoire de la carte Arduino contienne un ancien programme. Il vaut mieux s en débarrasser avant de brancher un nouveau circuit qui pourrait endommager la carte au moment de la mise sous tension. Il faut savoir qu en téléversant le programme BareMinimum toutes les broches deviennent des entrées numériques (sauf la broche 13) 4

Les fonctions de bases Il faut toujours avoir ces 3 réflexes lorsqu on fait un montage en électronique : Y a-t-il les résistances suffisantes pour que l intensité du courant ne soit pas trop élevée? S il y a des bobines : a-t-on mis les diodes de protection contre les surtensions créées par les bobines? Ne suis-je pas porteur de charge électrostatique qui pourrait détruire un circuit intégré? On commence par présenter l ensemble des fonctionnalités de la carte en utilisant le minimum de matériel, avec aussi une programmation réduite à sa plus simple expression. Résumé des commandes paragraphe 8 5

SORTIES 2 Sorties numériques - digital output 2.1 Présentation 2.2 Programmation d une sortie numérique Lorsqu une broche est programmée en sortie, elle peut être considérée comme un générateur. La carte Arduino Uno possède 14 broches numérotées de 0 à 13, qui peuvent être programmées soit au potentiel 0 V soit au potentiel 5 V. Cependant les broches 0 (RX) et 1 (TX) notamment ont des fonctions particulières pour la communication entre l ordinateur et la carte par le câble USB, il faut éviter de les utiliser autrement. La broche 13 est par construction reliée à GND (ground) par une LED en série avec une résistance. Elle permet surtout de vérifier facilement le bon fonctionnement de la connexion entre la carte et l ordinateur. Attention : les autres sorties numériques peuvent avoir d autres fonctions dans le cadre de certains programmes à l exception de la broche 7. Les broches GND sont au potentiel 0 V. Si on doit relier une broche au potentiel 5 V à une broche au potentiel 0 V par une chaîne de conducteurs (surtout pas directement par un câble mais par exemple avec une résistance suffisamment grande de l ordre de 500 Ω), ceux-ci sont alors parcourus par un courant qui circule du potentiel le plus élevé vers le potentiel le plus faible. L intensité de ce courant se mesure en ampères (courant fort), milliampères (courant faible) ou microampères (courant très faible). Les cartes peuvent être détériorées si on dépasse une limite de courant. Cette limite n est que de 40 ma pour une sortie numérique. Si on utilise plusieurs sorties numériques, le total ne doit pas dépasser 200 ma. La carte Arduino est gérée par un logiciel dédié : on parle du langage Arduino 6. Il est vivement recommandé de commenter les lignes de code d un programme. Il y a 2 façons d ajouter des commentaires dans un programme : après // en restant sur la ligne entre /* et */ sur plusieurs lignes. Le programme Fichier/Exemples/01.Basics/BareMinimum indique les 2 instructions obligatoires qu il faudra écrire dans n importe quel programme : void setup() // les instructions écrites ici ne sont exécutées qu'une seule fois. void loop() // les instructions écrites ici sont exécutées en boucle. Quelques expériences avec le programme Fichier/Exemples/01.Basics/Blink : int led = 13; //on affecte à la variable led la valeur entière 13 void setup() pinmode(led, OUTPUT); //la broche 13 est déclarée en SORTIE void loop() digitalwrite(led, HIGH); delay(1000); digitalwrite(led, LOW); delay(1000); //en boucle //la broche 13 est portée à 5 V //durée 1 s //la broche 13 est portée à 0 V //durée 1 s On peut remplacer HIGH par 1 et LOW par 0. On peut remplacer OUTPUT par 1 (et INPUT par 0) 6. Le langage Arduino est proche du langage C. Le code C est compatible avec le code Arduino voir 25 page 28 6

On peut supprimer la déclaration de variable int led = 13; et remplacer led par 13 Chaque changement sur le programme n est effectif qu après avoir téléversé la nouvelle version dans la mémoire de la carte. Si la carte est alimentée par une source extérieure, débrancher le câble USB ne change rien : le programme est installé dans la mémoire de la carte et exécuté en boucle indéfiniment (ou jusqu à ce qu on téléverse un nouveau programme). On pourra constater aussi que le programme placé en mémoire est sauvegardé même s il y a coupure de courant. Programme minimum pour que la broche 13 soit en permanence sous 5 V : void setup() pinmode(13,1); //la broche 13 est déclarée en SORTIE digitalwrite(13,1); //la broche 13 est portée à 5 V et la LED est allumée void loop() Programme minimum pour que la broche 13 soit en permanence sous 0 V : void setup() pinmode(13,1); //la broche 13 est déclarée en SORTIE digitalwrite(13,0); //la broche 13 est portée à 0 V et la LED est éteinte void loop() 2.3 Logique inversée Remarque importante : il ne faut pas associer systématiquement 1 et passage du courant, 0 et absence de courant. Il est toujours possible de réaliser un circuit en «logique inversée». En effet, les 2 techniques ne sont pas toujours équivalentes, l intensité du courant produit n étant pas forcément égale dans les 2 cas. 5 V i R 0 V sortie numérique 5 V R sortie numérique R i 0 V i logique 0 V 5 V logique inversée sortie numérique LED sortie numérique LED 1 allumée 0 éteinte 1 éteinte 0 allumée 2.4 Le moniteur série intégré à l IDE Arduino 2.4.1 Son utilisation Il est souhaitable de commander la LED non pas en chargeant un nouveau programme mais en modifiant le programme en cours. Pour intervenir dans le programme en exécution, on passe par le moniteur série accessible par l icône. Le moniteur est divisé en 2 parties : en haut : un cadre qui permet d envoyer des caractères de l ordinateur vers le «buffer», mémoire-tampon de la carte. en dessous : ce qui est envoyé de la carte vers l ordinateur. Pour que la communication ait lieu entre le moniteur série et l ordinateur, il faut synchroniser le débit d informations des 2 côtés : on déclare par exemple 9600 bauds sur le moniteur et on écrit l instruction Serial.begin(9600); dans le programme. 7

Pour commander la LED, il faut pouvoir écrire HIGH ou 1 pour l allumer ou LOW ou 0 pour l éteindre dans l instruction digitalwrite. On reprend le programme minimum qui allume la LED 13 en permanence. byte etat=1; byte val1; byte val2; void setup() Serial.begin(9600); pinmode(13,output); digitalwrite(13,etat); //la broche 13 est déclarée en SORTIE //la broche 13 est portée à 5 V et la LED est allumée void loop() val1=serial.available(); // val1: nombre de caractères dans le buffer val2=serial.read(); // val2: transformation du premier caractère en valeur ASCII correspondant. Par exemple 0 donne 48 et 1 donne 49. Il y a 256 valeurs ASCII disponibles. Serial.print(val1); // écrit sur le moniteur val 1 Serial.print(" "); // laisse un espace de 2 caractères sur la même ligne Serial.print(val2); // écrit sur le moniteur val 1 sur la même ligne if (val1>0) // s'il y a un caractère au moins dans le buffer etat=val2-48; // soustraction valeur ASCII - 48 = 0 ou autre nombre digitalwrite(13,etat); // si 0 LED éteinte, si autre nombre LED allumée Serial.print(" "); Serial.println(etat); // affichage de etat delay(1000); La boucle loop permet de recevoir l ordre qui permet de commander la LED. On constate que tous les caractères autres que 0 allument la LED. On pourra remarquer que l envoi de certains caractères donnent 2 valeurs ASCII consécutives (par exemple µ ou $). 2.4.2 Amélioration Le moniteur série intégré à l IDE Arduino permet d envoyer dans la mémoire de la carte des instructions caractères par caractère ou par blocs de caractères qu il faut ensuite assembler par une programmation qui peut s avérer fastidieuse. Pour contourner avantageusement cette difficulté, on peut utiliser le logiciel Processing. Certains exemples accessibles par l IDE Arduino contiennent d ailleurs des sous programmes à copier coller dans Processing. Une partie de ce document est consacrée à l utilisation de Processing dans le but de remplacer le moniteur série de l IDE Arduino : Commande d une sortie numérique par Processing : voir 18 page 20 Commande d une sortie numérique par Processing avec la bibliothèque controlp5 : voir 22 page 23 Commande d une sortie numérique par Processing avec la bibliothèque G4P : voir 23 page 25 8

3 Sorties PWM Pulse Width Modulation ou Modulation de Largeur d Impulsion 3.1 Présentation Les broches 3, (5, 6), 9, 10 et 11 peuvent être utilisées en PWM. On les repère facilement sur la carte : à côté du numéro de la broche. Les broches 5 et 6 sont cependant à éviter car elles peuvent être perturbées dans la gestion du temps. Chaque broche déclarée en PWM par une commande analogwrite(<numéro de la broche>, <0 à 255> ) génère un signal carré : c est un signal de très courte durée (appelée période) qui se répète identiquement à lui-même (à une fréquence d environ 490 Hz c est-à-dire que ce signal se répète 490 fois par seconde) : exemple : si la valeur indiquée est 64, alors pendant 64 256 = 0,25 soit 25% du temps, le potentiel de la broche sera à +5 V et le reste du temps à 0 V. On dit que le rapport cyclique est de 25%. potentiel PWM 5 V 25% 32 256 T période T 1 490 s 75% 224 256 T allumé éteint 0 V t en ms 3.2 Programmation d une sortie PWM /* Ce programme permet de faire varier de plus en plus fort la luminosité d'une LED placée en série avec une résistance de l'ordre de 500 ohms. */ int LED=3; int i=0; // La broche 3 peut être choisie. // variable de boucle void setup() pinmode(led, OUTPUT); // On déclare la broche 3 en SORTIE void loop() for (i=0; i<=255;i++) // toutes les valeurs de 0 à 255 sont utilisées tour à tour analogwrite(led,i); // commande générant le signal carré delay(10); // chaque valeur i dure 10 ms 3.3 Commande d une sortie PWM par le moniteur série float etat;//comme il y a une puissance dans le programme, il faut déclarer en float float val1; float val2; 9

float total=0; void setup() Serial.begin(9600); pinmode(3,output); //broche 3 en sortie analogwrite(3,123);//la led 3 brille à moitié void loop() val1=serial.available();//val1 nombre de caractères dans le buffer if(val1!=0)// val1: nombre de caractères dans le buffer val2=serial.read();// val2: transformation du premier caractère en valeur ASCII correspondant. Par //exemple 0 donne 48 et 1 donne 49. Il y a 256 valeurs ASCII disponibles. Serial.print(val1);// écrit sur le moniteur val 1 Serial.print(" ");// laisse un espace de 2 caractères sur la même ligne Serial.print(val2);// écrit sur le moniteur val 1 sur la même ligne if (val1>0)// s'il y a un caractère au moins dans le buffer etat=val2-48; total=total+etat*pow(10,val1-1);// soustraction valeur ASCII - 48 = 0 ou autre nombre total=constrain(total,0,255); Serial.print(" "); Serial.print(etat);// affichage de etat Serial.print(" "); Serial.println(total); analogwrite(3,total); delay(100); else total=0; delay(100); 10

4 Signal carré de fréquence audible ou ultrasonore La commande tone(<pin>,<frequence>,<durée>) permet d obtenir un signal carré de fréquence allant de 31 Hz à 65535 Hz. La durée en ms est optionnelle. La broche <pin> doit préalablement être déclarée en sortie. potentiel période T = 1 f 50% 50% 5 V 0 V t On peut brancher par exemple un haut-parleur d impédance 8 Ω en série avec une résistance de protection, le tout entre la broche 2 et la broche GND : broche 2 HP R=220 Ω 8 Ω Le programme suivant permet d entendre le la 3 pendant 5 secondes : void setup() pinmode(2,output); tone(2,440,5000); void loop() 0 V notone(<pin>) arrête le signal. 11

ENTRÉES 5 Entrées numériques - digital input Les broches numérotées de 0 à 13 peuvent être utilisées aussi en entrées numériques. Lorsqu une broche est programmée en entrée, elle peut être considérée comme un appareil testeur de tension. Une entrée numérique lit une tension et la traduit soit par un 0 (entre 0 V et environ 2,5 V c est le niveau bas ou LOW) soit par un 1 (entre environ 2,5 V et 5 V c est le niveau haut ou HIGH). Il y a donc un intervalle de potentiel autour de 2,5 V ou la lecture est incertaine 7. Chaque broche en entrée numérique peut par programmation être reliée au +5 V par l intermédiaire d une résistance interne de «rappel au plus» (pull-up) de 20 à 50 kω. Il faut éviter d utiliser les broches 0 (RX), 1 (TX) et 13. (voir 2.1) 5.1 État d une entrée numérique Quelques expériences avec le programme Fichier/Exemples/01.Basics/DigitalReadSerial : /* Ce programme lit l'état de la broche 2 et l'écrit sur le moniteur série On relie avec un câble la broche 2 à GND ou à la broche 5 V ou à la broche 3,3 V */ int pin = 2; void setup() Serial.begin(9600); // il faut initialiser la connexion série à 9600 bauds (nombre de symboles transmissibles par seconde) pinmode(pin, INPUT); // on déclare la broche 2 en entrée: void loop() int etat = digitalread(pin); // lit l'état 0 ou 1 sur la broche 2 Serial.println(etat); // écrit l'état sur le moniteur suivi d'un retour à la ligne (sinon print) delay(1); // précaution pour éviter que la routine soit trop rapide (en ms) Il est nécessaire de cliquer sur l icône pour lire les résultats sur le moniteur série. Attention à vérifier que la vitesse de transmission des données est la même que celle indiquée dans le programme : 9600 bauds. Si le câble relié à la broche 2 n est pas branché de l autre côté («en l air»), alors l état de l entrée devient aléatoire. Pour éviter cela et imposer dans ce cas l état 1, il suffit de remplacer pinmode(pin, INPUT) par pinmode(pin, INPUT_PULLUP) On peut remplacer INPUT par 0 7. phénomène d hystérésis : le passage de 0 à 1 n a pas lieu pour le même potentiel que pour le passage de 1 à 0. La datasheet du micro-contrôleur garantit que toute tension inférieure à 1V sera comprise comme un 0 et que toute tension supérieure à 3,5V sera comprise comme un 1. 12

6 Entrées analogiques - analogic input La carte Arduino Uno possède 6 broches numérotées de A0 à A5. Elles peuvent être utilisées en entrée analogique : un potentiel entre 0 V et 5 V sera converti en un nombre de 0 à 1023, proportionnellement c est le travail d un CAN convertisseur analogiquenumérique intégré au micro-contrôleur de la carte. Ce nombre peut être récupéré puis utilisé.on remarquera ainsi qu avec la carte Arduino, une variation de 5 1024 4,9 mv peut être détectée. On s inspire de l exemple : Fichier/Exemples/01.Basics/AnalogReadSerial : /* La broche A0 reçoit une tension entre 0 V et 5 V et la convertit en un nombre compris entre 0 et 1023 grâce à un convertisseur analogique numérique CAN 10 bits (2^10=1024) On relie avec un câble la broche A0 à GND, à la broche 5 V ou à la broche 3,3 V. */ void setup() Serial.begin(9600); // il faut initialiser la connexion série à 9600 bits par seconde void loop() int valeur = analogread(a0); // lit la tension sur la broche A0 et la convertit Serial.println(valeur); // écrit la valeur sur le moniteur série delay(500); // pause de 0,5 seconde En plaçant un potentiomètre entre 0 et 5 V et en branchant le curseur sur A0 on peut faire défiler toutes les valeurs de 0 à 1023. Remarque : On peut modifier la tension de référence du convertisseur analogique numérique de l Arduino : analogreference(internal); remplace la tension de référence 5 V par une tension de référence de 1,1 V. La conversion reste 10 bits. La résolution est alors de l ordre de 1,1 mv. analogreference(external); remplace la tension de référence 5 V par la tension appliquée sur la broche AREF; entre 1,1 et 5 V, au travers une résistance de 5kΩ (par précaution bien qu il y ait une résistance interne de 32kΩ sur la broche AREF;). analogreference(default); impose la tension de référence 5 V. 13

7 Gestion des durées 7.1 Pause TEMPS La commande delay(<durée>) arrête le déroulement du programme pendant la durée en millisecondes (ms) indiquée. La commande delaymicroseconds(<durée>) arrête le déroulement du programme pendant la durée en microsecondes (µs) indiquée. 7.2 Instant La commande millis() donne le nombre de ms depuis la mise en route du programme. (jusqu à 50 jours!). La commande micros() donne le nombre de µs depuis la mise en route du programme. (jusqu à 70 minutes environ). unsigned long time; void setup() Serial.begin(9600); void loop() Serial.print("Time: "); time = millis(); //affiche le temps depuis que le programme a démarré Serial.println(time); // pause d'une seconde delay(1000); Attention : Les commandes delay(<durée>) et delaymicroseconds(<durée>) bloquent l exécution du programme pendant la durée indiquée : aucune autre tâche ne peut être exécutée pendant cette durée. byte etatdel13 = HIGH; byte etatdel12 = HIGH; unsigned long datedernierchangement13 = 0; unsigned long datedernierchangement12 = 0; void setup() pinmode(13, OUTPUT); pinmode(12, OUTPUT); void flashdel13() unsigned long datecourante = millis(); unsigned long intervalle = datecourante - datedernierchangement13; if (etatdel13 == HIGH && intervalle > 20) // extinction de la DEL car elle est allumee (HIGH) et 20ms se sont ecoules etatdel13 = LOW; digitalwrite(13, etatdel13); datedernierchangement13 = datecourante; else if (etatdel13 == LOW && intervalle > 980) // allumage de la DEL car elle est eteinte (LOW) et 980ms se sont ecoules etatdel13 = HIGH; digitalwrite(13, etatdel13); datedernierchangement13 = datecourante; void flashdel12() unsigned long datecourante = millis(); unsigned long intervalle = datecourante - datedernierchangement12; if (etatdel12 == HIGH && intervalle > 100) // extinction de la DEL car elle est allumee (HIGH) et 100ms se sont ecoules etatdel12 = LOW; digitalwrite(12, etatdel12); datedernierchangement12 = datecourante; else if (etatdel12 == LOW && intervalle > 200) // allumage de la DEL car elle est eteinte (LOW) et 200ms se sont ecoules etatdel12 = HIGH; digitalwrite(12, etatdel12); datedernierchangement12 = datecourante; 14

void loop() flashdel13(); flashdel12(); 15

8 Résumé : principales commandes spécifiques de la carte Arduino broches (0, 1,) 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 et 13 pinmode(<numéro de la broche>,output) digitalwrite(<numéro de la broche>,high) digitalwrite(<numéro de la broche>,low) la broche est une SORTIE la sortie est portée à +5 V la sortie est portée à 0 V tone(<pin>, <frequence>, <durée>) la sortie est un signal carré la durée est optionnelle notone(<pin>) arrête le signal carré pinmode(<numéro de la broche>,input) la broche est une ENTRÉE lit 0 ou 1 si elle est en l air pinmode(<numéro de la broche>,input_pullup) la broche est une ENTRÉE lit 1 si elle est en l air int etat = digitalread(<numéro de la broche>) lit l état de l ENTRÉE 0 ou 1 broches A0, A1, A2, A3, A4, A5 int valeur = analogread(<numéro de la broche>) lit la valeur de l ENTRÉE 0 à 1023 analogreference(<option>); DEFAULT : 5 V INTERNAL : 1,1 V EXTERNAL : entre 1,1 et 5 V PWM broches 3, (5, 6), 9, 10 et 11 analogwrite(<numéro de la broche>, <valeur>) 0 à 255 «pseudo-analogique» moniteur série Serial.begin(<vitesse en bauds>) Serial.print(<valeur>) Serial.println(<valeur>) valeur=serial.available() valeur=serial.read() durée delay(<durée>) ouverture de la communication série écrit valeur dans le moniteur série sans retour à la ligne écrit valeur dans le moniteur série avec retour à la ligne indique le nombre de caractères dans le buffer du moniteur convertit en valeur ASCII le premier caractère dans le buffer du moniteur pause en ms maximum 128 delaymicroseconds(<durée>) pause en µs millis() permet d utiliser la durée en ms depuis le démarrage d un programme micros() permet d utiliser la durée en µs depuis le démarrage d un programme 16

Éléments de programmation avec le logiciel Arduino 9 Déclaration de variable exemple de syntaxe occupation mémoire commentaire boolean b = true; true ou false b =!b; inverse l état unsigned char mychar = 'A'; synonyme : byte 0 à 255 (8 bits 1 byte) code ASCII de A = 65 char mychar; -128 à 127 (8 bits 1 byte) le résultat est un caractère non un chiffre byte b = B10010; 0 à 255 (8 bits 1 byte) B10010 nombre binaire int led = 13; 2 10 15 à 2 10 15-1 (16 bits 2 bytes) -32768 à 32767 unsigned int led = 13; synonyme : word 0 à 65535 (2 10 16-1) (16 bits 2 bytes) long var = <valeur>; 2147483648 à 2147483647 (32 bits 4 bytes) unsigned long var = <valeur>; 0 à 429496729 (2 10 32-1) (32 bits 4 bytes) float n = 1.117; synonyme : double int led[8]=4,5,6,7,8,9,10,11; 3,4028235 10 38 à 3,4028235 10 38 (32 bits 4 bytes) précision 6 ou 7 décimales. déclare un tableau de 8 constantes const byte pinled = 13; déclare une valeur qui ne changera pas au cours du programme 10 Conversions Les nombres entiers peuvent être entrés ou obtenus dans les bases 10 (base décimale), 2 (base binaire) et 16 (base hexadécimale). Par défaut, c est la base 10 qui est prise en compte. void setup() Serial.begin(9600); Serial.println(123,BIN);//123 en décimal = 111101 en binaire = 7B en hexadécimal Serial.println(B1111011,DEC); //préfixe B pour entrer un nombre binaire Serial.println(123,HEX); Serial.println(0x7B,DEC); //préfixe 0x pour entrer un nombre hexadécimal void loop() 11 Opérateurs logiques Attention : = est une affectation et== est une égalité.!= différent de si P est Vrai,!P est faux. && renvoie Vrai uniquement si les deux conditions sont vraies ensemble. renvoie Vrai si et seulement si une des valeurs est Vraie. ^ renvoie Vrai si une seule des conditions est vrai et l autre fausse. 12 Condition int seuil = 80 ; int valeur = analogread(a0) ; if (valeur > seuil) // traitement si la valeur est strictement supérieure else // facultatif // traitement si la valeur est inférieure ou égale 17

if (analogread(0) > 400) // si la valeur analogique du capteur > 400 return 1; // renvoie 1 else return 0; // renvoie 2 13 Branchement byte boutonactif = 0 ; // traitement qui permet de savoir sur quel bouton on a appuyé, contient 0 si aucun bouton n'a été utilisé switch ( boutonactif ) case 1 : // traitement si c'est le bouton 1 break ; case 2 : // traitement si c'est le bouton 2 break ; case 3 : // traitement si c'est le bouton 3 break ; default : // traitement si aucun bouton n'a été utilisé break ; 14 Itération avec for ou while int tab[128] ; // définition d'un tableau d'entiers contenant 128 cases, indexées de 0 à 127 int somme = 0 ; for (int i = 0 ; i < 128 ; i++) //i = i +1 somme += tab[i] ;//somme = somme + tab[i] float moyenne = somme / 128.0 ;//128.0 float et non entier int state = LOW ; // on suppose le bouton inactivé while (state == LOW) digitalwrite(led1, HIGH) ; // on allume la LED d'alarme delay(500) ; // on attend une demi-seconde digitalwrite(led1, LOW) ; // on éteint la LED d'alarme delay(500) ; // on attend une demi-seconde state = digitalread(button) ; digitalwrite(led2, HIGH) ; // on allume la LED indiquant un bon fonctionnement do // instructions de la boucle while (condition); 15 Changement d échelle val2 = map(val1,400,1000,0,255); 18

16 Introduction Éléments de programmation avec le logiciel Processing Certains exemples de programmes présentés dans l IDE Arduino contiennent des sous-programmes à copier-coller dans le logiciel Processing. Un programme Processing pourra notamment remplacer avantageusement le moniteur série. On peut créer à l écran une interface de commande de la carte Arduino avec des boutons, des curseurs, des fenêtres... Attention : bien que Arduino et Processing soient produits par la même communauté de développeurs, les syntaxes sont proches mais pas identiques. Processing est multiplateforme, on peut le télécharger et l installer à partir du site https://processing.org/download/?processing. Pour lancer facilement Processing sur Ubuntu, une solution consiste à ouvrir le fichier processing avec l éditeur Geany dont les fonctionnalités sont plus complètes que celles de Gedit) et taper F5. L IDE Processing ressemble beaucoup à l IDE Arduino. Remarque : La partie inférieure de l IDE Processing est une console sur laquelle on peut recueillir des données résultant de l exécution du programme en cours. Elle n a donc pas le même usage que la partie inférieure de l IDE Arduino sur laquelle on recueille notamment des messages d erreurs. Fichier/Exemples est un bon moyen pour apprendre à programmer en langage Processing. On remarquera que sans aucune ligne de programme, simplement en appuyant sur l icône un résultat : un carré gris de 100 pixels de côté. qui exécute le programme, on obtient Contrairement à l IDE Arduino, il est possible d écrire directement des lignes de code sans les insérer dans des procédures void () et obtenir un résultat après compilation. En général, un programme Processing, à l instar d un programme Arduino, comporte ces 2 procédures : void setup() dans laquelle les lignes de code sont exécutées une seule fois, et void draw() dans laquelle les lignes de code sont exécutées en bouche. Dans le cadre de ce document, il s agit d abord d utiliser les exemples des 2 IDE pour remplacer le moniteur série d Arduino par un programme Processing qui s avérera beaucoup plus évolutif. 17 Sélection de commandes Processing 17.1 Commandes générales 17.2 Commandes spécifiques de la souris 17.3 Commandes spécifiques du clavier 19

18 Commande d une sortie numérique par Processing L exemple suivant reprend en l épurant Fichier/Exemples/Serial/SimpleWrite de l IDE Processing : On commande l allumage ou l extinction d une LED par déplacement de la souris sur un carré : Voici le programme à téléverser dans la carte Arduino : char val; void setup() pinmode(3, OUTPUT); Serial.begin(9600); //val est une variable de type char, chaîne de caractères //broche 3 en sortie numérique //établit la communication carte - ordinateur void loop() while (Serial.available()) //tant qu'il y a des données dans le buffer val = Serial.read(); //le premier caractère dans le buffer est lu if (val == 'H') //si ce caractère est H digitalwrite(3, HIGH); //allume la LED else digitalwrite(3, LOW); //si ce n'est pas H, la LED est éteinte delay(100); //pause de 0,1 seconde Programme Progressing associé : import processing.serial.*; communication par le port USB Serial port; int val; //mise en service de la bibliothèque de gestion de //obligatoire //déclaration de variable entière 200px void setup() size(200, 200); //crée un carré (par défaut Processing crée un carré de 100 de côté) port = new Serial(this, "/dev/ttyacm0", 9600); //ouverture de la communication entre l' ordinateur et la carte void draw() if (mousex<100) port.write('h'); else port.write('l'); //création du dessin //partie gauche du carré //envoie un H vers la carte //envoie un L vers la carte 0 < mousex < 100 100 < mousex < 200 200px 20

19 Commande d une sortie PWM par Processing L exemple suivant reprend en l épurant Fichier/Exemples/04 Communication/Dimmer de l IDE Arduino : On commande l allumage progressive ou l extinction progressive d une LED par déplacement de la souris sur un rectangle : Voici le programme à téléverser dans la carte Arduino : void setup() Serial.begin(9600); pinmode(3, OUTPUT); //ouverture de la communication entre l'ordinateur et la carte //broche 3 en sortie void loop() byte brightness; if (Serial.available()) brightness = Serial.read(); analogwrite(3, brightness); Programme Progressing associé : 255px import processing.serial.*; Serial port; void setup() size(255, 200); port = new Serial(this, "/dev/ttyacm0", 9600); void draw() port.write(mousex); mousex 0 255 200px 21

20 Graphe d une conversion analogique-numérique avec Processing Un potentiomètre est placé entre 5 V et 0 V,le curseur sur l entrée analogique A0. Programme Arduino : int mesure=0; void setup() Serial.begin(9600); //variable résultat de la conversion analogique numérique //connexion ordinateur carte void loop() mesure=analogread(0); //lecture de la tension et conversion Serial.println(mesure); //envoi de la valeur sur le moniteur série delay(100); Programme Processing : import processing.serial.*; Serial port; int x = 1; float y = 0; void setup () size(400, 300); port = new Serial(this, "/dev/ttyacm0", 9600); background(255); void draw () stroke(255,0,0); point(x, height - y); if (x >= width) x = 0; background(255); else x++; void serialevent (Serial port) String caracteres = port.readstringuntil('\n');//recueille ce qui vient de la carte tant qu'il n'y a pas de <<retour chariot>> if (caracteres!= null) caracteres = trim(caracteres);//enlève les espaces blancs entre caractères y = float(caracteres);//convertit la chaîne en nombre y = map(y, 0, 1023, 0, height);//transforme les valeurs pour que toute la hauteur de l'é cran puisse être occupé 22

Quelques bibliothèques de Processing 21 Introduction Des bibliothèques complètent Processing. Elles peuvent permettre d éviter de nombreuses lignes de code en fournissant des commandes prêtes à l emploi : par exemple un bouton pour commander une LED. On se limitera dans ce document à 2 d entre elles : controlp5 et G4P. 22 La bibliothèque controlp5 22.1 Commande d une sortie numérique Programme à écrire dans l IDE Arduino : char val; //val est une variable de type char, chaîne de caractères void setup() pinmode(3, OUTPUT); //broche 3 en sortie numérique Serial.begin(9600); //établit la communication carte - ordinateur void loop() while (Serial.available()) //tant qu'il y a des données dans le buffer val = Serial.read(); //le premier caractère dans le buffer est lu if (val == 'H') //si ce caractère est H digitalwrite(3, HIGH); //allume la LED else digitalwrite(3, LOW); //si ce n'est pas H, la LED est éteinte delay(100); //pause de 0,1 seconde Programme à écrire dans l IDE Processing : import processing.serial.*; //mise en service de la bibliothèque de gestion de communication par le port USB import controlp5.*; Serial port; //obligatoire ControlP5 cp5; int val; //déclaration de variable entière void setup() size(250, 150); port = new Serial(this, "/dev/ttyacm0", 9600); cp5 = new ControlP5(this); cp5.addbutton("allume").setposition(50,50).setsize(50,50) ; cp5.addbutton("eteint").setposition(150,50).setsize(50,50) ; void draw() public void allume() port.write('h'); public void eteint() port.write('l'); 23

22.2 Commande d une sortie PWM Programme à écrire dans l IDE Arduino : void setup() Serial.begin(9600); la carte pinmode(3, OUTPUT); //ouverture de la communication entre l'ordinateur et //broche 3 en sortie void loop() byte brightness; if (Serial.available()) brightness = Serial.read(); analogwrite(3, brightness); Programme Progressing associé : import processing.serial.*; import controlp5.*; Serial port; ControlP5 cp5; int slidervalue = 100; void setup() size(255, 200); cp5 = new ControlP5(this); cp5.addslider("slidervalue").setposition(80,50).setrange(0,255) ; port = new Serial(this, "/dev/ttyacm0", 9600); void draw() port.write(slidervalue); 24

23 La bibliothèque G4P 23.1 Commande d une sortie numérique Programme à écrire dans l IDE Arduino : char val; //val est une variable de type char, chaîne de caractères void setup() pinmode(3, OUTPUT); //broche 3 en sortie numérique Serial.begin(9600); //établit la communication carte - ordinateur void loop() while (Serial.available()) //tant qu'il y a des données dans le buffer val = Serial.read(); //le premier caractère dans le buffer est lu if (val == 'H') //si ce caractère est H digitalwrite(3, HIGH); //allume la LED else digitalwrite(3, LOW); //si ce n'est pas H, la LED est éteinte delay(100); //pause de 0,1 seconde Programme Progressing associé : Premier onglet : import processing.serial.*; import g4p_controls.*; Serial port; public void setup() size(200, 100, JAVA2D); creategui(); customgui(); port = new Serial(this, "/dev/ttyacm0", 9600); public void draw() background(230); public void customgui() Deuxième onglet : public void button1_click1(gbutton source, GEvent event) port.write('h'); public void button2_click1(gbutton source, GEvent event) port.write('l'); public void creategui() G4P.messagesEnabled(false); G4P.setGlobalColorScheme(GCScheme.BLUE_SCHEME); G4P.setCursor(ARROW); surface.settitle("sketch Window"); button1 = new GButton(this, 56, 13, 80, 30); button1.settext("allume"); button1.addeventhandler(this, "button1_click1"); button2 = new GButton(this, 55, 56, 80, 30); button2.settext("eteint"); button2.addeventhandler(this, "button2_click1"); GButton button1; GButton button2; 25

23.2 Commande d une sortie PWM Programme à écrire dans l IDE Arduino : void setup() Serial.begin(9600); la carte pinmode(3, OUTPUT); //ouverture de la communication entre l'ordinateur et //broche 3 en sortie void loop() byte brightness; if (Serial.available()) brightness = Serial.read(); analogwrite(3, brightness); Programme Progressing associé : Premier onglet : import processing.serial.*; import g4p_controls.*; Serial port; public void setup() size(200,100, JAVA2D); port = new Serial(this, "/dev/ttyacm0", 9600); creategui(); customgui(); public void draw() background(210); port.write(cs.getvaluei()); public void customgui() Deuxième onglet : public void custom_slider1_change1(gcustomslider source, GEvent event) public void creategui() G4P.messagesEnabled(false); G4P.setGlobalColorScheme(GCScheme.BLUE_SCHEME); G4P.setCursor(ARROW); surface.settitle("sketch Window"); cs = new GCustomSlider(this, 51, 28, 100, 40, "grey_blue"); cs.setshowvalue(true); cs.setshowlimits(true); cs.setlimits(127, 0, 255); cs.setnumberformat(g4p.integer, 0); cs.setopaque(false); cs.addeventhandler(this, "custom_slider1_change1"); GCustomSlider cs; 26

Approfondissements 27

Cette partie nécessite de connaître quelques éléments de l architecture du microcontrôleur Atmega328 de l Arduino Uno. 24 Quelques registres du microcontrôleur Atmega 328 de l Arduino Uno Le microcontrôleur est un Atmega 328. Les broches sont regroupées en ports 8 bits 8 port B port C port D bit broche bit broche bit broche AREF GND 5 13 PB5 4 12 PB4 3 11 PB3 2 10 PB2 1 9 PB1 0 8 PB0 25 Langage Arduino et langage C 0 A0 PC0 1 A1 PC1 2 A2 PC2 3 A3 PC3 4 A4 PC4 5 A5 PC5 7 7 PD7 6 6 PD6 5 5 PD5 4 4 PD4 3 3 PD3 2 2 PD2 1 1 PD1 0 0 PD0 Le langage Arduino se veut être une simplification du langage C. Des instructions écrites en langage C peuvent être intégrées dans le code Arduino. On peut même écrire un code entièrement écrit en C dans l IDE Arduino. Les bibliothèques avr/io.h et util/delay.h sont intégrées dans l installation de l IDE Arduino. Le langage C permet notamment de gagner du temps à l exécution d un programme. Il est bien mieux adapté lorsqu on intervient en même temps sur plusieurs broches d un même port du microcontrôleur. 25.1 Base 10 ou décimale base 2 ou binaire base 16 ou hexadécimale Base 2 : 0,1 Base 10 : 0,1,2,3,4,5,6,7,8,9 Base 16 : 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F A = 8 = 8 + 0 = 4 conversion en hexadécimal : AB + 2 = 2 + 0 = 1 1 0 1 0 1 0 1 1 128 = 128 + 64 = 0 + 8 = 8 + 0 = 4 32 = 32 + 16 = 0 + 8 = 8 + 4 = 0 + conversion en décimal : 171 + 2 = 2 2 = 2 + + 1 = 1 = B 1 = 1 = 171 8. Certains bits ne sont pas utilisés. 28

binaire décimal hexadécimal binaire décimal hexadécimal binaire décimal hexadécimal 00000000 0 0 00001111 15 F 01000000 64 40 00000001 1 1 00010000 16 10 01111111 127 7F 00000010 2 2 00010100 20 14 10000000 128 80 00000100 4 4 00011111 31 1F 10101011 171 AB 00001000 8 8 00100000 32 20 11110000 240 F0 00001010 10 A 00111111 63 3F 11111111 255 FF 25.2 Règles d écriture communément admises Les constantes ont un nom qui commence par une majuscule, par exemple ValeurMax Les variables ont un nom qui commence par une minuscule demiperiode. Une accolade fermante est seule sur une ligne, sauf pour le do..while #define Led 13 au lieu de int Led=13; ou de const int Led=13;. On économise ainsi de la mémoire. 25.3 Comparaisons et opérations logiques 25.3.1 Comparaisons logiques Le résultat d une comparaison est : true (vrai ou 1) ou false (faux ou 0). 25.3.2 Opérations logiques et masque égal supérieur supérieur ou égal inférieur inférieur ou égal différent == > >= < <=!= Un masque noté m (dans le tableau le plus à droite dans ce paragraphe) permet de fixer à 0 ou à 1 certains bits dans un octet sans que les autres bits soient affectés même transitoirement. C est notamment important pour des opérations sur le port D pour lequel les bits 0 et 1 permettent la communication USB entre l ordinateur et la carte. a xxxxxxxx not ~ and & Or Xor ^ m 01100111 a = 10110101 a = 10100101 a = 10100101 a = 10100101 b = 00011111 b = 00011111 b = 00011111 ~ a = 01001010 a & b = 00000101 a b = 10111111 a ^ b = 10111010 25.3.3 Décalages a & m a ~m a & ~m a m 0xx00xxx 1xx11xxx x00xx000 x11xx111 unsigned signed a = 10110101 a = 10110101 a = 10110101 a = 10110101 a >> 3 = 00010110 a << 4 = 01010000 a >> 3 = 11110110 a << 4 = 01010000 26 Fonctions de base en langage C 26.1 Opérations dans un registre Chacun des ports B,C et D est associé à un registre de direction, respectivement DDRB, DDRC et DDRD. Ces registres permettent de déclarer les broches 1 à 13 en entrée (0 potentiel 0 V) ou en sortie (1 potentiel 5 V) : 26.1.1 Déclaration d une broche en sortie Par exemple, on veut déclarer la broche 13 en sortie sans changer l état des autres broches. C est donc le bit 5 du port B qui est concerné. 1. L instruction pour mettre à 1 le bit 5 de DDRB pour le mettre en sortie est : DDRB = B100000; ou DDRB = DDRB B100000; le symbole est un OU logique. On compare l état de l octet DDRB à 00100000. Le résultat est tel que seul le bit 5 est modifié. 29

exemple : 10010010 OR 00100000 = 10110010 Remarques : On aurait pu aussi écrire DDRB = 32; en décimal ou DDRB = 0x20; en hexadécimal. Ou encore DDRB = (1<<5); qui met à 1 le bit 5. En complément : (1<<2) 00000100 écrit 1 en binaire et déplace de 2 bits vers la gauche (3<<2) 00001100 écrit 3 en binaire et déplace de 2 bits vers la gauche (4>>1) 00000010 écrit 4 en binaire et déplace de 1 bit vers la droite (3>>1) 00000001 écrit 3 en binaire et déplace de 1 bit vers la droite (4>>4) 00000000 écrit 4 en binaire et déplace de 4 bits vers la droite 2. L instruction pour mettre à 1 le bit 5 de PORTB et mettre la broche 13 à 5 V : PORTB = B100000; On reprend ci-dessous le programme de clignotement de la LED 13 : void setup() DDRB = B100000; void loop() PORTB = (1<<5); delay(1000); PORTB &= ~(1<<5); delay(1000); 1<<5 écrit 1 en binaire et déplace de 5 bits vers la gauche soit 00100000 ~(1<<5) est l inverse bit à bit soit 11011111 L opération ET logique laisse inchangés tous les bits de PORTB sauf le bit 5 qui est mis à 0 exemple : 10110010 AND 11011111 = 10010010 Encore plus court : void setup() DDRB = 32; void loop() PORTB ^= (1<<5); delay(1000); 26.2 Sorties numériques Le programme ci-dessous permet de faire clignoter jusqu à 6 LEDs (chacune en série avec une résistance) sur les broches 8 à 13 ( 0,5 s allumé puis 0,5 s éteint) //#include <avr/io.h> //#include <util/delay.h> int main (void) DDRB = 0x3F;//les broches 8 à 13 sont mises en sortie while (1) PORTB = 0x3F;//les broches 8 à 13 sont portées au potentiel 5V _delay_ms(500); PORTB &= ~0x3F;//les broches 8 à 13 sont portées au potentiel 0V _delay_ms(500); return 0; Les 2 programmes équivalents ci-dessous illustrent le principe d un chenillard : celui-ci fonctionne avec 3 LEDs sur les broches 8, 9 et 10 : 30