+33 (0) 1 46 59 17 37

Hi! We are based in Paris, we propose low shipping fees and love Open Hardware!

HackSpark, l'électronique facile !

  • Contrôler et comprendre la qualité de l'air intérieur avec Arduino

    Qualité de l'air avec Arduino et Grove

    Il y a des fois où l'on veut pouvoir influer sur son environnement, et comprendre ce qui rend la qualité de l'air chez soi bonne ou mauvaise, quand faut-il aérer, etc. est une bonne méthode pour le faire.

    Prenons un exemple concret (ce que j'ai fait), j'ai été voir sur les internets quels sont les facteurs pouvant gêner la respiration et tout simplement être nocifs à un bébé (eh oui, ce que l'on ne fait pas pour soi, on le fait pour sa progéniture :-)).

    Mes recherches m'ont montré qu'il y a plusieurs facteurs environnementaux (ce que l'on pourra mesurer de façon objective avec des capteurs) à prendre en compte : la température et la circulation de l'air (facilement mesurable au taux de CO2 mesuré près du couchage).

    D'autre part, je souhaitais également mesurer la présence d'autres polluants comme les particules fines dans l'atmosphère (diesel, pics de pollution, etc.) et la présence de formaldéhydes (également nocifs pour les plus petits) dégagés par nos chers meubles suédois.

    Plan de bataille :

    • Idéalement, il me fallait deux centrales de mesure :
      • une dans la chambre, au plus près du lit mesurant les polluants de l'air intérieur (CO2, formaldéhydes) et la température
      • une dans le salon, mesurant la pollution en particules (PM25) et la température générale de l'appartement.

    Bien que j'ai opté pour ce choix, pour cet exemple nous mettrons tout sur un seul Arduino, à vous de séparer ensuite et de peaufiner les détails selon vos goûts :)

    Quelle plateforme ?

    Seeeduino_Lotus_photo

    J'ai opté pour une plateforme Arduino et plus particulièrement pour la Seeeduino Lotus (une Seeeduino - carte compatible Arduino - avec le Grove Base Shield intégré), mais toute autre carte Arduino (ou autre micro-contrôleur à ce compte là) conviendra et les mêmes capteurs dans leurs versions indépendantes conviendront également.

    Quels capteurs ?

    _MG_5661

    Pour la température, un Grove Temp & Humi Sensor (DHT 11) ou Grove Temp & Humi Sensor Pro (DHT 22) nous donnent la température en degrés Celsius et le pourcentage d'humidité de façon fiable (plus fiable et précis dans le cas de la version pro, la version normale ne passe pas en dessous de 0°C).

    _MG_5662

    Pour la qualité de l'air, un petit capteur très pratique nous donne un indicateur global de qualité de l'air tenant compte de nombre de facteurs dont le niveau de CO2, alcool, monoxyde de carbone, formaldéhydes dans l'air : Grove Air Quality Sensor (TP-401A ou MQ 135). C'est ce senseur que j'utilise pour savoir quand aérer (trop d'air respiré, trop de polluants, etc)

    _MG_5660

    Pour le niveau de pollution aux particules, le Grove Dust Sensor  (ou DSM501A en version non grove) est très précis et utile pour donner une indication précise du niveau de particules dans l'air.

    Comment afficher ces données ?

    Dans le cas d'une installation complète, on fera remonter les informations à un serveur pour pouvoir les visualiser, les comparer, etc. Pour cet exemple, nous ferons un dispositif séparé, affichant ses valeurs sur son écran : c'est largement suffisant pour contrôler la qualité de son air et avoir une information rapide sur la marche à suivre.

    Ma priorité est d'avoir un écran petit (discret) et ne diffusant pas trop de lumière pour ne pas être gênant la nuit (rétro-éclairage proscrits). Il faut néanmoins pouvoir l'activer et l'utiliser pour envoyer de la lumière, voire flasher, dans le cas où une action est nécessaire (haut niveau de pollution). Pour cela, une technologie est toute indiquée : l'afficheur OLED.

    Nous choisirons plus précisément l'écran Grove Oled 96x96 pour sa connectique grove facile à connecter (presque équivalent non grove l'écran oled 128x64)

    Étape 1 : Assemblage

    Ce qui est pratique avec Grove, c'est qu'il suffit d'assembler les pièces :

    Ou :

    Puis :

    _MG_5668

    Étape 2 : Installation des librairies

    Nous allons installer les librairies Arduino nécessaires aux capteurs utilisés :

    Nous avons également préparé une archive contenant toutes ces librairies.

    Pour cela décompacter les archives dans le répertoires libraries de votre "sketchbook" arduino.

    Étape 3 : Écrivons notre programme

    Il faut prendre les divers bouts d'exemples des librairies utilisées (pages du wiki seeed studio) :

    Puis assembler tout cela dans un programme qui gère et affiche les données lorsqu'elles sont disponibles (grosso modo : copier le code de "setup", et remplacer les Serial.print par des écritures sur l'api de l'afficheur).

    Commençons avec le Air Quality Sensor et le Temp & Humi Sensor :

    #include <Wire.h>
    #include <SeeedGrayOLED.h>
    #include "AirQuality.h"
    #include "Arduino.h"
    #include "DHT.h"
    #define DHTPIN 2     // what pin the DHT is connected to
    
    // Uncomment whatever type you're using!
    //#define DHTTYPE DHT11   // DHT 11 
    #define DHTTYPE DHT22   // DHT 22  (AM2302)
    DHT dht(DHTPIN, DHTTYPE);
    
    AirQuality airqualitysensor;
    int current_quality =-1;
    #define BUZZER 10
    void setup()
    {
      Wire.begin();    // initialize i2c
      SeeedGrayOled.init();  //initialze SEEED OLED display
      SeeedGrayOled.clearDisplay();          //clear the screen and set start position to top left corner
      SeeedGrayOled.setNormalDisplay();      //Set display to normal mode (i.e non-inverse mode)
      SeeedGrayOled.setVerticalMode();    
      //SeeedGrayOled.setPageMode();           //Set addressing mode to Page Mode
      SeeedGrayOled.setTextXY(0,0);          //Set the cursor to Xth Page, Yth Column  
      SeeedGrayOled.putString("Initializing"); //Print the String
    
      pinMode(BUZZER, OUTPUT);
      digitalWrite(BUZZER, LOW);
      airqualitysensor.init(14);
      dht.begin();
    }
    
    void loop()
    {
      // Reading temperature or humidity takes about 250 milliseconds!
      // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
      float h = dht.readHumidity();
      float t = dht.readTemperature();
      SeeedGrayOled.setTextXY(8,0);
      // check if returns are valid, if they are NaN (not a number) then something went wrong!
      if (isnan(t) || isnan(h)) 
      {
          SeeedGrayOled.putString("DHT ERROR");
      } 
      else 
      {
          SeeedGrayOled.putString("Humid: "); 
          SeeedGrayOled.setTextXY(9,0);
          SeeedGrayOled.putString("   "); 
          SeeedGrayOled.putFloat(h);
          SeeedGrayOled.putString("%"); 
          SeeedGrayOled.setTextXY(10,0);
          SeeedGrayOled.putString("Temp.: "); 
          SeeedGrayOled.setTextXY(11,0);
          SeeedGrayOled.putString("   "); 
          SeeedGrayOled.putFloat(t);
          SeeedGrayOled.putString("C");
      }
    
      current_quality=airqualitysensor.slope();
      if (current_quality >= 0) {
        if (current_quality <= 1)
          // Air quality is bad. Let's revert display to make some light !
          SeeedGrayOled.setInverseDisplay();
        else
          SeeedGrayOled.setNormalDisplay();
    
        SeeedGrayOled.setTextXY(1,0);
        SeeedGrayOled.putString("Air Quality:"); //Print the String
        SeeedGrayOled.setTextXY(2,0);
        SeeedGrayOled.putString("   "); // Empty the number line
        SeeedGrayOled.setTextXY(2,0);
        SeeedGrayOled.putNumber(airqualitysensor.first_vol); //Print the String
    
        SeeedGrayOled.setTextXY(0,0);
        if (current_quality==0)
        SeeedGrayOled.putString("Emergency   ");
        else if (current_quality==1)
        SeeedGrayOled.putString("Hi Pollution");
        else if (current_quality==2)
        SeeedGrayOled.putString("Lo Pollution");
        else if (current_quality ==3)
        SeeedGrayOled.putString("Fresh air   ");
    
        if (current_quality<1)
          digitalWrite(BUZZER, HIGH);
        else
          digitalWrite(BUZZER, LOW);
      }
    }
    
    ISR(TIMER2_OVF_vect)
    {
    if(airqualitysensor.counter==122)//set 2 seconds as a detected duty
    {
    
    airqualitysensor.last_vol=airqualitysensor.first_vol;
    airqualitysensor.first_vol=analogRead(A0);
    airqualitysensor.counter=0;
    airqualitysensor.timer_index=1;
    //PORTB=PORTB^0x20;
    }
    else
    {
    airqualitysensor.counter++;
    }
    }

    Dans ce code on a repris les éléments des divers exemples et on affiche sur l'écran les valeurs. Si la pollution est élevée, on inverse l'écran (noir sur fond blanc), de façon à envoyer une lumière dans une pièce sombre. Si le niveau est critique, on active le port 10 de l'arduino (sur lequel on peut brancher un buzzer, une led puissante, etc).

    La Partie "ISR(TIMER2_OVF_vect)" sert à mettre à jour les valeurs du air quality sensor, je n'ai pas touché à grand chose sur le code fourni dans l'exemple.

    Basiquement, des valeur air quality de moins de 100 indiquent un air assez pur, plus de 100 c'est moyen, mais tant que cela n'est pas sur une longue période pas de problème. Dans une chambre non aérée toute une nuit, cela peut monter à 300-400, ce qui est très mauvais : il faut aérer.

    Ajoutons à présent le dust sensor à tout cela (j'ai mis en gras les lignes nouvelles) :

    #include <Wire.h>
    #include <SeeedGrayOLED.h>
    #include "AirQuality.h"
    #include "Arduino.h"
    #include "DHT.h"
    #define DHTPIN 2     // what pin the DHT is connected to
    
    // Uncomment whatever type you're using!
    //#define DHTTYPE DHT11   // DHT 11 
    #define DHTTYPE DHT22   // DHT 22  (AM2302)
    DHT dht(DHTPIN, DHTTYPE);
    
    AirQuality airqualitysensor;
    int current_quality =-1;
    #define BUZZER 10
    
    int dust_pin = 4;
    unsigned long duration;
    unsigned long starttime;
    unsigned long sampletime_ms = 30000;//sampe 30s ;
    unsigned long lowpulseoccupancy = 0;
    float ratio = 0;
    float concentration = 0;
    
    void setup()
    {
      Wire.begin();    // initialize i2c
      SeeedGrayOled.init();  //initialze SEEED OLED display
      SeeedGrayOled.clearDisplay();          //clear the screen and set start position to top left corner
      SeeedGrayOled.setNormalDisplay();      //Set display to normal mode (i.e non-inverse mode)
      SeeedGrayOled.setVerticalMode();    
      //SeeedGrayOled.setPageMode();           //Set addressing mode to Page Mode
      SeeedGrayOled.setTextXY(0,0);          //Set the cursor to Xth Page, Yth Column  
      SeeedGrayOled.putString("Initializing"); //Print the String
      
      pinMode(BUZZER, OUTPUT);
      digitalWrite(BUZZER, LOW);
      airqualitysensor.init(14);
      dht.begin();
      
      pinMode(dust_pin,INPUT);
      starttime = millis();//get the current time;
    }
    
    void loop()
    {
      // Reading temperature or humidity takes about 250 milliseconds!
      // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
      float h = dht.readHumidity();
      float t = dht.readTemperature();
      SeeedGrayOled.setTextXY(8,0);
      // check if returns are valid, if they are NaN (not a number) then something went wrong!
      if (isnan(t) || isnan(h)) 
      {
          SeeedGrayOled.putString("DHT ERROR");
      } 
      else 
      {
          SeeedGrayOled.putString("Humid: "); 
          SeeedGrayOled.setTextXY(9,0);
          SeeedGrayOled.putString("   "); 
          SeeedGrayOled.putFloat(h);
          SeeedGrayOled.putString("%"); 
          SeeedGrayOled.setTextXY(10,0);
          SeeedGrayOled.putString("Temp.: "); 
          SeeedGrayOled.setTextXY(11,0);
          SeeedGrayOled.putString("   "); 
          SeeedGrayOled.putFloat(t);
          SeeedGrayOled.putString("C");
      }
      
      // Checking Air Quality 
      current_quality=airqualitysensor.slope();
      if (current_quality >= 0) {
        if (current_quality <= 1)
          // Air quality is bad. Let's revert display to make some light !
          SeeedGrayOled.setInverseDisplay();
        else
          SeeedGrayOled.setNormalDisplay();
          
        SeeedGrayOled.setTextXY(1,0);
        SeeedGrayOled.putString("Air Quality:"); //Print the String
        SeeedGrayOled.setTextXY(2,0);
        SeeedGrayOled.putString("   "); // Empty the number line
        SeeedGrayOled.setTextXY(2,0);
        SeeedGrayOled.putNumber(airqualitysensor.first_vol); //Print the String
        
        SeeedGrayOled.setTextXY(0,0);
        if (current_quality==0)
        SeeedGrayOled.putString("Emergency   ");
        else if (current_quality==1)
        SeeedGrayOled.putString("Hi Pollution");
        else if (current_quality==2)
        SeeedGrayOled.putString("Lo Pollution");
        else if (current_quality ==3)
        SeeedGrayOled.putString("Fresh air   ");
        
        if (current_quality<1)
          digitalWrite(BUZZER, HIGH);
        else
          digitalWrite(BUZZER, LOW);
      }
      
      // Checking Dust Sensor
      duration = pulseIn(dust_pin, LOW);
      lowpulseoccupancy = lowpulseoccupancy+duration;
    
      if ((millis()-starttime) > sampletime_ms) //if the sample time == 30s
      {
        ratio = lowpulseoccupancy/(sampletime_ms*10.0);  // Integer percentage 0=>100
        concentration = 1.1*pow(ratio,3)-3.8*pow(ratio,2)+520*ratio+0.62; // using spec sheet curve
        /*Serial.print(lowpulseoccupancy);
        Serial.print(",");
        Serial.print(ratio);
        Serial.print(",");
        Serial.println(concentration);*/
        SeeedGrayOled.setTextXY(4,0);
        SeeedGrayOled.putString("Particles:");
        SeeedGrayOled.setTextXY(5,0);
        SeeedGrayOled.putString("    ");
        SeeedGrayOled.setTextXY(5,0);
        SeeedGrayOled.putNumber(concentration);
        lowpulseoccupancy = 0;
        starttime = millis();
      }
    }
    
    ISR(TIMER2_OVF_vect)
    {
    if(airqualitysensor.counter==122)//set 2 seconds as a detected duty
    {
    
    airqualitysensor.last_vol=airqualitysensor.first_vol;
    airqualitysensor.first_vol=analogRead(A0);
    airqualitysensor.counter=0;
    airqualitysensor.timer_index=1;
    //PORTB=PORTB^0x20;
    }
    else
    {
    airqualitysensor.counter++;
    }
    }

    On a juste ajouté les lignes présentes dans l'exemple fourni par le distributeur et affiché une valeur importante.

    La concentration en particules varie beaucoup entre les lectures. Un temps de plus de 30 secondes peut permettre de meilleures valeurs. Un lissage aussi. Mais cela donne déjà un bon aperçu de la qualité de l'air en terme de pollution. (Exemple : pendant les pics de pollution à Paris, cette valeur peut monter à plus de 6000/7000. Un air pur à la campagne - hors printemps et pollens - dépasse rarement les 500. A l'heure exacte où j'écris cet article, le capteur affiche 1500).

    Avec le temps vous apprendrez à comprendre ce qui fait monter les valeurs. Par exemple, buvez une bière forte et respirez à coté de l'Air Quality Sensor, ou faites votre menage avec des produits chimiques et voyez la qualité de l'air baisser considérablement, aérez et comparez, etc.

    _MG_5666

    Quelles évolutions ?

    On peut imaginer envoyer les données pour en faire des statistiques, ou même contrôler une ventilation chez soi. On peut également mettre un plus grand écran et afficher des images ou avoir une interface tactile. En bref : tout est possible. N'hésitez pas à partager vos variantes et idées dans les commentaires.

    Qui sait ? Si ce projet intéresse suffisamment de monde, on pourrait, chez HackSpark, être tentés d'en faire un produit fini prêt à être utilisé par tout un chacun, et ce en open hardware :)

  • Un gros compteur à LEDs à base d'Arduino

    F30G8A9HMNNF54S.MEDIUM

    Nous amis de chez Seeed Studio ont voulu afficher chez eux le nombre de commandes passées sur leur site en temps réel. Lorsque l'on fait du hardware, quelle idée plus naturelle que de le faire avec un Arduino ? Le faire avec un Arduino et des matrices de LEDs rouges !

    Ce petit projet utilise deux matrices à led rouges 32x16 ultra fine ainsi qu'un Arduino Leonardo et ce qu'il faut pour le connecter en wifi. Si vous êtes un grand fan de pixel art, essayez :)

    1ère étape : préparation du matériel

    FL626N1HMMF6UG4.MEDIUM FP2TSHDHMMF5B5R.MEDIUM

    Tout comme pour une recette culinaire, il nous faut préparer les ingrédients avant la cuisson :

    1. Arduino Leonardo (x1)
    2. Matrice de LEDs rouges 32x16 (x2)
    3. Wifi Shield (x1)
    4. Plaques acrylique pour le boitier (optionnel)
    5. Quelques fils de liaison
    6. Une alimentation pour Arduino 9V

    Cette matrice de LED peut être contrôlée directement par l'Arduino. Avec le shield WIFI nous allons récupérer l'information nécessaire (chacun voudra afficher quelque chose de différent).

    Vous devrez bien sur avoir sous la main quelques fils de liaison (male-male, male-femelle, femelle-femelle, c'est toujours utile dans un projet "bidouille" comme celui-ci :))

    Étape 2 : Tester la matrice de LEDs avec l'Arduino

    On connecte avec des fils male-femelle la carte Arduino à une matrice de leds :

    FD3P35FHMMFBXGD.MEDIUM

    - connecter A à digital 2
    - connecter B à digital 3
    - connecter C à digital 4
    - connecter D à digital 5
    - connecter OE à digital 6
    - connecter STB à digital 10
    - connecter R1 à digital 11
    - connecter CLK à digital 13
    - connecter GND à GND

    Il nous faudra installer la librairie Arduino de ces afficheurs à LED.

    Ici nous allons afficher deux caractères "你好" sur la matrice. Ces deux caractères veulent dire "bonjour" :)

    Pour ce faire nous allons envoyer le code de démo à télécharger ici.

    FCCQEG0HMMF5B6D.MEDIUM

    Étape 3 : Connecter les pièces du projet

    Nous allons chaîner les deux matrices ensembles avec une nappe fournie.

    FDFD86BHMMFBZKT.MEDIUM

    Puis bouger vers connexions de l'arduino vers le shield wifi et enfin connecter le shield wifi sur l'arduino (sur la photo suivante on a ajouté un petit connecteur de courant externe, il est bien sur optionnel).

    FVS1YBOHMMF14B9.MEDIUM

    Étape 4 : Faire un boitier et coder son applicaition

    C'est la partie où vous entrez en jeu, il vous faudra télécharger l'information à afficher avec le shield wifi et utiliser l'api très simple de l'affichage. Dans cet exemple, l'équipe Seeed Studio a pris le nombre de vente grâce à une API XMLRPC et l'affiche immédiatement sur l'afficheur avec l'API.

    F30G8A9HMNNF54S.MEDIUM

    Article source (en anglais)

  • Créer son réseau de senseurs et mini-devices WiFi avec Arduino et RN-171-XV WiFly

    senseurs

    Créer des appareils, des senseurs, des modules relais, etc. c'est louable, nécessaire et même parfois très agréable. Oui, mais pouvoir les contrôler à distance c'est encore mieux.

    Pour cela nous avons plusieurs choix, des modules radio (433mhz par exemple), des modules de réseau mesh spécialisés (très utile, comme les xbee et autres nrf24l10), des systèmes plus généralistes pour la communication proche (nfc, bluetooth, etc), ou finalement notre bon vieux wifi, utilisables avec tous les ordinateurs, téléphones portables ou même cartes de développement ARM.

    Si des centaines d'articles  existent pour vous expliquer comment arriver à faire votre réseau de capteur en zigbee, peu en revanche vous expliquent comment arriver à une solution comparable en wifi. C'est ce que nous allons tenter de faire ici.

    Pour cela, regardons de plus prêt un circuit nouvellement arrivé sur la scène, le module wifi RN-XV, mieux connu sous le doux nom de Wifly, avec un module au format xbee (il en a juste la connectique) plus répandu appelé RN-171-XV.

    P1010700-2

    Ce module peut être soit utilisé de façon autonome, et dans ce cas il pourra vous permettre de contrôler des sorties numériques ou lire des entrée analogiques à distance, soit couplé à un arduino avec le protocole de votre choix.

    1. Paramétrage de notre module WiFly

    Afin d'aller au plus simple nous utiliserons un Arduino (ou compatible, ici un Seeeduino v3) avec un shield XBee.

    Si vous souhaitez utiliser le modufle WiFly sans arduino, vous pouvez aussi utiliser le port USB du XBee Carrier ou Wireless Sensor Node Kit décrit plus loin (et dans ce cas omettre l'étape suivante).

    Avant de connecter le shield Xbee, nous envoyons un programme vide à l'arduino, afin qu'il n'interfère pas sur la connexion série (avec le menu Fichier > Exemple > 01. Basics > BareMinimum) :

    bareminimum sketch

    Ensuite, nous connectons le shield Xbee avec le RN-171-XV sur la carte, puis nous plaçons les jumper de la carte en position USB (vers le haut).

    Utilisation avec un shield XBee Utilisation avec un shield XBee
    Utilisation avec Grove XBee carrier Utilisation avec Grove XBee carrier

    Il  faut ensuite lancer le moniteur série Arduino (ou screen sous linux), en module "Pas de fin de ligne" et "9600 baud".  Envoyez le texte "$$$" pour passer en mode commande (vous recevrez "CMD").

    Passez maintenant le moniteur série en mode "retour chariot" (première liste déroulante en bas). Vous pouvez maintenant envoyer les commandes pour le connecter sur votre réseau wifi :

    <4.00> set wlan ssid <nom du réseau>
    AOK 
    <4.00> set wlan phrase <mot de passe réseau>
    AOK 
    <4.00> set ip dhcp 1
    AOK 
    <4.00> set wlan channel 0
    AOK 
    <4.00> set wlan join 1
    AOK

    Ici, je vous conseille pour faire simple de le faire se connecter à votre réseau personnel wifi, en settant uniquement le "ssid" et "phrase", il détectera le reste.

    Pour sauvegarder et appliquer les changements, envoyer les commandes :

    <4.00> save  
    Storing in config

    Maintenant,  vous devriez pouvoir voir le connecter à votre réseau avec la commande join :

    <4.00> join my_network  
    Auto-Assoc my_network chan=6 mode=MIXED SCAN OK 
    <4.00> Joining my_network  now.. 
    Associated! 
    DHCP: Start 
    DHCP in 11ms, lease=172800s 
    IF=UP 
    DHCP=ON 
    IP=192.168.0.111:2000 
    NM=255.255.255.0 
    GW=192.168.0.1 
    Listen on 2000

    Cela nous apprend qu'il s'est bien connecté à notre réseau, a obtenu l'adresse IP 192.168.0.111 et qu'il écoute sur le port 2000.

    Vous pouvez relancer le module pour vérifier qu'il se reconnectera bien automatiquement avec la commande "reboot".

    Pour mettre à jour le firmware de votre WiFly (s'il est à une version trop ancienne, et ne surtout pas éteindre le courant pendant la mise à jour) :

    <4.00> ftp update
    <4.00> factory reset

    Il faudra bien entendu, dans ce cas, tout re-paramétrer comme décrit plus haut.

    Si l'on essaie de s'y connecter en telnet (sous la plupart des OS la commande est disponible directement) :

    $ telnet 192.168.0.111 2000
    Trying 192.168.0.111...
    Connected to 192.168.0.111.
    Escape character is '^]'.
    *HELLO*blah

    Ce que l'on enverra comme texte ici sera envoyé à l'arduino (si l'on remet les jumper en mode "Xbee" (vers le bas)), et l'on peut également envoyer "$$$" pour passer en mode commandes. Ici, j'ai envoyé "blah".

    Coté arduino, on recoit ceci :

    *OPEN*blah

    Qui nous apprend qu'un client s'est connecté, et nous a envoyé "blah". On recevra "*CLOS*" lorsqu'il se sera déconnecté.

    2. Utilisation avec un Arduino

    Pour la partie de la communication avec votre arduino, je vous laisserais l'imaginer, le choix du protocole sera votre, et vous dialoguerez avec comme si vous étiez en connexion filaire, mais en socket. Chaque carte aura son IP. A vous d'associer une ip fixe à chaque noeud sur votre routeur/serveur dhcp grâce à leurs adresses MAC.

    L'utilisation sur un arduino peut se faire comme expliqué plus haut avec un shield xbee et le module rn-171-xv dessus, ou avec un shield wifi utilisant déjà ce module.

    Utilisation avec un shield XBee Utilisation avec un shield XBee

    Dans tous les cas, si vous voulez plus de contrôle sur vos modules wifly, il existe un librairie Arduino très complète pour les gerer.

    Une autre option encore, pour un encombrement minimal, consiste à utiliser :

    Et les utiliser comme cela :

    Utilisation avec un Arduino Nano IO Shield
    Utilisation avec un Arduino Nano IO Shield

    Votre Arduino pourra ainsi recevoir les commandes de l'ordinateur sur sa liaison série et envoyer les données de ses capteurs.

    3. Utilisation autonome

    a. Comment ?

    Plus intéressant encore, l'utilisation de ces modules WiFly peut être autonome, sans micro-controlleur, permettant ainsi de baisser encore les coûts.

    Pour l'utiliser de façon autonome, nous pouvons soit brancher ses fils individuellement, grâce à un adaptateur de xbee vers breadboard (plus diy), soit utiliser une platine faite pour cela, la carte XBee Carrier.

    A noter, que cette carte est disponible en kit dénomé "Wireless Sensor Node Solar Kit", comprenant une boite, une petite batterie, le xbee carrier et un petit panneau solaire

    En premier lieu il faut connecter le module WiFly RN-171-XV sur la platine.

    Puis, on peut suivre les étapes sur la partie 1 (sans la partie arduino) en utilisant le port usb inclus sur la carte xbee carrier pour le parametrer.

    b. Commandes disponibles

    Tout d'abord, voyons les ports à disposition :

    rn171xv3

    Nous avons à notre disposition 9 ports GPIO et 6 ports de senseurs (analogiques).

    Les ports numériques (GPIO)

    Ici, on n'utilisera quasiment que le mode CMD, on pourra changer les états des ports GPIO comme ceci :

    <4.00> set sys mask 0x21f8 1
    AOK
    <4.00> set sys output 0x08
    AOK
    <4.00> set sys output 0x00
    AOK
    <4.00> set sys mask 0x21f4 1
    AOK
    <4.00> set sys output 0x04
    AOK
    <4.00> set sys output 0x00
    AOK

    Cela définira le port GPIO 3 comme output, l'allumeras puis l'éteindra. Sur la platine, le port GPIO 3 devient D6 et est disponible sur le fil blanc de l'interface grove (le fil jaune est D5). On fait ensuite de même pour GPIO 2.

    P1010730-2

    Pour le "set mask", une valeur à 1 vaut output, à 0 vaut input. Par défaut le masque est 0x21f0 (00010000111110000). Si l'on veut set le gpio 3 en output, on envoie donc 00010000111111000, soit 0x21f8 (et en set output 0x08). et pour le gpio 2, on envoie 0x21f4 (en set output 0x04).

    On peut également s'amuser avec les leds disponibles sur le module, que l'on peut éteindre et allumer (la led "assoc" de la platine correspond à D5 en Xbee, soit GPIO 2).

    Lire les ports analogiques

    On peut disposer des ports analogiques du module rn-171-xv assez facilement, pour cela in faut lancer le sampling sur les ports nécéssaires (ici on va tout activer), puis lire le port que l'on vent (ici SEN 5, le fil jaune de l'interface grove) :

    <4.00> set q sensor 0xFF
    AOK
    <4.00> show q 5
    81caa3,
    <4.00> show q 5
    829a72,

    Comme vous pouvez le voir, la valeur est renvoyée en hexadecimal, et nous avons reçus les valeurs de 117411 puis 170610 (converties en décimal, il faut ignorer le premier chiffre). Un oyen simple de convertir ces valeurs est d'ouvrir un interpréteur python et ajouter 0x à ces valeurs :

    ~$ python
    Python 2.7.4 (default, Sep 26 2013, 03:20:26) 
    >>> 0x1caa3
    117411
    >>> 0x29a72
    170610

    Dans ce cas précis, j'ai connecté un senseur de gaz MQ5 sur le xbee carrier et je l'alimente sur batterie (inutile de dire que j'ai soufflé dessus pour faire monter la valeur analogique entre deux lectures, le monoxyde de carbone étant détecté légèrement par le mq5):

    P1010724-2

    Ainsi, à chaque fois que je me connecte en telnet, le module se reveille, je lui demande la valeur du senseur et je me déconnecte, ce qui le fait repasser en sommeil.

    c. Lui demander de nous rappeler

    C'esrt bien joli, mais si l'on a plusieurs capteurs, voudra pouvoir recevoir ces valeurs sans avoir à les demander, à intervales réguliers.

    Pour cela, rien de plus simple :

    <4.00> set ip host <addresse du serveur>
    AOK
    <4.00> set ip remote 8001
    AOK
    <4.00> set ip proto 18
    AOK
    <4.00> set com remote GET$/ma_page?DATA=
    AOK
    <4.00> set q sensor 0xFF
    AOK
    <4.00> set option format 7
    AOK
    <4.00> set sys autoconn 300
    AOK
    <4.00> save
    AOK

    Nous lui demandons ici de se connecter sur notre ip en HTTP (proto 18 = client http et serveur TCP pour le telnet) et d'envoyer la requete "GET /ma_page?DATA=XXX" au port 8001 toutes les 300 secondes.

    Lançons un serveur très simple sur notre machine pour voir ce qu'il reçoit :

    $ python -m SimpleHTTPServer 8001
    Serving HTTP on 0.0.0.0 port 8001 ...192.168.0.112 - - [11/Mar/2014 11:44:19] code 404, message File not found
    192.168.0.112 - - [11/Mar/2014 11:44:19] "GET /ma_page?DATA=0D117E1F100A097E097F06810E4F7AE60654 HTTP/1.0" 404 -

    On peut voir qu'il reçoit une requête sur une page qui n'existe pas (ma_page) avec des données en hexadecimal en arguments.

    Ces données sont décomposées comme cela :

    • Les 4 premiers caractères sont les valeurs des gpio en lecture (au même format que le bitmask plus haut), c'est équivalent aux valeur d'un digitalRead Arduino.
    • Les données suivantes sont sous forme de 16 bit (4 caractères hexa ici) par canal de senseur, c'est équivalent à un analogRead Arduino.

    Ce petit script python nous renvoie les valeurs de façon lisible :

    import re
    
    def get_values(input_string):
        values = re.findall('....', inval)
        digital = [bool((1<<i)&int(values[0],16)) for i in range(16)]
        analogic = [int(values[i+1],16)<<4 for i in range(8)]
        return dict(digital=digital,
                    analogic=analogic)

    A l'utilisation :

    >>> get_values("0D117E1F100A097E097F06810E4F7AE60654")
    ... {'analogic': [516800, 65264, 38976, 38912, 26656, 58080, 503488, 25904], 'digital': [True, False, False, False, True, False, False, False, True, False, True, True, False, False, False, False]}
    >>> get_values("0D117E1F100A097E097F06810E4F7AE60654")["analogic"][5]
    ... 58080

    OIn peut donc voir que notre senseur 5 a la valeur de 58080. Il a donc bien baissé depuis la lecture précédente (j'ai aéré l'espace après avoir lu des valeurs aussi hautes).

    Nous avons donc un lecteur de gaz nocifs en wifi fonctionnant sur batterie et panneaux solaires qui nous envoie les valeurs régulièrement en http, réalisé en moins de 10 minutes. Pas mal non ?

    P1010721-2

    Vous pouvez faire pointer votre rn-xv sur n'importe quel port et adresse (un script php, un serveur wsgi, etc.) avec les arguments que vous souhaitez. Je vous invite à lire la datasheet  et le user-guide du module pour voir toutes les options disponibles (il peut même vous donner son niveau de batterie, se réveiller lorsqu'un port change de valeur, etc).

    Cette méthode s'applique également à d'autres capteurs comme un capteur d'humidité du sol par exemple :

    P1010728-2

  • Configuration d'un Arduino et de son écran couleur tactile

    Avec l'avènement  des smartphones et autres tablettes, les écrans tactiles sont en vogue. Alors pourquoi ne pas connecter un écran tactile sur un Arduino pour réaliser vos propres applications 'tactiles' ?

    Dans cet article, nous allons vous expliquer comment connecter un écran tactile sur un Arduino et comment vous créer un environnement de développement qui vous permettra d'écrire des applications utilisant cet écran !

    Voici la liste du matériel utilisé pour les besoins de cet article:

    Ci dessous le Arduino DUE:

    img_0001_03

    Et le shield LCD:

    lcd-shield

    lcd-shield-back

    Le modèle du Arduino et du shield LCD sont donnés à titre indicatif. Vous pouvez utiliser d'autres modèles de Arduino et d'autres shield LCD. La seule contrainte à respecter est de vérifier que le shield LCD utilisé est compatible avec le Arduino.

    Raccordement du Arduino et du shield LCD

    Le principe d'un shield est le suivant: c'est un composant que l'on superpose à une plateforme de développement (dans notre cas un Arduino), et qui enrichit les fonctionnalités matérielles de la plateforme. Ici l'ajout d'un shield LCD donne à notre Arduino des capacités d'affichage et d'interaction avec l'utilisateur.

    Le raccordement proprement dit se fait en superposant les deux composants:

    raccord1

    Enclenchez les connecteurs métalliques du shield dans les récepteurs en plastique noir du Arduino. Enfoncez le shield bien à fond pour que les connecteurs du shield disparaissent complètement dans les récepteurs du Arduino. Le résultat doit ressemler à cela:

    raccord2

    La même chose vu de haut:

    raccord3

    Le shield et le Arduino sont maintenant raccordés ! Il ne vous reste plus qu'à raccorder le Arduino à votre ordinateur et nous en aurons finis avec les manipulations matérielles. Pour ce faire munissez vous d'un cable micro-usb/usb.  Reliez le coté micro-usb à votre Arduino comme suit:

    arduino-french-8bis

    Ce câble sert à la fois d'alimentation électrique à votre Arduino mais vous permettra aussi d'envoyer à votre Arduino l'application que vous aller réaliser. Branchez l'autre extrémité  du câble à votre ordinateur. Vous devriez voir une petite diode s'allumer sur votre Arduino.

    Ensuite débranchez le Arduino de votre ordinateur. Nous le rebrancherons plus tard.

    Installation du logiciel Arduino

    L'installation matérielle est faite. Reste à créer un environnement de développement qui vous permettra d'écrire une application pour votre Arduino enrichi à l'écran tactile. La pièce maîtresse de l'environnement de développement est le logiciel Arduino. Ce logiciel vous permet à la fois d'écrire une application pour Arduino et d'envoyer votre application sur votre Arduino pour voir le résultat.

    Pour installer le logiciel Arduino, rendez vous sur cette page: http://arduino.cc/en/Main/Software

    Téléchargez la dernière version du logiciel (version 1.0.4 au moment où cet article est écrit). Faites attention à cliquer sur le lien qui correspond au système d'exploitation utilisé par votre ordinateur (Windows ? Mac OS X ?). Un fois le logiciel téléchargé, il convient de le dé-zipper (en utilisant par exemple 7-zip: http://www.7-zip.org/). Une fois le logiciel dé-zippé vous devriez obtenir un répertoire qui s'intitule arduino-1.0.4. Déplacez ce répertoire et mettez le dans un endroit facile d'accès, vous devrez aller dans ce répertoire à chaque fois que vous voudrez utiliser le logiciel Arduino.

    A l'intérieur de ce répertoire vous devriez voir un ensemble de dossiers et de fichiers, dont un fichier intitulé arduino.exe. Double cliquez sur ce fichier, cela démarre le logiciel Arduino.

    Si tout se passe bien, vous verrez apparaître à l'écran quelque chose qui ressemble à ça:

    arduino-french-1

    Notes au utilisateurs du Arduino DUE: si vous êtes l'heureux possesseur d'un Arduino  DUE (modèle utilisé pour réaliser cet article, mais comme nous l'avons déjà précisé d'autres modèles peuvent convenir) il vous faut impérativement utiliser la version 1.5 du logiciel Arduino. Au moment où cet article est écrit, la version 1.5 du logiciel est au stade BETA, ce qui signifie qu'elle n'est pas complètement terminée mais qu'elle est suffisamment aboutie pour être rendue disponible au public. Vous pouvez télécharger la version 1.5 sur la page des téléchargements indiquée précédemment (http://arduino.cc/en/Main/Software).  Les versions inférieures à 1.5 ne sont pas compatibles avec le Arduino DUE.

    Rebranchez maintenant votre Arduino à votre ordinateur.

    Notes aux utilisateurs de Windows: après avoir  rebranché votre Arduino à votre ordinateur,  il se peut que Windows installe des drivers pour finaliser l'installation (ce n'est pas obligatoire, cela dépend du modèle de Arduino et de la version de Windows qui se trouve sur votre ordinateur). Si pendant l'installation des drivers, vous voyez apparaître un message d'erreur, rendez vous sur cette page pour obtenir des instructions d'aide: http://arduino.cc/en/Guide/Windows#toc4

    Il faut maintenant indiquer au logiciel quel est le modèle de votre Arduino: pour ce faire allez dans le menu Outils, rubrique Board et sélectionnez le modèle de votre Arduino. Dans notre cas, nous travaillons avec un Arduino DUE, nous sélectionnons donc Arduino DUE (Programming Port). Nous choisissons Arduino DUE (Programming Port) et non Arduino DUE (Native USB Port) parce que nous avons raccordé le Arduino à notre ordinateur par par le port qui se trouve le plus près de l'alimentation.

    arduino-french-2

    Votre logiciel Arduino est maintenant prêt à être utilisé.

    Installation des librairies UTFT et UTouch

    C'est la dernière étape. Elle consiste à installer les librairies qui vous permettrons d'écrire votre propre application. Une librairie logicielle est un ensemble de programmes utilisables par un autre programme. En clair lorsque nous allons écrire notre application nous allons utiliser des librairies, et ces librairies vont grandement nous faciliter la vie.

    Tout d'abord vous allez pourvoir constater que le logiciel Arduino contient plusieurs librairies pré-installées. En allant dans le menu Croquis puis Importer bibliothèque.... vous verrez apparaître une liste de librairies déjà disponibles.

    arduino-french-3

    Installer la librairie UTFT

    Cette librairie vous servira pour afficher des choses sur l'écran.

    Tout d'abord il faut télécharger la librairie. Pour ce faire rendez vous à cette adresse: http://henningkarlsen.com/electronics/library.php?id=51, puis cliquez sur le lien UTFT.rar. Une fois le fichier téléchargé, il faut le décompresser (en utilisant par exemple 7-zip: http://www.7-zip.org/). A l'issue de la décompression, vous devriez obtenir un répertoire UTFT.

    Retournez ensuite dans le logiciel Arduino,  allez dans le menu Croquis puis Importer bibliothèque.... puis  Ajouter bibliothèque....Utilisez la partie gauche de menu (intitulée 'Dossiers') pour naviguer jusqu'à l'endroit où se trouve le répertoire UTFT. Sélectionnez le et cliquez sur OK.

    arduino-french-4

    Vous devriez maintenant voir apparaître cette librairie dans le menu Croquis puis Importer bibliothèque.... Regardez sur la capture d'écran ci dessous, on voit UTFT  tout en bas du menu.

    arduino-french-5

    Nous allons maintenant vérifier que la librairie fonctionne bien. Comme cette libraire est bien faite elle inclut des exemples d'applications que l'on peut écrire en utilisant cette librairie. Nous allons donc charger un de ces exemple sur notre Arduino pour vérifier que tout fonctionne correctement.

    Aller dans le menu Fichier puis Exemples puis UTFT puis Arduino (Arduino ARM) puis UTFT_DEMO_320*240.

    arduino-french-6

    A ce stade il convient de faire plusieurs remarques.

    Tout d'abord le choix de le rubrique  Arduino ARM. Nous réalisons ce article avec un Arduino DUE qui est le premier Arduino à utiliser l'architecture ARM. Si vous utilisez un autre Arduino, il vous faudra aller dans la rubrique Arduino AVR.

    Deuxième remarque sur le choix de l'exemple UTFT_DEMO_320*240. Nous avons choisis l'exemple qui correspond à la résolution de notre shield LCD. Vous pourrez constater en regardant dans les caractéristiques techniques détaillées (http://hackspark.fr/fr/3-2-tft-touch-shield-for-arduino.html) que la résolution de notre shield est bien de 240 * 320. Si vous utilisez un shield  dont la résolution est différente, sélectionnez un exemple qui correspond à la résolution de votre shield.

    Le chargement de l'exemple provoque l'affichage d'instructions dans la fenêtre de votre logiciel Arduino. Ci dessous une capture d'écran des premières lignes qui devraient s'être affichées dans votre logiciel Arduino:

    arduino-example3

    Les lignes qui s'affichent constituent une application qui utilise la bibliothèque UTFT. L'application est quasiment prête à être envoyée sur votre Arduino. Il reste une opération à effectuer avant de procéder à l'envoi.

    Une des premières lignes de l'application est la suivante:

    UTFT myGLCD(ITDB24E_16,38,39,40,41);

    Ceci est une instruction qui informe l'application sur le type d'écran LCD qui est utilisé avec le Arduino. En particulier c'est le code ITDB24E qui correspond à un certain type de shield LCD. II nous faut remplacer ce code par celui qui correspond à notre modèle de shield LCD.

    Vous me direz:"mais où trouver ce code ?".  Et bien comme la librairie UTFT est bien faite  , elle comporte un document  qui recense les différents codes des différents shield LCD. Allez voir dans le répertoire UTFT que vous avez téléchargé, vous y trouverez un fichier nommé UTFT_Supported_display_modules_&_controllers.pdf. Ouvrez ce fichier. Vous constaterez alors qu'il comporte plusieurs tableaux recensant les différents modèles   supportés par la librairie. Nous allons maintenant décrire comment trouver dans ces tableaux le code du shield que nous utilisons.

    Rappel: pour toutes les caractéristiques techniques de notre shield, les infos sont ici: http://hackspark.fr/fr/3-2-tft-touch-shield-for-arduino.html.

    Tout d'abord le fabricant de notre shield est ITEAD Studio, nous regardons donc dans la partie du tableau qui correspond à ITEAD Studio. Ensuite en regardant de près les caractéristiques techniques du produit vous constaterez que le controller utilisé par le shield est le SSD1289. Dans le tableau regardez l'avant dernière colonne de droite, descendez jusqu'à la ligne SSD1289. La colonne d'avant vous donne le code à utiliser dans vos applications utilisant la librairie UTFT. Dans notre cas le code est: ITDB32S.

    Retournez dans votre logiciel Arduino et changez la ligne:

    UTFT myGLCD(ITDB24E_16,38,39,40,41);

    en

    UTFT myGLCD(ITDB32S,38,39,40,41);

    Vous êtes maintenant prêt à envoyer votre application sur votre Arduino. Dans le logiciel Arduino, cliquez sur l'icone représentant une flèche tournée vers la droite, en haut à gauche du logiciel.

    arduino-french-7

    Quelques seconds plus tard vous devriez voir apparaître une animation l'écran de votre Arduino !

    Si vous voyez une animation sur l'écran, c'est que tout s'est bien passé. Vous pouvez commencer à changer quelques paramètres de l'application pour voir ce que ça change ou écrire votre propre application !

    Nous allons maintenant installer une deuxième librairie qui sert à détecter les actions tactiles de l'utilisateur sur l'écran.

    Installer la librairie UTouch

    Téléchargez cette librairie à l'adresse suivante: http://henningkarlsen.com/electronics/library.php?id=55, le lien s'intitule UTouch.rar.

    La procédure d'importation de la librairie est exactement le même que pour la librairie UTFT, vous devriez donc y arriver sans problèmes. Vous pouvez essayer une des applications exemples qui viennent avec cette nouvelle librairie. Là encore le principe est  le même que précédemment.

    Vous êtes maintenant prêt à écrire votre application, amusez vous bien !

  • Passer un projet électronique sur batterie (panneaux solaires en option)

    Vous venez de finir votre projet, il est tout beau, tout propre.
    Oui, mais est-il transportable ? S'il y a une coupure de courant, que se passe-t-il ?
    Il existe plusieurs solutions pour mettre un projet sur batterie :

    1. Utiliser des bêtes piles, on a plusieurs réceptacles pour cela... mais la recharge doit être séparée ou les piles changées régulièrement. Pas génial.
    2. Utiliser une pile 12V de voiture ou d'onduleur, lourd et pas forcément efficace.
    3. Notre solution préferée, et c'est celle que nous allons étudier ici, utiliser des batteries lithium polymer (li-poly) protégées avec un module de charge usb.

    Dans le cas d'une solution à base de li-poly, il y a plusieurs choses à prendre en compte : la batterie en elle-même (combien allons-nous consommer), le module de charge en lui-même (combien allons nous consommer en pic) et la recharge (usb ? énergie solaire ? eau qui coule ? roue de vélo ? etc.)

    1. Quelle batterie ?

    Batteries HackSpark

    Mettons que nous ayons un projet avec un arduino uno, quelques senseurs, une ou deux leds et une carte SD, ça nous fait pas beaucoup d'énergie au final (5V 200mA environ). Si on veut être alimenté tout le temps sauf de temps en temps et continuer à marcher lorsque l'on est débranché (continuer en cas de coupure de courant), on pourra prendre une petite batterie 1000mah. Pour tenir un petit moment une batterie 2000mah (en 3.7v, ça équivaut à environ 1500mah en 5v soit 7h30 environ).

    Si l'on veut tenir plus longtemps ou que notre projet consomme plus (utilisant une carte Raspberry Pi par exemple), on peut opter pour une batterie de 6000mAh (donnant environ 22h d'autonomie à notre exemple précédent, 12 à 16h à un RPi modèle A et 7 à 10h à un RPi modèle B, selon l'utilisation du cpu et de l'usb).

    2. Quel module de charge ?

    Modules de charge LiPo Rider Pro et LiPo Rider côte à côte Modules de charge LiPo Rider Pro et LiPo Rider côte à côte

    Avoir une batterie, c'est bien, mais autant faut il pouvoir l'utiliser.

    Certaines cartes vendues ici proposent un port permettant d'en raccorder une en direct (la seeeduino mega par exemple), mais autant prendre une solution générique.

    Pour cela, on en a choisi deux :

    1. La carte LiPo Rider est un bon choix car elle permet de brancher n'importe quel périphérique en usb et l'alimenter à partir de la batterie.
      Dès que vous branchez le lipo rider à l'ordinateur, vous accédez de façon transparente au device alimenté (votre arduino pour l'exemple précédent, et ainsi le programmer pendant que vous le chargez) tout en rechargeant la batterie. L'autre avantage est qu'il supporte l'adjonction d'une source externe comme un panneau solaire, une dynamo ou un générateur hydro.
      Petit bémol, sa sortie d'énergie en pointe est de 350mA en 5V, donc ce sera suffisant pour un arduino avec quelques capteurs, mais si vous voulez alimenter une matrice de leds, un moteur ou autre chose, passez à la carte suivante.
    2. La carte LiPo Rider Pro a les memes fonctionnalités que sa petite soeur, mais permet de sortir 1A en 5V, de quoi alimenter un raspberry pi avec sa clé wifi, un arduino avec des petits moteurs, etc. Vous pourrez même l'utiliser pour charger votre téléphone portable en fait.

    3. Quelle source d'énergie ?

    Lorsque l'on peut être branché au secteur ou à un ordinateur, pas de soucis, on se recharge lorsque l'on est branché en USB, et on utilise la batterie lorsque l'on ne l'est pas. Pas besoin d'une source annexe.

    En revanche, pour des projets nomades ou devant rester à l'extérieur, nous avons plusieurs sources d'énergie à notre disposition, que ce soit une dynamo sur un vélo, un générateur hydro ou des panneaux solaires. Pour notre exemple, nous allons nous intéresser plus particulièrement aux panneaux solaires, en particulier les panneaux photo-voltaïques. On les classe selon la puissance restituée, ceux proposés sur HackSpark sont en 3.7v et proposent des puissances allant de 1.5 à 3W.

    Panneaux solaires HackSpark

    Dans le cas de l'Arduino avec des capteurs, le projet consomme 200mA à 5V, soit 1W. Un panneau de 1.5W est donc suffisant en source d'énergie d'appoint, mais devient limité lorsque l'on doit tenir toute une nuit par exemple.

    Si l'on utilisait un MSP 430 Launchpad à la place d'un Arduino, on pourrait consommer beaucoup moins, 50 à 100mA environ et encore, uniquement lors des réveils (le msp430 peut entrer en veille quasi-complète pendant de longues périodes); Dans ce cas le 1.5W serait parfait.

    Revenons à notre exemple, on prendrait plutôt un panneau solaire 2.5W, laissant 1.5W à la charge d'une batterie lors des périodes ensoleillées.

    Dans le cas d'un Raspberry Pi, le Type B consomme environ 350mA en activité moyenne et jusqu'à 700mA lors des pics de cpu. Prenons la valeur moyenne de 300mA, cela nous fait 0.4x5 => 2W, un panneau de 2.5W sera tout juste suffisant alors qu'un panneau de 3W sera adapté. Un Raspberry Pi type A en revanche, consomme beaucoup moins, et pourra être opéré avec un panneau de 2.5W sans trop de soucis.

    4. Connectons tout ça...

    Connexion

    Tout d'abord, il faut relier la batterie au LiPo Rider, grâce à la prise prévue à cet effet.

    Si vous avez choisi d'utiliser un panneau solaire pour augmenter l'autonomie de votre projet, c'est le moment de le connecter également.

    Maintenant, connectez votre dispositif (Arduino, Raspberry Pi, etc.) avec la prise USB host femelle (comme celle d'un ordinateur).

    Pour finir, allumez le dispositif à l'aide du sélecteur on/off sur le Lipo Rider. Et voilà, vous avez un dispositif autonome. Ce n'était pas très compliqué :)

    img_0001_02

    5. Et ensuite ?

    Faire marcher c'est une chose, avoir de l'autonomie c'en est une autre, et vous devrez tôt ou tard penser à optimiser votre projet pour l'économie d'énergie.

    Avec un Raspberry Pi la solution facile est de passer au Raspberry Pi modèle A qui est beaucoup moins gourmand en énergie.

    Avec un Arduino, une solution est de passer aux MSP430 qui ont un IDE équivalent à Arduino disponible sur internet, vous permettant de continuer à utiliser votre code, l'autre, plus simple et aidant un peu (moins) est de passer à une carte Arduino supportant l'exécution en 3.3v comme la Seeeduino des photos ci-dessus ou l'iTeaduino.

    Chacun a ses solutions pour moins consommer, l'essentiel étant d'arriver à équilibrer la consommation électrique avec la vitesse de charge et/ou l'autonomie désirée.

  • Connecter des dispositifs sans fil à votre Arduino ou Raspberry Pi, Partie 1: Réception en 433Mhz

    leonardo_montage

    Vous avez sans doute entendu parler ou vu des détecteurs de fumée, d'ouverture de porte, des télécommandes, des prises murales, etc. sans fil ?

    Que ce soit les modèles chers que vous trouvez en magasin ou les modèles chinois bon marché, la plupart, s'ils ne sont pas avancés, utilisent la bande de fréquence 433 mhz (n'essayez pas ceux en 315, ils sont illégaux en France). Certains autres sont en 2.4 ghz, mais nous les laisserons de coté pour l'instant.

    En ce qui concerne ces capteurs en 433mhz, il se trouve qu'ils utilisent pour la plupart un protocole très simple, introduit par des circuits intégrés chinois à bas cout, les PT2262 coté émission et les PT2272 coté réception (d'autres plus exotiques comme les SC5262 / SC5272, HX2262 / HX2272, EV1527, RT1527, FP1527 ou encore HS1527 peuvent être trouvés et fonctionneront aussi).

    Plutot que de nous lancer dans l'acquisition de ces chips, on va utiliser notre microcontrolleur, plus que capable de le faire, pour décoder et encoder les signaux, grâce à la librairie RC-Switch pour Arduino, ou RCSwitch-pi pour la Raspberry Pi.

    Regardons de plus prêt ce que nous avons à disposition :
    - Un Arduino (ici un Leonardo, mais un Uno ou un clone quelconque fera l'affaire)
    - Une breadboard
    - Un 433 mhz RF link kit (un émetteur, un récepteur)
    - Des fils à breadboard

    composants

    Niveau détecteurs:
    - Un détecteur d'ouverture de porte
    - Un détecteur PIR

    pir doorswitch

    Regardons ce détecteur d'ouverture de porte de plus près :

    20121217_124151

    On voit bien le PT2262 pour l'encodage et à gauche des jumper pour choisir le code (ainsi chaque émetteur aura un code différent).
    Pas besoin de déduire le code de ces jumpers, on va faire un petit programme Arduino qui nous les dira au fur et à mesure de leur activation.

    1 / installation de la librairie RC Switch :

    1. Télécharger RCswitch_2.3.zip
    2. Extraire le contenu dans le sous-repertoire "libraries" (s'il n'existe pas, créez le) de votre répertoire "sketchbook", pour que cela donne :
      • sous Mac, /Users/<votre utilisateur>/Documents/Arduino/libraries/RCswitch
      • sous Linux, /home/<votre utilisateur>/sketchbook/libraries/RCswitch
      • sous Windows, C:\Users\<votre utilisateur>\Documents\Arduino\libraries\RCswitch

    2/ Connexion du récepteur

    Le récepteur est simple, il suffit de le connecter au courant (+5v et GND) et à un pin de l'Arduino ayant une interruption.

    recepteur

    Voici un petit tableau des interruptions :

    Carte int.0 int.1 int.2 int.3 int.4 int.5
    Uno, Ethernet 2 3
    Mega2560 2 3 21 20 19 18
    Leonardo 3 2 0 1

    Sur notre Leonardo, si nous voulons connecter notre récepteur sur l'interrupt 0, il nous faut le connecter sur le pin 3 :

    leonardo_montage

    3/ Recevons des codes

    Pour cela, nous allons lancer l'ide arduino et charger l'exemple de RCSwitch, "ReceiveDemo_Simple".

    Pour le Leonardo, il faut ajouter "while (!Serial) ;" avant d'écrire sur le port série (lié à l'utilisation de l'usb après le lancement) :

    sketch_demo

    Envoyons le croquis sur la carte, et lancons le moniteur série (Outils > Moniteur Série, après avoir vérifié que le port était le bon dans Outils > Port série).

    Actionnez votre senseur (ici le détecteur d'ouverture de porte, en écartant les deux parties):

    montage

    Et magie, des codes s'affichent dans le moniteur série :

    serial_print

    Ce code, 13464924 dans cette capture d'écran, est l'id unique de votre senseur, 24bit est la taille de celui-ci et 1 le protocole utilisé (ici celui du PT2262).

    Si l'on active un autre senseur (le capteur de mouvement ici, il s'allume en rouge lorsqu'il détecte un mouvement):

    20121217_105715

    deux_codes

    On voit que l'on reçoit un nouveau code : 12449942.

    Note: si vous ne voyez rien dans la console avbec un Leonardo, c'est quelque chose qui arrive souvent, n'hésitez pas à ouvrir un autre moniteur série que celui livré avec l'ide Arduino. Par exemple, putty fait très bien l'affaire même sous linux. La commande "putty -serial /dev/ttyACM2 -sercfg 9600" permet d'ouvrir ttyACM2 en 9600 baud. (remplacer /dev/ttyACMx par COMx sous windows :))

    4/ Interprétons

    De là à garder ces codes et à donner une information humainement compréhensible, il n'y a qu'un pas.

    Essayons d'envoyer une information utile sur le port série :

    #include <RCSwitch.h>
    
    #define couloir 12449942
    #define porte 13464924
    
    RCSwitch mySwitch = RCSwitch();
    
    void setup() {
      Serial.begin(9600);
      mySwitch.enableReceive(0);
    }
    
    void loop() {
      if (mySwitch.available()) {
    
        int value = mySwitch.getReceivedValue();
    
        while (!Serial) ;
    
        switch (value) {
          case porte:
            Serial.println("Quelqu'un a ouvert la porte !");
            break;
          case couloir:
            Serial.println("Quelqu'un marche dans le couloir !");
            break;
          default:
            Serial.print("Dispositif inconnu: ");
            Serial.println(value);
            break;
        }
    
        mySwitch.resetAvailable();
      }
    }

    D'abord dans setup() on initialise mySwitch sur l'interrupt 0, ensuite, dans le loop() lorsque l'on recoit un message, on agit selon ce qui est reçu.
    On envoie un message simple "Quelqu'un a ouvert la porte !" ou "Quelqu'un marche dans le couloir !" selon le cas.

    Voici ce que l'on reçoit sur le port série :

    Capture du 2012-12-17 14:04:54

    Comme vous pouvez le voir, on a l'information, mais elle se répète. C'est du à la nature du protocole, qui ne permet pas de vérifier la réception de l'information. Du coup, elle est envoyée plusieurs fois pour être sur de sa réception.

    Pour régler ce problème, il suffit d'ajouter un timer sur la réception, pour ne l'avoir qu'une seule fois :

    #include <RCSwitch.h>
    
    #define couloir 12449942
    #define porte 13464924
    
    RCSwitch mySwitch = RCSwitch();
    
    #define debounceDelay 1000 // On limite à un évènement par seconde
    long last_times[2] = {0,0}; // On a deux détecteurs, donc on a deux timers.
    
    void setup() {
      Serial.begin(9600);
      mySwitch.enableReceive(0);
    }
    
    bool debounce(int number) {
      if ((last_times[number] == 0)
          || ((millis() - last_times[number]) > debounceDelay)) {
        last_times[number] = millis();
        return true;
      }
      return false;
    }
    
    void loop() {
      if (mySwitch.available()) {
    
        int value = mySwitch.getReceivedValue();
    
        // on remet à zero le timer
    
        while (!Serial) ;
    
        switch (value) {
          case porte:
            if (debounce(0))
              Serial.println("Quelqu'un a ouvert la porte !");
            break;
          case couloir:
            if (debounce(1))
              Serial.println("Quelqu'un marche dans le couloir !");
            break;
          default:
            Serial.print("Dispositif inconnu: ");
            Serial.println(value);
            break;
        }
    
        mySwitch.resetAvailable();
      }
    }

    Notre fonction debounce permet, pour un détecteur donné (de 0 à 1 ici), de dire si c'est un nouvel événement ou pas.
    Voici ce que cela donne si j'ouvre la porte, marche jusqu'à une autre porte puis ouvre cette autre porte inconnue :

    Capture du 2012-12-17 14:21:21

    Comme vous pouvez le voir, nous n'avons pas de timer sur l'émetteur inconnu mais on en a un sur ceux qui sont connus.

    5/ La suite ?

    Dans la deuxième partie nous verrons comment envoyer des signaux à une prise en 433 mhz, et à envoyer et recevoir des signaux entre arduino selon le même principe.

    A bientôt !

6 Item(s)