IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Cours complet pour apprendre à programmer un Arduino


précédentsommairesuivant

XVII. Texte brillant

Ce projet permet de monter plusieurs LED sur une carte Arduino. Les LED sont ensuite pilotées à partir de certaines touches du clavier de votre ordinateur pour en faire un magnifique jeu de lumière. Dans ce projet, nous utiliserons d'abord le moniteur sériel pour activer les lumières, puis nous montrerons un exemple avec le logiciel libre Pure-Data (http://puredata.info/).

Image non disponible

XVII-A. Principe de fonctionnement

Des caractères sont saisis à partir du moniteur sériel de l'interface de programmation Arduino pour allumer et éteindre les LED.

  • Saisir 'R ou r' pour allumer la LED rouge.
  • Saisir 'J ou j' pour allumer la LED jaune.
  • Saisir' V ou v' pour allumer la LED verte.
  • Saisir 'B ou b' pour allumer la LED bleue.
  • Saisir 'E ou e' pour éteindre les LED.

XVII-A-1. Matériel nécessaire

  1. Carte Arduino Duemilanove.
  2. Platine de prototypage.
  3. Quatre LED (rouge, verte, jaune et bleue).
  4. Quatre résistances (130, 60, 130, 60  hms).
  5. Fils de connexion.

XVII-B. Première étape : le montage du circuit

Image non disponible

Les LED, leur résistance appropriée et le fil de connexion sont montés sur la platine d'essai. L'anode (patte positive) de chacune des LED est connectée à une résistance reliée à une pin numérique de la carte : la LED rouge est reliée à la pin 2, la jaune à la pin 4, la LED verte à la pin 6 et la LED bleue, à la pin 8.

La cathode (patte négative) de chacune des LED est connectée à un fil de connexion relié à une des pins GND de la carte. Les LED rouge et jaune utilisent chacune une résistance de 130 ohms et les LED verte et bleue une résistance de 60 ohms.

Après avoir réalisé le montage du circuit, il faut connecter la carte sur le port USB et lancer le logiciel Arduino pour y écrire le code de pilotage des LED.

XVII-C. Deuxième partie : le programme

Copiez le programme suivant dans la fenêtre de programmation d'Arduino :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
//Déclaration des pins sur lesquelles sont connectées les LED

int pinLed3 = 8; // LED Bleue
int pinLed2 = 6; // LED Verte
int pinLed1 = 4; // LED Jaune
int pinLed0 = 2; // LED Rouge

//Déclaration de la variable contenant la valeur de la touche saisie au clavier

int octetRecu;
 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
void setup() {

    // Initialisation de la communication série

    Serial.begin(9600);

    // Configuration des pins en sortie

    // il est important pour le bon fonctionnement du montage de spécifier quelles pins seront utilisées comme sortie.

    pinMode(pinLed0, OUTPUT);
    pinMode(pinLed1, OUTPUT);
    pinMode(pinLed2, OUTPUT);
    pinMode(pinLed3, OUTPUT);
}
 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
void loop() {
    // Vérifie si il y a une donnée sérielle disponible
    if (Serial.available() > 0) {
        // Lecture de l'octet présent dans la mémoire tampon (buffer)
        octetRecu = Serial.read();

        if (octetRecu == 'R' || octetRecu == 'r') { //Si l'octet reçu est égal à R ou r
            digitalWrite(pinLed0, HIGH); //Allumer la LED connectée à pinLed0
            Serial.println("LED Rouge allumee"); //Afficher "LED Rouge allumée" dans le moniteur série
        }

        if (octetRecu == 'J' || octetRecu == 'j') { //Si l'octet reçu est égal à J ou j
            digitalWrite(pinLed1, HIGH); //Allumer la LED connectée à pinLed1
            Serial.println("LED Jaune allumee"); //Afficher "LED Jaune allumée" dans le moniteur série
        }

        if (octetRecu == 'V' || octetRecu == 'v') { //Si l'octet reçu est égal à V ou v
            digitalWrite(pinLed2, HIGH); //Allumer la LED connectée à pinLed2
            Serial.println("LED Verte allumee"); //Afficher "LED Verte allumée" dans le moniteur série
        }

        if (octetRecu == 'B' || octetRecu == 'b') { //Si l'octet reçu est égal à B ou b
            digitalWrite(pinLed3, HIGH); //Allumer la LED connectée à pinLed3
            Serial.println("LED Bleue allumee"); //Afficher "LED Bleue allumée" dans le moniteur série
        }

        if (octetRecu == 'E' || octetRecu == 'e') { //Si l'octet reçu est égal à E ou e
            //Éteindre les LED connectées aux pinLed0, pinLed1, pinLed2 et pinLed3
            digitalWrite(pinLed0, LOW);
            digitalWrite(pinLed1, LOW);
            digitalWrite(pinLed2, LOW);
            digitalWrite(pinLed3, LOW);
            //Afficher "LED éteinte" dans le moniteur série
            Serial.println("LED eteinte");
        }
    }
}

