Changes between Initial Version and Version 1 of SujetTP6-2017

Timestamp:

Mar 24, 2017, 7:10:49 AM (8 years ago)

Author:

franck

Comment:

--

SujetTP6-2017

@@ +1 @@
+= Programmation Arduino =
+
+== Préambule ==
+
+Vous devez utiliser la version d'arduino qui se trouve :
+{{{#!bash
+> /opt/arduino-1.6.8/arduino
+}}}
+
+Les documents nécessaires se trouvent :
+- [https://github.com/adafruit/Adafruit_SSD1306 Repository API Ecran OLED]
+- [https://github.com/adafruit/Adafruit-GFX-Library Repository API Graphique]
+- [http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.ReferenceMaxi 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 :
+
+{{{#!c
+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.
+{{{#!c
+// --------------------------------------------------------------------------------------------------------------------
+// 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`[[BR]] à 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.
+
+
+