Programmation Arduino

Préambule

Vous devez utiliser la version d'arduino qui se trouve :

> /opt/arduino-1.6.8/arduino

Les documents nécessaires se trouvent :

• ​Repository API Ecran OLED
• ​Repository API Graphique
• ​Langage Arduino

Objectif

Le but de cette séance est de faire de la programmation sur Arduino en utilisant 3 entrées-sorties :

• La LED présente sur le module.
• L'écran OLED
• Le port série qui relie le module et le PC.

Nous voulons aussi expérimenter la programmation "multi-tâches". Les guillemets expriment le fait qu'il s'agit plus d'une structure du programme que d'une vraie programmation multi-tâches dans la mesure où il n'y a pas de système d'exploitation. Toutefois, les "tâches" seront programmées de sorte à être indépendantes de leur contexte d'utilisation et elles seront "ordonnancées" par la fonction loop().

Exécution multi-tâches

Nous allons docnc voir comment il est possible de programmer des applications multi-tâches coopératives dans l'environnement Arduino sans pour autant alors les services d'un OS. Le code a été volontairement simplifié à l'extrême afin de bien comprendre le principe.

Commençons par exprimer les besoins. Dans une applications pour micro-contrôleur, il est nécessaire :

• d'exécuter des tâches périodiquement ;
• d'exécuter des tâches lorsque des événements surviennent ;
• de mesurer le temps séparant deux événements ;
• de synchroniser l'exécution de deux tâches (une tâche T1 s'exécute et produit des données qui sont récupérées par une tache T2) ;
• etc.

Chaque tâche est représentée par une fonction qui code son comportement. Dans l'environnement Arduino, la fonction loop() s'exécute en boucle, c'est elle qui va séquencer l'exécution des tâches. La fonction loop() demande donc l'exécution des tâches à tour de rôle. Les tâches n'ont pas le droit de conserver le processeur sinon celà crée un blocage du système. La structure générale d'une tâche est la suivante :

void tache(arguments) {
   // test de la condition d'exécution
   if (evement_attendu_absent) return;
   // code de la tache
   ....
}

Pour les tâches périodiques, nous pouvons écrire une fonction qui exploite un timer interne du processeur qui s'incrémente chaque microseconde. Cette fonction nommée waitFor(int timer, unsigned long period) prend deux paramètres timer et period. Le premier un numéro de timer (il en faudra autant que de tâches périoodiques). Le second est une période en microsecondes.

wairFor() peut être appelée aussi souvent que nécessaire, elle rend 1 une seule fois par période (second paramètre). Si elle n'est pas appelée pendant longtemps alors elle rend le nombre de périodes qui se sont écoulées.

Dans l'application suivante nous avons deux tâches périodiques Led() et Mess(). La première fait clignoter une led dont le numéro est passé en paramètre à 5Hz. La seconde affiche bonjour à une fois par seconde.

// --------------------------------------------------------------------------------------------------------------------
// Multi-tâches cooperatives : solution basique
// --------------------------------------------------------------------------------------------------------------------

// unsigned int waitFor(timer, period) 
// Timer pour taches périodique
// arguments :
//  - timer  : numéro de timer entre 0 et MAX_WAIT_FOR_TIMER-1
//  - period : période souhaitée
// retour :
//  - nombre de période écoulée depuis le dernier appel
//
#define MAX_WAIT_FOR_TIMER 16
unsigned int waitFor(int timer, unsigned long period){
  static unsigned long waitForTimer[MAX_WAIT_FOR_TIMER];
  unsigned long newTime = micros() / period;              // numéro de la période modulo 2^32 
  int delta = newTime - waitForTimer[timer];              // delta entre la période courante et celle enregistrée
  if ( delta < 0 ) delta += 1 + (0xFFFFFFFF / period);    // en cas de dépassement du nombre de périodes possibles sur 2^32 
  if ( delta ) waitForTimer[timer] = newTime;             // enregistrement du nouveau numéro de période
  return delta;
}

void Led(int timer, long period, byte led) {
  static byte val = 0;                                    // valeur à mettre sur la led
  if (!waitFor(timer,period)) return;                     // sort s'il y a moins d'une période écoulée
  digitalWrite(led,val);                                  // ecriture
  val = 1 - val;                                          // changement d'état
}

void Mess(int timer, long period, const char * mess) {
  if (!(waitFor(timer,period))) return;                   // sort s'il y a moins d'une période écoulée
  Serial.println(mess);                                   // affichage du message
}

void setup() {
  pinMode(13,OUTPUT);                                     // initialisation de la direction de la broche
  Serial.begin(115200);                                   // initialisation du débit de la liaison série
}

void loop() {
  Led (0,100000,13);                                      // Led est exécutée toutes les 100ms
  Mess(1,1000000,"bonjour");                              // Mess est exécutée toutes les secondes
}

Utilisation de l'écran

Nous allons utiliser un écran OLED connecté en I2C, 128x32 ssd1306

• La bibliothèque de l'écran se trouve en tapant la requête ssd1306 arduino
  à l'adresse ​https://github.com/adafruit/Adafruit_SSD1306. Vous devrez prendre également la bibliothèque GFX à l'adresse ​https://github.com/adafruit/Adafruit-GFX-Library qui est la bibliothèque graphique.
• Vous pouvez exécuter l'exemple proposé dans la bibliothèque. Cette bibliothèque fonctionne pour plusieurs types modèles. Vous allez choisir le bon exemple : 128x32 I2C.

Questions :

• Quel est le numéro de l'abonné I2C de l'écran ?
• Modifier le programme initial pour afficher "bonjour" sur l'Oled toutes les 2 secondes sans changer le comportement de existant.