Tour d'Horizon de la Plateforme Arduino

L'Arduino version Duemilanove (“2009”) est une carte basée sur le microcontrôleur ATmega168 ou ATmega328.

Il possède

• 14 entrées/sorties digitales (dont 6 peuvent être utilisées comme des sorties PWM “Pulse Width Modulation”).
• 6 sorties analogiques
• une horloge à 16 MHz
• un connecteur USB (adaptateur du port série, et alimentation)
• un jack d'alimentation (alternative à l'alimentation par l'USB)
• des broches pour l'ICSP (In-Circuit Serial Programming)
• un bouton RESET

Plus de détails sur la carte...

A faire: description, utilisation

• http://www.arduino.cc
• http://www.atmel.com
• Arduino Duemilamove
• Le schéma

On peut utiliser les outils de son choix (gcc …) mais le plus simple pour commencer est probablement d'installer l'environnement proposé ici .

Pour les machines 64 bits , des problèmes ont été rapportés concernant les librairies java de communication (RXTX) et l'outil de manipulation des ROM et EEPROM des microcontrôleurs AVR, avrdude (détails). Mais dans le monde du Libre, les choses s'arrangent rapidement et je vous conseille de vous reporter à la page officielle pour connaître la solution actuelle.

Le jour de l'atelier, la version la plus récente était arduino-0017.tgz, ou http://chemicaloliver.net/code/arduino-0017.tgz pour les machines 64 bits.

Télécharger l'archive et la décompresser dans le répertoire de son choix, par exemple ~/arduino/tools/ , ~/installs/ ou /usr/local/share/ si vous avez les permissions nécessaires.

Par exemple:

cd ~/installs/
wget http://arduino.googlecode.com/files/arduino-0017.tgz
tar xzvf arduino-0017.tgz
ln -s arduino-0017 arduino

- la machine virtuelle java de Sun:

sudo apt-get install sun-java6-jre

• les librairies (C++) nécessaires à la compilation des programmes pour l'Arduino (AVR Atmel):

sudo apt-get install gcc-avr avr-libc

• Autres outils (optionels)
  • minicom : utiliser le port série en ligne de commandes

Le script shell 'arduino' lance java avec les arguments nécessaires, à condition d'être lancé depuis le répertoire d'installation .

cd arduino-0017
./arduino

Plus d'infos...

ref: http://arduino.cc/en/Tutorial/Blink

L'Arduino intègre une LED que l'on peut contrôler via le port digital 13. On peut également monter une LED externe, entre la masse GND et un port digital de son choix. Si on choisit le port 13, la LED externe devrait fonctionner en même temps que la LED intégrée.

Les LEDs sont des diodes, elles ont donc une polarité et ne laissent passer le courant que dans un sens, tout en émettant de la lumière. Typiquement, la patte positive est plus longue, c'est celle qu'on doit relier à la borne 13 de l'Arduino (la plus courte va sur GND) .

Si la LED ne s'allume pas, essayez de la monter (brièvement pour ne pas risquer de l'abîmer) dans l'autre sens.

Attention: Ce montage est possible car le port n°13 est connecté à une résitance de 1k, qui limitera le courant dans la LED. Si on choisit un port différent, il nous faut ajouter nous-même une résistance.

Entraînons-nous à calculer sa valeur optimale:

• intensité maximale : 10 à 30 mA
• intensité souhaitée : 8 mA
• tension de seuil : 1.83 V

R = U/I = 1.83 / 0.008 = 228.75 ohm

En théorie, la résistance peut être placée d'un côté ou l'autre de la LED, mais en pratique on préfère souvent la mettre du côté positif (en amont).

Il nous reste à choisir parmi les composants disponibles ou dans les séries de valeurs normales et à consulter le code de couleur des résistances pour dénicher la bête.

Dans la série E3, on prendra donc une résistance de 470 ohm, qui se reconnaît par ses anneaux jaune(4), violet(7) , marron(x10) .

Question: Quelle intensité de courant parcourt la LED dans le montage simple sur le port n° 13 ?

L'Arduino se programme en C++, en utilisant des bibliothèques spécifiques.

Depuis l'IDE arduino, charger l'exemple 'Blink': File → Examples → Digital → Blink

