Arduino : getting started

Getting started

Ecrire un sketch

Langage et référence

Les programmes écrit pour Arduino ont un nom particulier appelé "Sketch", vous retrouverez ce terme partout dans les documentations que vous pouvez trouver. Les fichiers écrit pour ces Sketch sont des ".ino" et sont écrit en utilisant le langage Processing. Ce langage a une syntaxe qui est très proche du C (également au niveau des types, structures etc) et va permettre avec la librairie de manipuler les entrées/sorties, les communications avec le PC, de faire des opérations mathématiques et encore de faire des conversions de type. Pour plus d'informations sur le langage, on peut consulter cette page.

4 étapes

La programmation d'un Arduino se fait en 4 étapes très simples :

  1. Brancher l’arduino en USB
  2. Ecrire un sketch
  3. Uploader le sketch sur l’arduino via l’USB
  4. L’arduino exécute le code tant qu’il est alimenté

Structure du code

Afin de simplifier les développements, chaque programme Arduino (Sketch) est articulé sur une structure de code bien définie. Celle-ci est composé de deux fonctions, la première étant setup() qui est appelé une seule fois au chargement du programme et permet d'initialiser des variables ou des librairies, la deuxième étant loop() et qui doit comporter le code principal du programme. Cette dernière va être appelée en boucle indéfiniment tant que l'arduino est alimenté, le comportement de cette fonction pourra donc changer en fonction des entrées et sorties.

Le code ci-dessous permet de voir la structure de base :

void setup() {
// put your setup code here, to run once:
// initialisation des variables, des librairies,IO etc
}

void loop() {
// put your main code here, to run repeatedly:
// Tourne indefiniment, repond et change en fonction des I/O.
}

Langages, constantes et méthodes

Cette section a pour but de détailler succinctement les différentes fonctions qui permettent d'interagir avec les entrées/sorties.

Constants

Les constantes vont permettre de définir le comportement des broches dans notre programme. Par exemple le mode (entrée ou sortie) ainsi que les états. Ces constantes seront donc utilisable en paramètres des fonctions que l'on voit par la suite.

I/O Numériques

Les fonctions ci-dessous permettent de configurer et d'interagir avec les broches numériques. On remarque que à chaque fois, on précise le numéro de la broche tel qu'il est annoté sur notre circuit.

I/O analogiques

Les fonctions ci-dessous permettent de configurer et d'interagir avec les entrées analogiques ainsi que les sorties PWM

Serial

Les fonctions ci-dessous permettent de lire et d'écrire des données sur l'interface série.

Hello World !

Maintenant que l'on connait la structure de base du code ainsi que les principales fonctions à utiliser nous pouvons écrire notre premier programme. Le but est ici très simple : faire clignoter une LED. Pour cela, nous allons avoir besoin de seulement deux composants électronique : une LED et une résistance permettant d'abaisser la tension au niveau de la LED pour la protéger. La résistance est branchée comme sur le schéma ci-dessous à la broche numéro 13 (sorties numériques), la LED en série par la suite et sa cathode à GND. En modifiant ainsi la tension au niveau de la broche 13, la tension au niveau de la LED va changer et celle-ci va s'allumer.


led_circuit led_schema

Le programme à écrire est alors assez simple, la première chose à faire étant d'initialiser la broche en mode OUTPUT puis dans la fonction loop() de positionner successivement un état HAUT puis un état BAS. La LED va alors clignoter, on peut ajouter des temps d'attente pour contrôler la fréquence de clignotement. Le code à écrire est celui ci-dessous :

  // The LED is connected to pin 13
  const int led = 13;

  void setup() {
    // initialize the pin as an output.
    pinMode(led, OUTPUT);
  }
  void loop() {
    digitalWrite(led, HIGH); // turn the LED on 
    delay(1000); //wait for a second
    digitalWrite(led, LOW); // turn the LED off
    delay(1000); // wait for a second
  }

Hello World ! (avec PWM)

En plus de vouloir faire clignoter la LED, nous voulons maintenant pouvoir contrôler l'intensité lumineuse de celle-ci et la faire clignoter plus doucement. Il faut alors contrôler de facon linéaire la tension à ses bornes. Ceci est possible en utilisant le mode PWM que nous avons décrit. On connecte la résistance à une broche PWM (ici sur le schéma la 9), la LED en série par la suite et toujours la cathode sur GND. Ainsi en faisant varier la pulsation du signal sur la broche, on fera varier la tension moyenne appliquée aux bornes de la LED, permettant ainsi de contrôler l'intensité lumineuse.


fade_circuit fade_schema

Le code est encore ici très simple, la différence est que l'on ne définit pas le mode de la broche et que l'on va utiliser la fonction analogWrite(). En imbriquant deux boucles dans la fonction loop(), on peut allumer doucement la LED et l'eteindre de la même manière. On augmente ou on diminue de 5 en 5 à chaque tour de boucle la valeur des pulsations en sortie.

  const int led = 9;// The LED is connected to PIN 9
  void setup() {
  // nothing to do here this time.
  }
  void loop() {
    // fade in
    for(int fadeV = 0 ; fadeV <= 255; fadeV +=5) {
       analogWrite(led, fadeV);
       delay(30); // wait to see the effect
    }
    // fade out
    for(int fadeV = 255 ; fadeV >= 0; fadeV -=5) {
       analogWrite(led, fadeV);
       delay(30); // wait to see the effect
    }
  }

Les shields

Afin de pouvoir étendre encore plus les possibilités d'Arduino mais de simplifier la tache au maximum, il existe des cartes d'extension appelées Shield. Ces cartes branchées au dessus de l'Arduino vont permettre de ne pas reinventer la roue et de s'abtenir de cabler des circuits complexes. Certain prefereront les fabriquer suivant les plans fournit (long et laborieux pour les non électroniciens) mais il y a possibilité de les acheter déjà montés (7 sont disponibles sur le store officiel).

Les shields disponibles sont par exemple :

Un exemple

Nous aimerions maintenant bien utiliser du Wifi dans nos programmes afin de communiquer avec l'extérieur mais la conception complète d'une carte parait plutôt laborieuse et complexe. Il est alors possible ici d'utiliser le shield Wifi et la librairie qui est fournit avec. On peut voir ci-dessous un apercu du Shield avec au milieu le circuit permettant les communications Wifi. Celui-ci doit être alimenté en 5 volts, est compatible 802.11 b/g et supporte les cryptages WEP et WPA2.

wifi

Supposons que l'on veuille se connecter à un réseau sans fil ouvert et récuperer ensuite notre adresse IP. Pour cela, il est nécessaire d'utiliser la librairie fournit avec le shield et de l'inclure dans notre programme (ici Wifi.h). On pourra ensuite initier la connexion avec Wifi.begin() puis tester le statut pour vérifier si on est bien connecté. Si on est connecté, on peut récuperer notre adresse IP grâce à la fonction Wifi.localIP(). Le code est disponible ci-dessous (simplifié pour des raisons de lisibilité).

  #include 
  char ssid[] = "my_ssid";
  int status = WL_IDLE_STATUS;

  void setup() {
    Serial.begin(9600); // initialize serial:
    Serial.print("Connecting to the network: ");
    status = WiFi.begin(ssid);
    
    if (status == WL_CONNECTED) {
      Serial.println("Connected");
    } else ...
  }

  void loop(){
    Serial.println(Wifi.localIP());
  }