Changes between Initial Version and Version 1 of SujetTP5-2017

Timestamp:

Mar 2, 2017, 7:23:19 PM (8 years ago)

Author:

franck

Comment:

--

SujetTP5-2017

@@ +1 @@
+= Communication sans fil =
+
+== Préambule ==
+
+Vous devez utiliser la dernière version d'arduino qui se trouve 
+{{{#!bash
+> /opt/arduino-1.6.8/arduino
+}}}
+
+== Documents de référence ==
+
+ * [http://www.nordicsemi.com/eng/Products/2.4GHz-RF/nRF24L01P Site Nordic nRF24L01Plus] 
+ * [https://www.sparkfun.com/datasheets/Components/SMD/nRF24L01Pluss_Preliminary_Product_Specification_v1_0.pdf Spéicification nRF24L01plus]
+ * [https://github.com/TMRh20/RF24 Repository API TMRh20/RF24]
+ * [http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.ReferenceMaxi Langage Arduino]
+
+== Travail demandé ==
+
+Le but de la séance est de lire la valeur de la lumière sur une échelle de 1 à 100 sur un Arduino et de l'afficher sur le terminal d'un PC distant. Il y a donc au moins 2 noeuds, un émetteur et un récepteur.
+Nous allons aussi voir comment simuler l'exécution de plusieurs tâches périodiques.
+
+== Exécution ''multi-tâches'' ==
+
+Avant de commencer à utiliser les modules nRF24L01+ nous allons 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çeons 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
+// 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(13,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
+}
+}}}
+
+Dans la pratique, les tâches des applications communiquent entre elles. Nous pouvons le faire ici en passant par des variables globales dont les adresses sont passées en paramètres des tâches. Ce dernier point est important, il faut absolument que les variables globales ne soient pas directement utilisées par les fonctions de tâches mais toujours passées explicitement en paramètre ceci afin de faciliter la mise au point ET permettre d'avoir plusieurs instances de la même tâche.
+
+Dans l'exemple qui suit, nous avons ajouter une tâche !GetKbd qui lit un message au clavier et le place dans un buffer nommé mess.
+C'est la tâche Mess qui fera l'affichage.
+Les deux tâches se synchronisent en utilisant une case mémoire nommée full dont la valeur peut prendre deux états: 
+- 0 = le buffer ne contient pas de message, le buffer appartient à !GetKbd qui le remplit à chaque nouveau caractère
+- 1 = le buffer contient un message, le buffer appatient à Mess qui le lit et l'affiche
+
+La case full est mise à 1 par !GetKbd et mise à 0 par Mess.
+
+Il y a une autre communication entre !GetKbd et Led que je vous laisse analyser
+
+{{{#!c
+// 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;
+  int delta = newTime - waitForTimer[timer];
+  if ( delta < 0 ) delta += 1 + (0xFFFFFFFF / period);   
+  if ( delta ) waitForTimer[timer] = newTime;
+  return delta;
+}
+
+// Variables globales pour la communication inter-taches
+char mess[32];
+byte full;
+byte onled = 1;
+
+void Led (int timer, long period, byte led, byte *on) {
+  static int val = 0;
+  if (!waitFor(timer,period)) return; // sort s'il y a moins d'une période écoulée
+  if (*on == 0) {
+    val = 0;
+  }
+  digitalWrite(13,val);
+  val = 1 - val;
+}
+
+void Mess (byte *full, char * mess) {
+  if (! (*full) ) return;
+  *full = 0;
+  Serial.println(mess);
+}
+
+void setup () {
+  pinMode(13,OUTPUT);
+  Serial.begin(115200);
+}
+
+void GetKbd (byte *full, char * mess, byte len, byte *on) {
+  static byte index = 0;
+  if (!Serial.available()) return;
+  char c = Serial.read();
+  mess[index++] = c;
+  if (c == '\n') {
+    mess[index-1] = 0;
+    index = 0;
+    *full = 1;
+    *on = (strcmp(mess,"on")==0) ? 1
+        : (strcmp(mess,"off")==0) ? 0
+        : *on;
+        
+  } else if (index == len) {
+    index--;
+  }
+}
+
+void loop() {
+  Led (0,100000,13, &onled);           // Led est exécutée toutes les 100ms
+  Mess (&full, mess);           // mess est un buffer d'echange avec getkbd et full une bascule de synchro
+  GetKbd (&full, mess, sizeof(mess), &onled);
+}
+}}}
+
+== Lecture de la luminosité ==
+
+Faire un programme qui affiche l'état de la photo-résistance toutes les secondes, en utilisant une application multi-tâches
+
+== Communication nRF24L01+ ==
+
+=== Le matériel ===
+
+* Vous allez commencer par faire un schéma du noeud.[[BR]]
+  Les composants nécessaires à un noeud sont : 
+  * un Arduino nano
+  * un couple photorésistance, résistance
+  * un capteur sonore 
+  * un module **nRF24L01**
+
+  [[Image(htdocs:jpg/nano.jpg, height=200px)]]
+
+  [[Image(htdocs:jpg/pinoutNRF24L01.jpg, height=200px)]]
+  [[Image(htdocs:jpg/photoresistance.jpg, height=100px)]]
+  [[Image(htdocs:jpg/resistance.jpg, height=100px)]]
+ 
+=== L'usage des bibliothèques Arduino ===
+
+* Ce qu'il y a de bien dans l'écosystème Arduino, c'est que la volonté de faire simple.
+  En l'occurrence, nous avons deux nouveaux objets, l'écran et le module RF24. 
+  Pour les utiliser, nous allons devoir faire appel à des fonctions, mais nous n'allons pas avoir
+  à les écrire. En effet, pour presque tous les "périphériques" existants il existe un et même
+  souvent plusieurs bibliothèques de fonctions écrites par des "amateurs" souvent très doués. 
+  En plus, les sources sont ouvertes, et il est donc possible d'adapter ces codes pour des 
+  besoins spécifiques.
+
+* Les bibliothèques sont trouvées, en général, en tapant sur un moteur de recherche, la requête 
+  "nom-du-module Arduino". Les projets sont souvent sur github. Pour faire court,
+   * Vous téléchargez la bibliothèque (un .zip)
+   * Vous ajoutez la bibliothèque dans l'environnement Arduino
+   * Vous lancer l'IDE Arduino et dans le menu '''file/exemples''' vous avez un exemple (souvent plusieurs) 
+     de la nouvelle bibliothèque.
+   * Vous en choisissez un, vous le chargez, vous le compilez, vous l'uploadez, vous le testez :-)
+
+=== Communication de base Sensor - baseSensor ===
+
+La documentation de la bibliothèque est [http://tmrh20.github.io/RF24/classRF24.html ici] dont voici un résumé :
+
+* `     RF24 (uint8_t _cepin, uint8_t _cspin)`[[BR]]
+  Configuration du module radio et du SPI, reçoit les numéros de broche cepin (radio) cspin (SPI Slave Select)
+
+* `bool         begin (void)`[[BR]]
+  Démarrage du module radio
+
+* `void         startListening (void)`[[BR]]
+  
+* `void         stopListening (void)`[[BR]]
+
+* `bool         available (void)`[[BR]]
+
+* `void         read (void *buf, uint8_t len)`[[BR]]
+
+* `bool         write (const void *buf, uint8_t len)`[[BR]]
+
+* `void         openWritingPipe (const uint8_t *address)`[[BR]]
+
+* `void         openReadingPipe (uint8_t number, const uint8_t *address)`[[BR]]
+
+
+- **sensor**
+{{{#!c
+#include <SPI.h>
+#include "RF24.h"
+#include "printf.h"
+
+RF24 radio(9,10); // radio(CE,CS)
+
+byte addresses[][6] = {"0Node"};
+
+void setup() {
+  Serial.begin(115200);
+  printf_begin();
+  radio.begin();
+  radio.setPALevel(RF24_PA_LOW);
+  radio.openWritingPipe(addresses[0]);
+  radio.printDetails();
+  delay(1000);
+}
+
+
+void loop() {
+  Serial.println(F("Now sending !"));
+
+  unsigned long start_time = millis();                             // Take the time, and send it.  This will block until complete
+  if (!radio.write( &start_time, sizeof(unsigned long) )){
+     Serial.println(F("failed!"));
+  }
+  
+  delay(1000);
+}
+}}}
+
+
+- baseSensor
+{{{#!c
+#include <SPI.h>
+#include "RF24.h"
+#include "printf.h"
+
+RF24 radio(9,10);
+
+byte addresses[][6] = {"0Node","1Node","2Node","3Node","4Node","5Node"};
+
+void setup() {
+  Serial.begin(115200);
+  printf_begin();
+  radio.begin();
+  radio.setPALevel(RF24_PA_LOW);
+  radio.openReadingPipe(1,addresses[0]);
+  radio.printDetails();
+  radio.startListening();
+}
+
+void loop() {
+  unsigned long got_time;
+    
+  if( radio.available()){
+     radio.read( &got_time, sizeof(unsigned long) );             // Get the payload
+     Serial.println(got_time);
+   }
+}
+}}}