Examinons le code (j'ai traduit les commentaires, pour aider):

La ligne

int ledPin =  13;    // La LED est connectée au port digital no 13

déclare une variable (ici utilisée comme une constante) qui contient le numéro du port digital choisi.

Ce numéro pourra ainsi être utilisé en de nombreux endroits du code, mais sa valeur réelle (litérale) n'est écrite qu'une seule fois. De cette façon, si on décide de changer,

• une seule ligne est à modifier dans le code source
• le code source est plus lisible, plus facile à comprendre.

x On utilisera aussi les constantes prédéfinies 'HIGH', 'LOW', 'OUTPUT'.

Elle nous sert simplement ici à définir comment les ports seront utilisés.

On utilise la fonction pinMode() en précisant la constante prédéfinie OUTPUT en argument.

// La méthode 'setup()' est lancée une seule fois, lorsque le programme démarre
 void setup()   {                
   // définit le port 'ledPin' comme une sortie
   pinMode(ledPin, OUTPUT);     
 }

Son exécution démarrera juste après l'initialisation, et recommencera jusqu'à ce que l'Arduino soit réinitialisé.

Pour allumer la LED, il suffit de sortir une tension suffisante sur 'ledPin'. La fonction digitalWrite() permet de basculer entre 0 volt (LOW) et 5 ou 3.3 (HIGH) volts selon les cartes.

Pour que l'on puisse percevoir le clignotement de la LED, il faut introduire une pause entre les instructions: delay() .

// La methode 'loop()' tourne en boucle tant que l'Arduino est sous tension.
 void loop()                     
 {
   digitalWrite(ledPin, HIGH);   // allume la LED
   delay(1000);                  // attend une seconde (1000ms)
   digitalWrite(ledPin, LOW);    // éteint la LED
   delay(1000);                  // attend une seconde
 }

1. Vérifier et compiler le programme
2. Connecter l'Arduino au PC par le port USB
3. Charger le binaire sur l'Arduino:
   • Menu File → Upload to I/O Board, ou
   • Ctrl-U , ou
   • Clic dans la barre d'outils “Upload”

La LED intégrée de l'Arduino se met à clignoter rapidement pendant quelques secondes, puis le programme se lance … Alors ça marche ?

Normalement le programme tourne “indéfiniment” mais on peut

• appuyer sur le bonton RESET
• le priver d'alimentation (débrancher l'USB)
• charger un autre programme à la place

Inchangé. Cette fois, la connection USB est utilisée à la fois pour l'alimentation et les communications série.

Les librairies arduino nous proposent en standard le module Serial qui va nous permettre d'exploiter les communications série :p

Pour initialiser le port série, nous devons préciser la vitesse de transmission.

// La méthode 'setup()' est lancée une seule fois, lorsque le programme démarre
 void setup()   {                
   // définit le port 'ledPin' comme une sortie
   pinMode(ledPin, OUTPUT);     
   // initialise le port série avec un bitrate de 9600 bauds
  Serial.begin(9600);   
 }

On utilise la méthode Serial.println() pour émettre une chaîne formattée sur le port série, qui pourra être interceptée sur le PC pour affichage.

// La methode 'loop()' tourne en boucle tant que l'Arduino est sous tension.
void loop() {
  Serial.println("J'allume la LED");  // affichage sur le PC
  digitalWrite(ledPin, HIGH);         // allume la LED
  delay(1000);                        // attend une seconde (1000ms)
 
  Serial.println("J'éteins la LED");  // affichage sur le PC
  digitalWrite(ledPin, LOW);          // éteint la LED
  delay(3000);                        // attend trois secondes
 }

L'IDE arduino permet d'afficher directement une console de communication série. Sinon, on peut utiliser minicom pour faire la même chose dans une fenêtre de terminal.

Le code ASCII de base, conçu pour l'anglais, ne comporte que 128 valeurs possibles (7 bits), ce qui exclut les caractères accentués et bien d'autres symboles disponibles en unicode. Dès qu'on veut les utiliser, il faut préciser de chaque côté (émetteur, récepteur) quel encodage on utilise, parmi les nombreux disponibles. Les languages de haut niveau actuels imposent de le préciser dans tous les cas.

Cette fois-ci on va utiliser le port série d'une part en lecture, et d'autre part en écriture.

A chaque tour de boucle, on va tout d'abord inspecter l'entrée série pour savoir si quelque chose a été transmis du PC : Serial.available(). Notez que Serial.read() est non bloquante et retourne -1 si le tampon d'entrée est vide.

Ensuite, selon la valeur du premier caractère dans la file (switch), on va allumer, éteindre la LED, ou afficher un message explicatif.

void loop() {
  char cmd;
  if (Serial.available()>0) { // au moins 1 caractère entré ?
    cmd = Serial.read();      // lit un caractère
    switch(cmd) {
      case 'o':               // O minuscule ou majuscule
      case 'O':
        led_on();  
        break;                // sortie du switch{}
      case 'n':               // N minuscule ou majuscule
      case 'N':
        led_off();
        break;                
    default:                  // autres cas
      Serial.println("Taper 'O' pour allumer, 'N' pour éteindre" );
  }
 }
}

Pour plus de clarté et de facilité pour faire évoluer le programme, les lignes de code qui exécutent directement les actions demandées ont été extraites dans des fonctions dédiées, 'led_on()' et 'led_off()' (refactoring).

/// Allume la LED, en affichant un message
void led_on() {
  Serial.println("J'allume la LED");
  digitalWrite(ledPin, HIGH);   // set the LED on
}
 
/// Eteint la LED, en affichant un message
void led_off() {
  Serial.println("J'éteins la LED");
  digitalWrite(ledPin, LOW);    // set the LED off
}

• Haut: Initiation à l'électronique
• Précédent: Session 0 - Quelques rappels théoriques
• Suivant : Session 2 - Capteur de temperature

arduino_dossier_ressource.pdf

arduino-pour-bien-commencer-en-electronique-et-en-programmation.pdf

arduino_tp.pdf