Maurin Donneaud

Designer d’interaction @ DataPaulette, Hackerspace textile, 19 rue Garibaldi 93100 Montreuil (Seine-Saint-Denis).

Formation/tutoriel

Pour faire communiquer Arduino et un logiciel il existe Firmata, une librairie simple et efficace. Cependant cette librairie ne nous permet pas d’aborder le fonctionnement d’un protocole de communication et elle ne fonctionne pas avec certains capteurs tel qu’un accéléromètre, etc. Nous allons donc aborder une méthode plus rudimentaires qui vous permettra de parcourir plusieurs notions fondamentales.

Pour commencer nous devons considérer les composants matériels de notre carte Arduino.
- Six convertisseurs analogiques numériques (ADC) qui nous offrent chacun une résolution de dix bits (0-1024).
- Une liaison série qui se caractérise par un unique canal d’émission (TX) et de réception (RX) qui ne nous permettent que de transmettre des octets (0-255).

Nous pourrions donc transmettre facilement des valeurs qui ne dépassent pas 255 mais pour garder la résolution maximum des capteurs nous allons transmettre chacune des valeurs dix bits sur deux octets.

Si nous voulons transmettre le flux de plusieurs capteurs à un ordinateur nous allons devoir créer un mécanisme pour identifier l’appartenance des valeurs reçues par l’ordinateur. Le moyen le plus simple est de réaliser un en-tête de plusieurs octets.

PNG - 18.5 ko

Le patch PureData ci-dessus fonctionne avec le code Arduino qui se trouve plus bas (Arduino2PureData).

Arduino2PureData

  1. ////////////////////////// Code Arduino
  2. // La transmission d'une valeur de 10 bits (0 - 1024)
  3. // nécessite une méthode particulière, car seul des
  4. // octets/bytes circulent sur la liaison série
  5. // ce sketche transmet deux valeurs de capteurs 10 bites
  6. ///////////// déclaration des variables
  7. int sensorPin_A = A0;    // sélection de la broche alogique A0
  8. int sensorPin_B = A1;    // sélection de la broche alogique A1
  9. int sensorValue_A = 0;   // déclaration de la variable qui contiendra une valeur captée (0 ---- 1024)
  10. int sensorValue_B = 0;   // déclaration de la variable qui contiendra une valeur captée (0 ---- 1024)
  11. boolean DEBUG = false; // false for PureData, true for Arduino
  12. ///////////// initialisation
  13. void setup() {
  14.   Serial.begin(19200);   // baude rate is 9600
  15. }
  16. ///////////// boucle principale
  17. void loop() {
  18.   sensorValue_A = analogRead(sensorPin_A); // lecture de la broche analogue
  19.   sensorValue_B = analogRead(sensorPin_B); // lecture de la broche analogue
  20.   if (!DEBUG) Serial.write(100);    // header BYTE 1
  21.   if (!DEBUG) Serial.write(254);    // header BYTE 2
  22.   if (!DEBUG) Serial.write(33);      // header BYTE 3
  23.   if (!DEBUG) Serial.write(125);    // header BYTE 4
  24.   delay(5);
  25.   if (DEBUG) Serial.println(sensorValue_A), Serial.print(" ");  
  26.   if (DEBUG) Serial.print(sensorValue_B);  
  27.   if (!DEBUG) print2byte(sensorValue_A);  // envoi de la première valeur captée
  28.   if (!DEBUG) print2byte(sensorValue_B);  // envoi de la deuxième valeur captée
  29. }
  30. ///////////// Fonction de transition d'une valeur dix bits (0-1024) sur deux octets/bytes
  31. void print2byte( int inputVal ) {
  32.   byte MSB = 0;
  33.   byte LSB = 0;
  34.   LSB = lowByte(inputVal);
  35.   Serial.write(LSB);
  36.   MSB = highByte(inputVal);
  37.   Serial.write(MSB);
  38. }

Arduino2Processing

  1. ///////////////// Code Arduino
  2. /*
  3. Ce programme consiste simplement à mesurer l'entrée analogique 0,
  4. et à transmettre le résultat à l'ordinateur.
  5.  */
  6. ///////////////// déclaration des variables
  7. // variable pour stocker le numéro de la broche du capteur
  8. int PinDeMesure = 0;
  9. // variable pour stocker la valeur mesurée
  10. int tension = 0;
  11. ///////////////// initialisation
  12. void setup(){
  13.   // établir la connection série à 19200 bits par segondes
  14.   Serial.begin(19200);
  15.   // définir le PinDeMesure comme une entrée
  16.   pinMode(PinDeMesure, INPUT);
  17. }
  18. ///////////////// boucle principale
  19. void loop() {
  20.   tension = analogRead(PinDeMesure); // lecture de la tension de la broche et stocke le résultat dans la variable tension
  21.       Serial.println( tension );
  22.       delay(50);
  23. }
  24. /*
  25. ///////////////// Code Prossecing
  26. Affichage des données captées par l'Arduino
  27. sous la forme d'un graphique en deux dimensions
  28. */
  29. ///////////////// librairie
  30. import processing.serial.*; // importation de la librairie de communication série
  31. Serial maConnection;        // création d'un objet de communication série
  32. ///////////////// variables
  33. int tension = 0;           // variable ou sera stockée la valeur de la tension
  34. int fenetreTemps = 12000;  // temps pour parcourir la largeur de l'écran en millisecondes
  35. int positionX = 0;         //
  36. int positionY = 0;         //
  37. ///////////////// initialisation
  38. void setup() {
  39.   size(650, 400);   // taille de l’écran
  40.   String NomDuPort = Serial.list()[0]; // récupère la première interface série trouvée
  41.   println("connection a " + NomDuPort);
  42.   maConnection = new Serial(this, NomDuPort, 19200); // création de la connexion série
  43.   background(255);  // fond d'écran blanc
  44.   smooth();         // lisser les dessins
  45.   strokeWeight(2);  // largeur de trait
  46.   stroke(40);       // couleur du trait gris
  47. }
  48. ///////////////// boucle principale de dessin
  49. void draw() {
  50.   // rien ne s'y passe, tout est géré dans la fonction serialEvent
  51. }
  52. void serialEvent (Serial maConnection) { // si des données arrivent par la connexion série
  53.   String donneesRecues = maConnection.readStringUntil('\n'); // lit la donnée jusqu'à la fin de ligne
  54.   if (donneesRecues != null) {           // si le donneesRecues n'est pas vide
  55.     donneesRecues = trim(donneesRecues); // enlever les espaces
  56.     tension = int(donneesRecues);        // converti le texte en nombre entier
  57.   }
  58.  
  59.   // détermination du X actuel
  60.   int oldPositionX = positionX;
  61.   positionX = (millis() % fenetreTemps) * width / fenetreTemps;
  62.  
  63.   if (oldPositionX > positionX) {
  64.     // reprise au debut de l'écran
  65.     oldPositionX = 0;
  66.     background(255); //fond d'écran blanc
  67.   }
  68.  
  69.   // calcul de la position Y
  70.   int oldPositionY = positionY;
  71.   positionY = int(map(tension, 0, 1023, height - 20, 20)); // mise à l'échelle de la tension pour entrer dans l'écran
  72.   line(oldPositionX, oldPositionY, positionX, positionY); // dessine le trait
  73. }

Forum sur abonnement

Pour participer à ce forum, vous devez vous enregistrer au préalable. Merci d'indiquer ci-dessous l'identifiant personnel qui vous a été fourni. Si vous n'êtes pas enregistré, vous devez vous inscrire.

Connexions'inscriremot de passe oublié ?