XVII-C-1. Déclaration des variables

Le caractère saisi au clavier ainsi que le numéro de la pin sur laquelle est connectée la LED à allumer sont stockés dans des variables déclarées au début du programme.

  • Déclaration des variables stockant les numéros de pin :
 
Sélectionnez
1.
2.
3.
4.
int pinLed3 = 8; // LED Bleue
int pinLed2 = 6; // LED Verte
int pinLed1 = 4; // LED Jaune
int pinLed0 = 2; // LED Rouge
  • Déclaration de la variable stockant la valeur du caractère saisi au clavier :
 
Sélectionnez
int octetRecu;
XVII-C-1-a. Initialisation et configuration

La communication sérielle entre l'ordinateur et la carte Arduino doit se faire à la même vitesse. Dans ce projet, nous utilisons une vitesse de 9600 Bauds. Il faut donc indiquer dans l'initialisation, la vitesse de la communication avec l'instruction :

 
Sélectionnez
Serial.begin (9600);

Certains logiciels ou périphériques peuvent fonctionner à d'autres vitesses, il serait donc nécessaire dans ces cas de modifier la commande précédente pour utiliser la bonne vitesse.

Une fois cette instruction réalisée, les ports sur lesquels sont connectées les LED sont configurés en sortie pour indiquer à la carte que des signaux seront envoyés de l'ordinateur vers les pins. La configuration se fait avec l'instruction pinMode().

 
Sélectionnez
1.
2.
3.
4.
pinMode(pinLed0, OUTPUT);
pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
XVII-C-1-b. Boucle principale

Le cœur du code de pilotage des LED se trouve dans la boucle principale ; les instructions qui s'y trouvent s'exécuteront aussi longtemps que la carte sera connectée à l'ordinateur.

C'est dans cette partie que la lecture du caractère saisi et la correspondance avec l'instruction d'allumage, et l'extinction des LED sont définies.

Puisque c'est à partir du clavier que le pilotage s'effectue, le programme est toujours en attente de saisie d'un caractère ; les instructions de pilotage sont donc contenues dans la structure :

 
Sélectionnez
1.
2.
3.
4.
if (Serial.available () > 0) {
    ...
    ...
}

Lorsque le moniteur sériel ou tout autre programme envoie une information sérielle à la carte Arduino, la donnée est stockée en mémoire par le port sériel de l'Arduino, et elle y demeurera jusqu'à ce qu'elle soit lue par la fonction Serial.read(). D'autre part, la fonction Serial.available() retourne une valeur correspondant au nombre de données qui sont contenues dans le port. Si elle est plus grande que 0, cela signifie qu'il y a au moins une donnée présente dans le port (et qu'il faut donc aller la lire).

La structure précédente vérifie donc tout au long de l'exécution du programme s'il y a une donnée sérielle reçue par l'Arduino qui est en attente d'être lue ; si c'est le cas, le programme la lit.

  • Lecture du caractère saisi :

La lecture du caractère se fait avec l'instruction Serial.read().

 
Sélectionnez
octetRecu = Serial.read ();

La donnée lue est ensuite stockée dans la variable octetRecu et retirée de la mémoire du port sériel de l'Arduino.

  • Allumage et extinction des LED.

La valeur de la variable est ensuite analysée dans le but d'effectuer la correspondance entre le caractère saisi et la LED appropriée comme indiqué dans le principe de fonctionnement. Dans le reste du code, les commentaires à la fin de chaque ligne expliquent les instructions.

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
if (octetRecu =='R'|| octetRecu =='r') { //Si l'octet reçu est égal à R ou r
    digitalWrite (pinLed0,  HIGH); //Allumer la LED connectée à pinLed0
    Serial.println ("LED Rouge allumée"); //Afficher "LED Rouge allumée" dans le moniteur série
}

if (octetRecu =='J'|| octetRecu =='j') { //Si l'octet reçu est égal à J ou j
    digitalWrite (pinLed1,  HIGH); //Allumer la LED connectée à pinLed1
    Serial.println ("LED Jaune allumée"); //Afficher "LED Jaune allumée" dans le moniteur série
}

