À la découverte de l'Arduino Uno

Posté le par | Répondre

Dimanche dernier, j'ai eu le plaisir de participer à un atelier d'initiation Arduino à l'ACoLab (Atelier Collaboratif) de Clermont-Ferrand. Le but de cet atelier était d'initier les participants à l'utilisation de l'Arduino sous forme de premier contact avec l'appareil, l'installation de l'IDE Arduino, la découverte du langage utilisé par l'Arduino, la compréhension des composants électroniques employés (LED, résistance, bouton poussoir, etc...) et la réalisation de circuits.

Ce tuto a pour but de me servir d'aide mémoire et de permettre aux novices de s'initier eux-même s'ils n'ont pas la possibilité de participer à un atelier de ce type dans une Fab Lab. Je ne rentrerai volontairement pas dans tous les détails pour éviter la surcharge d'information, de nombreux liens seront à votre disposition pour approfondir les choses. Une publication très complète, élaborée par le Centre de Ressources Art Sensitif sera l'une de mes sources.

Différence entre Arduino et Raspberry Pi

Beaucoup d'entre vous on commencé à bidouiller avec un Raspberry Pi et se demandent ce que peut apporter un Arduino.

Le Raspberry Pi est donc conçu comme un ordinateur avec : un Processeur (CPU), l'équivalent d'une carte graphique - le GPU, de la mémoire vive -la RAM, de périphériques de communication - l'USB/RJ45/audio/vidéo. Le RPi a la particularité d'intégrer des ports GPIO ((General Purpose Input/Output), littéralement Entrée/Sortie pour un usage général) très utilisés dans le monde des microcontrôleurs, en particulier dans le domaine de l'électronique embarquée, qui ont fait leur apparition aux débuts des années 1980. Le connecteur GPIO offre à une carte électronique, et dans notre cas au RPi, la possibilité de communiquer avec d'autres circuits électroniques.
Pour fonctionner, le RPi a besoin d'un système d'exploitation, éventuellement d'un environnement graphique. Les ports GPIO sont contrôlés directement par le CPU. Il va donc falloir installer des logiciels afin d'utiliser un langage pour donner des ordres aux ports GPIO : on va coder, dans le langage voulu, des instructions qui seront exécutées par le CPU (qui joue dans ce cas le rôle de microcontrôleur) et qui "agiront" sur les ports GPIO.

L'Arduino est une carte conçue autour d'un microcontrôleur, munie de nombreux connecteurs numériques, analogiques, d'un connecteur pour l'alimentation de l'appareil, d'un port micro-USB pour communiquer avec un ordinateur. Le microcontrôleur est programmé pour prendre en charge tous les connecteur IO (entrées/sorties) et ne va interpréter qu'un seul type de langage (proche du langage en C++).