if (octetRecu =='V'|| octetRecu =='v') { //Si l'octet reçu est égal à V ou v
    digitalWrite (pinLed2,  HIGH); //Allumer la LED connectée à pinLed2
    Serial.println ("LED Verte allumée"); //Afficher "LED Verte allumée" dans le moniteur série
}

if (octetRecu =='B'|| octetRecu =='b') { //Si l'octet reçu est égal à B ou b
    digitalWrite (pinLed3,  HIGH); //Allumer la LED connectée à pinLed3
    Serial.println ("LED Bleue allumée"); //Afficher "LED Bleue allumée" dans le moniteur série
}

if (octetRecu =='E'|| octetRecu =='e') { //Si l'octet reçu est égal à E ou e
    //Éteindre les LED connectées aux pinLed0,  pinLed1,  pinLed2 et pinLed3
    digitalWrite (pinLed0,  LOW);
    digitalWrite (pinLed1,  LOW);
    digitalWrite (pinLed2,  LOW);
    digitalWrite (pinLed3,  LOW);
    //Afficher "LED éteinte" dans le moniteur série  
    Serial.println ("LED éteinte");
}

L'image qui suit montre le résultat de la saisie d'un caractère 'R' suivi de celle du caractère 'E' dans le moniteur sériel.

Image non disponible

La vitesse de communication mentionnée sur le moniteur sériel est la même que celle indiquée dans la fonction Serial.begin(). Comme le port sériel de la carte Arduino peut recevoir plusieurs données consécutivement, il est possible de s'amuser en envoyant des combinaisons de lettres. Par exemple, envoyer d'un même coup les lettres « ERV » avec le moniteur sériel fera d'abord éteindre les LED, puis allumer la rouge et la verte quasi instantanément.

XVII-D. Bonus : programme Pure Data

Image non disponible

L'image ci-dessus est celle d'un programme Pure Data destiné au pilotage des LED connectées à la carte, lancez-le après avoir connecté la carte Arduino à l'ordinateur et téléversé le code ci-dessus.

Voyons en détail le fonctionnement de ce programme :

XVII-D-1. Ouverture et fermeture du port série

Image non disponible

En cliquant sur le message « devices », les ports USB sur lesquels sont connectées les cartes Arduino ainsi que leur numéro apparaissent.

Image non disponible

Dans notre cas, la carte est connectée sur /dev/ttyUSB0 et a 4 comme numéro de port.

Cliquer sur « open 4 » pour ouvrir le port numéro 4 et « close 4 » pour le fermer. Les messages « open » et « close » doivent être suivis du bon numéro de port (celui qui s'affiche en cliquant sur « devices »).

XVII-D-1-a. Traitement effectué sur les caractères
Image non disponible

Cette image est celle des commentaires sur la correspondance entre les caractères à saisir et les valeurs à envoyer à la carte.

Image non disponible

L'objet « key » lit le caractère saisi au clavier et renvoie sa correspondance en chiffre. Les valeurs correspondantes aux caractères indiqués dans le principe de fonctionnement sont sélectionnées avec l'objet « sel » et envoyées à l'objet « comport ».

Image non disponible

Cet objet fait office d'interface avec le port sériel et communique à une vitesse de 9600 bauds.

XVII-D-2. Remarque

Les caractères saisis et reçus par port sériel sont convertis en octet (conversion ASCII) avant d'être envoyés à la carte.

Pour plus d'informations sur la communication série visitez le site : http://wiki.t-o-f.info/index.php?n=Arduino.CommunicationS%C3%A9rie.

Pour plus d'informations sur le code ASCII des caractères visitez le site : http://www.asciitable.com/

Le montage de cet exemple est effectué à titre expérimental avec quatre LED ; la carte Arduino Duemilanove comporte 14 sorties numériques. Ainsi, d'autres LED pourraient être connectées sur les autres ports de la carte. Pour contrôler encore davantage de LED, il serait possible d'utiliser des circuits intégrés appelés multiplexeurs.

Il faut toujours prendre le soin de vérifier la résistance appropriée à chacune des LED avant de les ajouter au circuit pour ne pas les « brûler » (Voir Section Électronique ; Chapitre Précautions d'utilisation, Protection des composantsProtection des composants.


précédentsommairesuivant

Ce cours est publié sous licence GPLv2, peut être lu et copié librement.