Pour résumer, un RPi sera plus orienté vers (l'apprentissage de) la programmation, l'utilisation en terme domotique sera plus basique. L'Arduino quant à lui est plus orienté vers des applications plus électroniques allant de l'analyse et la production de signaux électriques, de manière à effectuer des tâches très diverses comme la domotique (le contrôle des appareils domestiques - éclairage, chauffage…), le pilotage d'un robot, etc...

Même si on peut réaliser ses projets électroniques indifféremment avec un Arduino ou un RPi, l'utilisation de l'Arduino sera plus recommandée.

Découverte de l'Arduino Uno

L'Arduino est donc une plateforme open-source d'électronique programmée qui est basée sur une simple carte à microcontrôleur (de la famille AVR) et un logiciel servant d'interface entre vous (votre ordinateur) et l'Arduino créant un environnement de développement qui va vous permettre d'écrire, de compiler et de transférer un programme vers la carte Arduino.

Que l'on soit enseignants, les étudiants ou bidouilleur en herbe, l'environnement Arduino simplifie la façon de travailler avec les microcontrôleurs : il est peu coûteux, multiplateforme (Windows, Mac, GNU/Linux), son environnement de programmation est simple - clair - open source - extensible.

Partons à la découverte de notre appareil sur la partie matériel et la partie logiciel.

Côté physique de notre Arduino Uno (comme pour les différentes versions des Arduino), le fonctionnement se fait sous le même principe général :

Schema_Arduino

  • A: ce sont les pattes (pin) dites digitales (0,1) ou "tout ou rien" ; elles offrent en sortie du 5V et acceptent en entrée du 5V sur le même principe (fonction digitalWrite() et digitalRead() ). La patte 13 est équipée d'une résistance.
  • B: le microcontrôleur
  • C: ce sont les pattes dites analogiques, valeur entre 0V et 5V (fonction analogWrite() et analogRead() ).
  • D: les différentes pattes d'alimentation (utilisez tant que possible les mêmes couleurs lors de vos montages, ce sont les couleurs de référence en électronique) :
    Rouge: sortie 5v (+)
    Orange: sortie 3,3V (+)
    Noire: les masses (-)
    Jaune: entrée reliée à l'alimentation (7V-12V)
  • L'USB sert pour l'alimentation de la carte et le transfert des programmes qu'on souhaite téléverser dans le microcontrôleur.
  • L'alimentation 7V-12V servira à alimenter la carte lorsqu'elle est en production (non reliée à l'ordinateur).

Pour aller plus loin, vous pouvez consulter la liste des différents modèles Arduino sur ce site.

Côté logiciel : pour écrire, modifier ou injecter (téléverser) les programmes (le code) dans le microcontrôleur, on utilisera une interface graphique appellée IDE (Integrated Development Environment). Cet environnement de développement intégré est téléchargeable sur le site Arduino. À vous de choisir la version Windows, Mac OS ou Linux correspondant à votre système d'exploitation et de l'installer avant de raccorder la carte Arduino à votre PC.

Arduino_IDE

Fenêtre de l'IDE Arduino

  • Procédure pour Windows (Windows 7, Vista, or XP) :
    • Télécharger la dernière version sur cette page (choisir "Windows ZIP file for non admin install" de préférence),
    • Dézipper l'archive précédemment téléchargée en prenant soit de ne pas modifier la structure des dossiers,
    • Raccordez votre Arduino au PC avec le câble USB fourni. C'est le PC qui fournit l'alimentation à la carte. les LEDs "ON" et "L" s'allument. Attendre que Windows détecte un nouveau périphérique et qu'il installe le driver. S'il n'installe pas automatiquement le driver, une fenêtre s'ouvre vous invitant à choisir un driver. Pour cela, manuellement, on se déplace dans l'arborescence des dossiers et on se rend là où vous avez dézippé l'archive. Sélectionner le fichier arduino.inf situé dans le dossier "Drivers" et valider.
    • Si cela marche directement c'est bien \o/
    • sinon : Menu démarrer > Panneau de configuration > Système et Sécurité > Système > Gestionnaire de périphériques
      - Dans la fenêtre "Gestionnaire de périphériques" repérez la ligne "Ports (COM & LPT)", cliquez dessus et sélectionnez le port qui devrait être ouvert "Arduino UNO (COMxx)". S'il n'apparait pas dans la liste, cherchez dans "Autre Périphérique" ou dans "Périphérique Inconnu".
      - Une fois "Arduino UNO (COMxx)" trouvé, on clic droit dessus et on sélectionne l'option de "mise à jour du driver" > "Rechercher un pilote sur mon ordinateur".
      - On se déplace dans l'arborescence des dossiers et on se rend là où vous avez dézippé l'archive. Sélectionner le fichier arduino.inf situé dans le dossier "Drivers" et validez. Windows devrait achever l'installation du driver.
    • Si cela ne marche toujours pas, rebootez et reconnectez la carte au PC. ...et dites-vous que Linux est user-friendly, que vous allez télécharger une distribution simple et passez à la procédure pour Linux :-p
    • Lors de l'installation une icône Arduino est apparue sur votre Bureau et dans le menu "Démarrer". Double-clic pour lancer l'IDE Arduino (image ci-dessus)
    • Il ne reste plus qu'à renseigner à l'IDE sur quel port il doit communiquer avec la carte Arduino : Outils > Port > sélectionner le port COM (si cela ne s'est pas fait automatiquement)
    • Windowsiens, vous avez terminé !
  • Procédure pour les systèmes GNU/Linux :
    • Télécharger la dernière version sur cette page,
    • Dézipper l'archive précédemment téléchargée en prenant soit de ne pas modifier la structure des dossiers,
    • dans une console, cd emplacement/du/dossier/arduino et lancez l’exécutable ./arduino
    • Il ne reste plus qu'à renseigner à l'IDE sur quel port il doit communiquer avec la carte Arduino : Outils > Port > sélectionner le port COM (si cela ne s'est pas fait automatiquement)
    • En cas de message d'erreur concernant les privilèges d'utilisation des ports (le port série n'est peut-être pas accessible tant que l'utilisateur n'a pas été ajouté aux groupes "tty" et "dialout"), toujours en console :
      usermod -a -G tty Nom_Utilisateur
      usermod -a -G dialout Nom_Utilisateur
    • relancez l'IDE Arduino. Au grand pire des cas, si on ne veut pas s'embêter avec les privilèges utilisateurs (ou si l'utilisateur est administrateur) on peut lancer l'IDE en tant que SU.
  • Procédure pour les systèmes Mac OS :
    • Télécharger la dernière version sur cette page,
    • Installer le logiciel Arduino dans le dossier Applications,
    • Installer le driver de la carte fourni dans le dossier Arduino (mot de passe puis redémarrage),
    • Glisser déposer le script macosx_setup.command sur le logiciel “terminal” (qui est dans le
      dossier Applications/Utilitaires, répondre “Y” , c’est à dire Yes, à la question qui se pose. Quitter le terminal.
    • La carte est prête à accueillir un programme Utilisateur.
    • Lancez le programme.
    • Il ne reste plus qu'à renseigner à l'IDE sur quel port il doit communiquer avec la carte Arduino : Outils > Port > sélectionner le port tty.usbserial-xxx (si cela ne s'est pas fait automatiquement).

À noter : Si vous utilisez une carte Arduino différente, il faudra indiquer le modèle employé et le port utilisé.

Voilà, nous sommes désormais en mesure de travailler sur notre bel Arduino Uno tout neuf tout beau 🙂

L'IDE Arduino

Comme nous l'avons vu juste au dessus, l'IDE Arduino va être notre interface de paramètres, de contrôle et de programmation. C'est donc grâce à cet IDE que nous allons interagir avec l'Arduino.

Voyons comment est composé notre IDE :

Arduino_IDE_explications

 

  • A : Barre de menus
  • B : Barre d'outils (raccourcis les plus utiles de fonctions se trouvant dans les menus) : Vérifier le code | Téléverser le code dans le microcontrôleur | Nouveau code | Ouvrir | Enregistrer | Moniteur série (permet d'afficher des messages textes reçus de la carte Arduino et/ou d'envoyer des caractères vers la carte Arduino).
  • C : Zone d'écriture du programme
  • E : Zone de notification lors du téléversement où sera indiqué ce qui se passe et les éventuels messages d'erreur
  • F : Barre de notification du port de communication employé (utile si on utilise plusieurs Arduino).

Maintenant que nous nous sommes familiarisé avec l'IDE Arduino nous allons voir comment se compose un code de programme.

Le programme Arduino

On va commencer à mettre les mains dans le cambouis numérique. Comme lu précédemment, pour donner des instructions à notre Arduino il faut lui parler, ou plutôt lui écrire dans un langage bien spécifique car, de base l'Arduino n'en connait qu'un seul. Le but va donc être de lui rédiger un message (le programme), de l'envoyer dans le microcontrôleur (le téléverser) pour qu'il l'interprète et qu'il agisse.

Quelle est la structure du programme ?

Le programme Arduino (ou une séquence - sketch en anglais) est une suite d’instructions élémentaires sous forme textuelle, ligne par ligne. Une fois téléversé dans le microcontrôleur Arduino, notre carte lit puis effectue les instructions les unes après les autres, dans l’ordre défini par les lignes de code.

Le programme est structuré en 4 parties distinctes :

  • La première partie est une zone de commentaire (qui ne sera pas interprété par le microcontrôleur) dans lequel on renseigne en général, le nom du créateur du programme, la date de création, d'éventuels liens pointant vers une page web, les révisions (s'il y en a) et la description du programme. Cette partie n'a pas une grande importance mais elle peut vous aider à comprendre ce qu'à voulu faire le codeur de ce programme. Elle est donc aussi utile pour les autres. Cette zone de commentaire (pour ne pas être lue par le microcontrôleur et donc générer des erreurs) commencera par un /* et se terminera par un */.
  • La deuxième partie est faite pour déclarer des variables et des représentées par la fonction int. Les variables sont des expressions que vous pouvez utilisez dans les programmes pour stocker des valeurs numériques. Les constantes prédéfinies du langage Arduino sont des valeurs particulières ayant une signification spécifique.
  • La troisième partie permet de configurer les entrées et sorties. La syntaxe employée est void setup() dans laquelle on donnera le détail entre accolade par exemple : {fonction (nom, état); }
  • La quatrième et dernière partie concerne la programmation des interactions et des comportements que l'on souhaite donner à un composant électronique par exemple. La syntaxe employée est void loop() dans laquelle on donnera le détail entre accolade comme pour la configuration des entrées/sorties.

Les fonctions de base void setup() et void loop() sont obligatoires dans tout programme en langage Arduino.

Les variables sont des expressions que vous pouvez utilisez dans les programmes pour stocker des valeurs numériques.

Les différents caractères que l'on trouvera dans les codes (liste minimale) :

  • la syntaxe de base :
    • ; (point virgule) essentiel pour clore chaque fonction. il correspond à notre point en fin de ligne pour finir une phrase.
    • {} (accolades)
    • // (commentaire sur une ligne)
    • /* */ (commentaire sur plusieurs lignes)
  • les constantes prédéfinies peuvent avoir la forme dans chaque type de données void :
    • HIGH | LOW
    • INPUT | OUTPUT
    • true | false
  • pour effectuer des opérations arithmétiques :
    • = (égalité)
    • + (addition)
    • - (soustraction)
    • * (multiplication)
    • / (division)
  • les fonctions entrées/sorties numériques :
    • pinMode(broche, mode)
    • digitalWrite(broche, valeur)
    • int digitalRead(broche)
  • les entrées-sortie avancées :
    • tone()
    • noTone()
  • Pour la durée (le temps) : delay()

Cette liste minimaliste nous permettra de comprendre les programmes que nous allons étudier plus loin. Si vous souhaitez prendre connaissance d'une liste beaucoup plus complète, je vous invite à visiter ce lien.

Il est temps de passer à un exemple concret pour mieux comprendre le langage Arduino. Pour cela nous aurons uniquement besoin que la carte raccordée au PC, IDE ouverte bien sûr.

<!–nextpage–>

Exemple simple : faire clignoter une LED de l'Arduino

Un grand nombre de programmes est compris dans L'IDE de l'Arduino. Pour afficher un programme, on va le chercher dans Fichier > Exemple > 01.Basics > Blink

Une nouvelle fenêtre s'ouvre avec le programme correspondant à notre choix. Pour l'instant notre Ardiuno est alimenté et seules les LEDs "ON" et "L" sont allumée de manière permanentes. Voyons de plus près le code :

Arduino_blink

  • Partie 1 : le commentaire (entre /* et */ ) expliquant à quoi sert ce code, sa date de modification et l'auteur.
  • Partie 2 : la configuration des entrées et sorties, la fonction s'exécute une seule fois lors de la mise sous tension de la carte ou lorsqu'on presse le bouton reset de la carte (bouton rouge). La fonction pinMode permet d'initialiser le pin 13 et le déclare comme sortie (celui qui sera utilisée). Le pin 13 correspond à la LED "L" sur la carte.
  • Partie 3 : la fonction loop s'exécute ensuite en boucle toutes les fonctions comprises dans son accolade :
    • allume (HIGH) la LED n°13 : digitalWrite(13, HIGH);
    • pendant une durée de 1000 millisecondes : delay(1000);
    • éteint (LOW) la LED n°13 : digitalWrite(13, LOW);
    • pendant une durée de 1000 millisecondes : delay(1000);

Pour les non-initiés curieux, je vais traduire en français : lorsque le programme est téléversé dans le microcontrôleur, il va ignorer le commentaire, initialiser la LED 13 comme signal de sortie puis va lire en boucle et donner les instructions à la LED concernée s'allumer durant 1 seconde puis s'éteindre durant une seconde (ainsi de suite).

Vous avez compris le mode de fonctionnement, maintenant téléversez le programme. Les LEDs "RX" et "TX" s'affolent, c'est normal elles correspondent à la réception/émission de données, le transfert du programme s'est bien déroulé. La LED 13 ("L" sur la carte) clignote. Vous venez de réussir avec succès une première étape dans l'apprivoisement de votre Arduino.

Comme on n'a pas peur et qu'on a pigé le truc, on va faire clignoter la LED plus rapidement. Très simplement, nous allons modifier la valeur delay() pour la passer à 200 (soit 0,2 seconde) puis on le téléverse.

Utilisation de l'Arduino avec un circuit électronique simple

Rapide retour sur les notions d'électricité : l'électricité est le résultat d'une interaction de particules qui sont chargées positivement ou négativement et dont les effets peuvent être utilisés pour générer de l’énergie. Dans un circuit, ces particules se déplacent au travers d'un conducteur de la borne + vers la borne -. Même si cela n'a pas grande importance, il est bon, lorsque vous allez monter votre circuit, il est bon de commencer ce circuit sur la breadboard par la borne + et de terminer par la borne -. Pour approfondir vos notions, cette page peut vous aider.

Dans cet exercice, nous allons faire clignoter une LED en utilisant le même programme que pour le précédent exercice et en concevant un circuit électronique simple.

Concevoir un circuit électronique est relativement simple, et, pour cela, nous allons utiliser une breadboard (littéralement une planche à pain, qu'on appelle aussi platine d'expérimentation ou carte de test), une LED, une résistance (pour canaliser la tension de la LED insatiable) et de quelques cordons mâle/mâle :

  • La breadboard (platine d'expérimentation ou carte de test) :
    Il est nécessaire de comprendre comment fonctionne la breadboard pour comprendre comment les trous cette carte de test sont reliés entre eux. C'est un support qui permet de connecter des composants électroniques à d'autres sans avoir de les souder. Ce genre de carte d'expérimentation est souvent utilisé pour tester une conception de circuit avant de créer une carte de circuit imprimé (PCB).
RPi breadboard

RPi breadboard

La rangée supérieure de trous sont tous reliés entre eux (marqué avec des points rouges dans le schéma ci-dessus et avec une ligne rouge sur la carte de test), de même pour la deuxième rangée de trous (marquée par des points bleus). Il en est de même pour les rangées inférieures (marquées en rouge pour l'un, en bleu pour l'autre). Ces lignes sont généralement utilisées pour la masse (GND) et la puissance (PWR), ce qui signifie que les lignes bleues sont reliés à la masse (0 V) et des lignes rouges à l'alimentation (3,3 V ou 5V).
La partie du milieu est divisée en deux : les trous dans les colonnes sont reliés entre eux avec une pause au centre. Ainsi, par exemple, tous les trous verts marqués sont reliés entre eux, mais ils ne sont pas connectés aux trous jaunes, ni les violets. Par conséquent, n'importe quel fil que vous piquez dans les trous verts sera connecté à d'autres fils passant dans les autres trous verts.

  • La LED (diode électro-luminescente) : lorsque vous observez une LED, vous notez que l'un des connecteurs est plus long que l'autre. Le plus long (anode) sera connecté à la borne positive du circuit, alors que le plus court (cathode) sera connecté à la borne négative aussi appelée "ground" (GND) ou "masse". Les LEDs ne fonctionneront que si l'alimentation électrique se fait dans le bon sens (polarité correcte). Vous ne risquez pas d'endommager les LEDs si elle ne sont pas connectées dans le bon sens, elles ne s'allumeront simplement pas.
    Il est impératif d'utiliser une résistance conjointement à la LED : l'Arduino ne fournissant qu'un courant de faible intensité (environ 60mA) alors que les LEDs chercheront à "tirer" davantage, et, si on les laisse faire, cela peut endommager l'Arduino. Par conséquent mettre les résistances dans le circuit garantira que seul ce faible courant circule.
  • La résistance : très utiles car elles sont un moyen de limiter la quantité d'électricité passant par un circuit, plus précisément, elles limitent la quantité de "courant" (tension) qui est autorisée à circuler. La mesure de la résistance est appelée Ohm (Ω). Plus la résistance est grande, plus elle limite le courant. La valeur d'une résistance est indiquée par des bandes de couleur le long de la longueur du corps de résistance. Ici nous utiliseront une résistance de 150 Ω.
  • Les cordons sont utilisés sur les platines d'expérimentation pour "sauter" d'une connexion à une autre. Pour ne pas trop se perdre dans le rôle des cordons, il est conseillé d'utiliser les couleurs noir pour la masse et le rouge pour le +.

 

Rien ne vaut la pratique pour mieux comprendre la théorie : la breadboard sera alimentée par l'Arduino par les pattes d'alimentations "13" (A sur le premier schéma) et "GND" (D sur le premier schéma). Le circuit passera par la résistance, puis la diode et enfin sortira. Je conçois toujours un circuit en commençant par le + pour finir par le -. À vous de jouer.

Vous devriez avoir quelque chose qui ressemble à cela :

Arduino-BB-Blink-LED

 

Si vous avez fait le branchement "à chaud" (Arduino sous tension), la LED "L" de l'Arduino continue à clignoter ainsi que la LED de la breadboard de manière synchrone. Pour jouer avec le résultat de votre circuit, modifiez le delay() du programme et appliquez les changements.

Challenge pour mettre en pratique les éléments que nous venons d'apprendre

Avec ce circuit électronique simple, et pour aller plus loin, nous allons maintenant faire joujou avec le code du programme avec trois petits challenges :

  • Sans modifier le câblage, modifier le code pour déclarer toutes les variables (int) que nous utilisons dans la configuration des entrées/sorties dans void setup() et des actions dans void loop(). Pour cela, sauvegardez (donnez-lui un p'tit nom) votre croquis "Blink" précédemment utilisé pour le modifier à nouveau. Voilà ce que l'on sait :
    • on utilise la LED 13 dans le void setup()
    • on allume cette LED durant 200 millisecondes dans void loop()
    • on éteint cette LED durant 200 millisecondes dans void loop()

    On va donc créer des variables qui seront ensuite utilisées dans void setup() et dans void loop(). L'intérêt de déclarer des variables prend tout sont sens lorsqu'on utilise de nombreuses entrées/sorties  et/ou que l'on souhaite les nommer.  Par exemple :

    /*
    Déclaration des variables.
    Basé sur : l'exemple Blink by Scott Fitzgerald
    */
    
    // Déclaration des variables.
    int LedUno = 13; // déclaration de la LED de l'Arduino
    int delayLedUnoON = 200; // durée de la phase allumée
    int delayLedUnoOFF = 200; // durée de la phase éteinte
    
    void setup() {
    pinMode(LedUno, OUTPUT); // initialisation du pin 13 comme sortie
    }
    
    void loop() {
    digitalWrite(LedUno, HIGH); // Allume la LED de l'Arduino
    delay(delayLedUnoON); // durée
    digitalWrite(LedUno, LOW); // Éteint la LED de l'Arduino
    delay(delayLedUnoOFF); //durée
    }

    En téléversant on se rend compte que cela fonctionne de manière identique que dans l'exercice précédent. Tout baigne, alors mettons un peu de piment 🙂

  • Modifiez votre code "Blink" (et le câblage Arduino/breadboard) pour faire clignoter la LED "L" de l'Arduino différemment de la LED-breadboard. La LED de la breadboard correspondra au pin 12. Le code du programme devrait ressembler à quelque chose comme ça :
/*
Blink LED breadboard vs LED Arduino
Déclaration des variables grâce à int
La LED rouge de l'Arduino clignote à une fréquence différente
de la LED de la breadboard.

Basé sur : l'exemple Blink by Scott Fitzgerald
*/

// Déclaration des variables.
int LED = 12; // déclaration de la LED de l'arduino
int delayLEDON = 150;
int delayLEDOFF = 150;
int LedUno = 13; // déclaration de la LED de l'arduino
int delayLedUnoON = 200;
int delayLedUnoOFF = 200;
// Cette fonction ne s'exécute que lorsque l'Arduino est
// sous tension ou que l'on presse le bouton "reset".
void setup() {
pinMode(LED, OUTPUT); // initialisation du pin digital 12 comme sortie
pinMode(LedUno, OUTPUT); // initialisation du pin 13 comme sortie
}

// Cette fonction exécute les instructions en boucle.
void loop() {
digitalWrite(LED, HIGH); // Allume la LED de la bb 
delay(delayLEDON); // durée de la précédente instruction
digitalWrite(LED, LOW); // Éteint la LED de la bb
delay(delayLEDOFF); // durée de la précédente instruction
digitalWrite(LedUno, HIGH); // Allume la LED de l'Arduino
delay(delayLedUnoON); // durée
digitalWrite(LedUno, LOW); // Éteint la LED de l'Arduino
delay(delayLedUnoOFF); //durée
}
  • modifiez votre code "Blink" (et le câblage Arduino/breadboard si nécessaire) pour arrêter la clignotement de la LED "L" de l'Arduino et laisser la LED-breadboard clignoter à une durée de 0,5 secondes. Pour cela :
    • on déclare les deux LEDs,
    • on déclare uniquement les durées de la LED de la breadboard 500 millisecondes,
    • on initialise les deux LEDs comme sortie
    • lors de l'exécution en boucle on impose à la LED de l'Arduino de rester éteinte.
    /*
    Blink LED breadboard vs LED Arduino
    Déclaration des variables grâce à int
    La LED rouge de l'Arduino clignote à une fréquence différente
    de la LED de la breadboard.
    Basé sur : l'exemple Blink by Scott Fitzgerald
    */
    
    int LED = 12; // déclaration de la LED de l'Arduino
    int delayLEDON = 500;
    int delayLEDOFF = 500;
    int LedUno = 13; // déclaration de la LED de l'Arduino
    
    void setup() {
    pinMode(LED, OUTPUT); // initialisation du pin digital 12 comme sortie
    pinMode(LedUno, OUTPUT); // initialisation du pin 13 comme sortie
    }
    
    void loop() {
    digitalWrite(LED, HIGH); // Allume la LED de la bb 
    delay(delayLEDON); // durée de la précédente instruction
    digitalWrite(LED, LOW); // Éteint la LED de la bb
    delay(delayLEDOFF); // durée de la précédente instruction
    digitalWrite(LedUno, LOW); // Éteint la LED de l'Arduino
    }

Vous êtes arrivé jusque là, félicitations! Vous venez que comprendre les bases de L'Arduino, de son environnement de développement (IDE) et de son langage.

J'espère que ce guide vous a aidé et surtout motivé à poursuivre de petits ou grands projets avec votre Arduino. Si vous êtes craintif, peu sûr de vous, je vous encourage vivement à vous rapprocher d'une Fab Lab la plus proche de chez vous car les équipes sont fantastiques, à l'écoute et peuvent, pas à pas vous diriger et répondre à toutes vos questions. J'en profite pour remercier Thomas, Baptiste et Jean-Marc de l'ACoLab de Clermont-Ferrand qui ont animé avec brio l'atelier d'initiation. Nous avons été pris par le temps, nous nous réunirons à nouveau pour l'utilisation de potentiomètres linéaires, boutons poussoirs et d'un double afficheur 7 segments. À suivre donc ... 🙂

Catégorie : Arduino | Tags : , , ,

Licence Creative Commons
Cet article, sauf mention contraire expresse, est publié sous licence Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported Licence.

Vous avez aimé cet article ? Alors partagez-le avec vos amis en cliquant sur les boutons ci-dessous :
Google Plus Twitter Facebook Linkedin Framasphere email Flattr !

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *