[Tuto] : Les sleep modes de l’ESP32

Les sleep modes sont des états qui permettent de mettre en sommeil l’ESP 32. On éteint alors certains périphériques et les données sont conservées dans la RAM.

Il existe 5 modes d’économie d’énergies différents, nous allons les étudier un à un :

  • mode actif ( par défaut)
  • mode modem
  • mode light speed
  • mode sommeil profond
  • mode hibernation

Le mode actif : normal

Tout est allumé.

Le mode modem : WiFi, Bluetooth et radio désactivés

Pour maintenir les connexions WiFi / Bluetooth vivantes, le processeur, le Wi-Fi, Bluetooth et la radio sont réactivés à des intervalles prédéfinis. Ces modules sont responsables de la majeure partie de la consommation de la carte, c’est pourquoi nous allons chercher à les désactiver.

Pendant ce mode de veille, le mode d’alimentation bascule entre le mode actif et le mode veille du modem.

L’ESP32 peut entrer en mode veille du modem uniquement lorsqu’il se connecte au routeur en mode station ( connexion sans fil).

L’ESP 32 reçoit à intervalle régulier des message DTIM (Delivery Traffic Indication Message) du routeur pour l’informer que la communication avec celui ci est possible.

Entre deux messages DTIM, les échanges de données  avec le routeur sont impossibles, le WiFi et le Bluetooth sont donc désactivés durant ce laps de temps pour économiser de la batterie. Le temps de sommeil est généralement compris entre 100 et 1000 ms.


Light Sleep mode

Il comporte toutes les fonctionnalités du mode modem et plus encore. Ce mode permet d’économiser encore plus de batterie en utilisant le procédé de “Clock-Gating”.

Ce phénomène est à l’oeuvre dans la RAM et le CPU où des parties du circuit sont mises hors tension pour empêcher les bascules flip-flop qui composent le circuit de changer d’état.

Ces bascules sont synchronisées par l’horloge interne de la carte (RTC). En mode actif, elles changent d’état (effectuent une action), à chaque coup d’horloge. En mode light sleep, ce n’est plus le cas, elles restent dans le même état.

C’est  uniquement durant le changement d’état qu’il y a consommation, le clock gating permet donc d’économiser de la batterie.

Avant d’entrer en mode light sleep, L’ESP garde en mémoire les données et reprendra l’exécution du code là ou il s’est arrêté. L’avantage de ce mode est qu’il permet un réveil rapide tout en économisant de la batterie. 

Pour observer le fonctionnement du mode light sleep, je vous propose de téléverser le code suivant et d’ouvrir le moniteur série. 


void setup() {
    Serial.begin(115200);
    Serial.println("setup");
}

void loop() {
    esp_sleep_enable_timer_wakeup(5000000); //5 seconds
    int ret = esp_light_sleep_start();
    Serial.print("light_sleep:");
    Serial.println(ret);
}

Vous observerez que la carte ne reboot pas en sortie de sommeil et qu’elle reprend l’exécution du programme toutes les 5 secondes là où elle s’était arrêtée.

Deep Sleep

Pendant le deep sleep mode la majeure partie de la RAM et tous les périphériques numériques sont mis hors tension. Les seules parties de la puce qui restent sous tension sont les suivantes :

  • contrôleur RTC
  • périphériques RTC (y compris le processeur ULP)
  • mémoires RTC (lentes et rapides).

Nous allons réaliser un montage visant à montrer que même en plongeant notre carte en sommeil profond, il est possible de sauvegarder des données.

Vous aurez besoin de :

Montage à réaliser

Pour sauvegarder une variable même après avoir mis l’ESP en deep sleep mode il faut l’enregistrer dans la mémoire RTC en déclarant la variable en globale avec le type :

RTC_DATA_ATTR

par exemple :

RTC_DATA_ATTR int bootCount = 0;

copiez collez le code et téléversez le à l’aide de l’IDE arduino.


#define uS_TO_S_FACTOR 1000000  /* Conversion factor for micro seconds to seconds */
#define TIME_TO_SLEEP  3        /* Time ESP32 will go to sleep (in seconds) */

RTC_DATA_ATTR int bootCount = 0;

int GREEN_LED_PIN = 25;
int YELLOW_LED_PIN = 26;

void setup(){

  pinMode(GREEN_LED_PIN,OUTPUT);
  pinMode(YELLOW_LED_PIN,OUTPUT);
  delay(500);
  
  if(bootCount == 0) //Run this only the first time
  {
      digitalWrite(YELLOW_LED_PIN,HIGH);
      bootCount = bootCount+1;
  }else
  {
      digitalWrite(GREEN_LED_PIN,HIGH);
  }
  
  delay(3000);

  digitalWrite(GREEN_LED_PIN,LOW);
  digitalWrite(YELLOW_LED_PIN,LOW);

  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
  esp_deep_sleep_start();
}

void loop(){
  
}

Contrairement au mode light sleep, la carte redémarre à chaque réveil et effectue donc à nouveau le setup.  

Dans ce code, on instancie une variable bootcount qu’on stocke dans la mémoire RTC. La première fois que le setup est effectué, la led jaune doit s’allumer car bountcount est égale à 0.

En sortie de sommeil profond, Bountcount est égale à 1 car la variable a été incrémentée au tour d’avant. Cette fois ci, seul la led verte s’allume. La valeur de notre variable est conservée, la led jaune ne s’allume donc qu’une seule fois. 

Mode Hibernation

Il désactive les mêmes fonctionnalités désactivées par le mode sommeil profond. A cela s’ajoute le fait que la mémoire RTC est aussi privée d’alimentation. Il en résulte qu’il est impossible de sauvegarder des données en utilisant ce mode d’économie d’énergie. 

La consommation durant ce mode est censée être extrêmement faible (seulement quelques micro ampères)

Les façons de réveiller l’ESP32 :

Une fois mis en sommeil, il existe différentes façons de réveiller un ESP32. La déclaration de ces fonctions doit toujours se faire avant l’appel de la fonction provoquant le mode sleep. Cependant, vous pouvez toujours réveiller votre ESP32 en appuyant sur le bouton EN. Cela le redémarrera.  

Timer :

Cette méthode peut être utilisée quelque soit le mode d’économie d’énergie activé. La carte se met en sommeil durant un temps défini par l’utilisateur et se réveille ensuite. 

esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP)// temps en micro seconde;

C’est cette méthode qui a été utilisée dans les exemples ci dessus.

Réveil externe :

Il est possible de réveiller un ESP32 après lui avoir envoyé un signal  digital sur une de ces pin.

void setup() {
    Serial.begin(115200);
    Serial.println("setup");
}

void loop() {
    esp_sleep_enable_ext0_wakeup(GPIO_NUM_27,HIGH);
    int ret = esp_light_sleep_start();
    Serial.print("light_sleep:");
    Serial.println(ret);
}

Ce code permet de sortir du mode light sleep dès que la pin 27 reçoit un 1 logique. Si le signal repasse à 0, la carte retombera en mode sommeil. 

Avec certains ajustements, il est aussi possible d’utiliser une interruption externe pour sortir du mode sommeil profond : 

void setup() {
    Serial.begin(115200);
    Serial.println("setup");
}
void loop() {
    esp_sleep_enable_ext0_wakeup(GPIO_NUM_27,LOW);
     esp_deep_sleep_start();// la fonction ne retourne rien
}

On est plongé dans le mode sommeil profond tant que la valeur sur la pin 27 est à HIGH.  

Vous êtes maintenant en mesure de comprendre comment les différents sleep modes de l’ESP32 fonctionnent et vous pouvez désormais les utiliser.

[Tuto] Programmation d’un ESP32 Basic Over The Air (OTA) avec l’IDE arduino

Le but de ce tutoriel est de programmer un esp32 pour pouvoir téléverser du code sans être relié physiquement à la carte. 

Ce tutoriel repose sur l’utilisation du code fourni dans la bibliothèque esp32 : Basic OTA, ainsi l’ordinateur avec lequel le code sera téléversé doit être connecté au même réseau WiFi que notre carte. 

tutoriel réalisé à l’aide du tutoriel de last minute engineers 

Matériel :

1 carte esp 32 (modèle Node32s)

Installation de Python 2.7.15

  1. Cliquez ici et téléchargez la version  qui correspond à votre système d’exploitation. Pour windows, favorisez la version MSI installer 
  2. cochez la case ‘install for all users’
  3. Dans la partie  “ Customise Python 2.7.15”, activez l’option add Python.exe to path : 

Initialisation :

1.Téléchargez la dernière version de l’IDE Arduino.

2. Si vous utilisez la carte mentionnée ci dessus, vous allez devoir ajouter la carte dans la liste des cartes prises en charge par l’IDE Arduino. Ouvrez l’IDE, « Fichier » → « Préférences » et dans « URL de gestionnaire de cartes supplémentaires » ajoutez le lien suivant : https://dl.espressif.com/dl/package_esp32_index.json

3. Allez ensuite dans le gestionnaire de carte et tapez esp 32 : téléchargez la version 1.0.0 de esp by Espressif system. Cela peut prendre quelques minutes. A la fin vous devez avoir le résultat ci contre :

4. Modifiez l’onglet outils pour qu’il corresponde à l’image ci dessous : 

Vous pouvez connaître le port COM de votre carte à l’aide d’un gestionnaire de périphérique. 

5. Copiez collez le code fourni

// Code exemple fournit dans la bibliothèque esp 32 espressif
// Ajout d'un programme pour vérifier le fonctionnement du téléversement à distance.
#include <WiFi.h>
#include <ESPmDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>

const char* ssid = "-----";
const char* password = "-----";

//variabls for blinking an LED with Millis
/*const int led = 2; 
// ESP32 Pin to which onboard LED is connected
unsigned long previousMillis = 0;  // will store last time LED was updated
const long interval = 1000;  // interval at which to blink (milliseconds)
int ledState = LOW;*/ // ledState used to set the LED

void setup() {

//pinMode(led, OUTPUT);  
  Serial.begin(115200);
  Serial.println("Booting");
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
    Serial.println("Connection Failed! Rebooting...");
    delay(5000);
    ESP.restart();
  }

  // Port defaults to 3232
  // ArduinoOTA.setPort(3232);

  // Hostname defaults to esp3232-[MAC]
  // ArduinoOTA.setHostname("myesp32");

  // No authentication by default
  // ArduinoOTA.setPassword("admin");

  // Password can be set with it's md5 value as well
  // MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
  // ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");

  ArduinoOTA
    .onStart([]() {
      String type;
      if (ArduinoOTA.getCommand() == U_FLASH)
        type = "sketch";
      else // U_SPIFFS
        type = "filesystem";

      // NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
      Serial.println("Start updating " + type);
    })
    .onEnd([]() {
      Serial.println("\nEnd");
    })
    .onProgress([](unsigned int progress, unsigned int total) {
      Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
    })
    .onError([](ota_error_t error) {
      Serial.printf("Error[%u]: ", error);
      if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
      else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
      else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
      else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
      else if (error == OTA_END_ERROR) Serial.println("End Failed");
    });

  ArduinoOTA.begin();

  Serial.println("Ready");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
}

void loop() {
  ArduinoOTA.handle();
  //loop to blink without delay
 /*unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) {
  // save the last time you blinked the LED
  previousMillis = currentMillis;
  // if the LED is off turn it on and vice-versa:
  ledState = not(ledState);
  // set the LED with the ledState of the variable:
  digitalWrite(led,  ledState);
  }*/
}

6. Renseignez votre identifiant WiFi et votre mot de passe : 

const char* ssid = "-----"; // nom du réseau
const char* password = "-----";// mot de passe

7.Téléversez le code. Il peut être nécessaire de maintenir le bouton Boot  de la carte enfoncé durant cette étape. 

8. Ouvrez le moniteur série ( en appuyant sur la petite loupe en haut à gauche) et appuyez sur le bouton EN de la carte. 

Voici l’affichage que vous devez obtenir. Sur la dernière ligne, vous pourrez observer votre adresse IP, notez la car vous en aurez besoin pour la suite. 

Si l’affichage du moniteur série ne correspond pas à l’image ci dessus, veuillez à nouveau appuyer sur le bouton EN. 

Téléversement d’un nouveau croquis Over-The-Air

Pour permettre le téléversement OTA, la séquence d’initialisation que nous venons de compiler doit toujours être présente. Ainsi, pour des questions de simplicité, nous allons rajouter du code dans notre exemple. 

Pour s’assurer que le téléversement sans fil fonctionne, nous allons  réaliser un programme faisant clignoter la led interne de notre carte. 

1.Décommentez  les lignes 14 à 17, la ligne 21 ainsi que les lignes 83 à 91. 

Les plus observateur d’entre vous auront remarqué que le code dans la fonction loop() est un peu plus compliqué que nécessaire. Cela est dû au fait qu’en programmation OTA, il est déconseillé d’utiliser la fonction delay(). En effet, lorsque cette fonction est utilisée sur un ESP32, la carte se met en pause. Si la prochaine requête OTA est générée pendant que notre carte est en pause, le programme va manquer la requête et ne pourra s’exécuter correctement. 

2. Changez le port dans l’onglet Outils de l’IDE. Une nouvelle catégorie intitulée port réseau devrait être disponible.

L’adresse IP doit correspondre à celle qui était affichée lors de la phase d’initiation.  Si vous ne trouvez pas le port, il peut être nécessaire de redémarrer l’IDE.

3. Téléversez le nouveau code; Une led bleue doit clignoter à une fréquence de 1Hz. Si tel est le cas, le programme a été téléversé à distance, vous avez réussi. 


[Tuto] Mise en marche de l’Ultimate GPS FeatherWing via le HUZZAH ESP8266 Wifi

Comment lire les coordonnées lue par le GPS à travers le HUZZAH ESP8266 Wifi?

1.Montage

Le but de ce montage est de tester le featherwing GPS via le Feather HUZZAH ESP8266 Wifi. Les cartes ne sont pas directement compatibles en mode shield, il est donc nécessaire de simuler un nouveau couple de ports RX/TX.


Effectuer les connexions suivantes :

  • le pin 3V du GPS au pin 3V de l’ESP
  • le pin GND du GPS au pin GND de l’ESP
  • Pin 12 de l’ESP au pin TX du GPS
  • Pin 14 de l’ESP au pin RX du GPS
  • Brancher l’ESP à un pc avec un câble USB

2. Programme

Le Programme permet de lire les données envoyées par le GPS, sur le serial monitor de l’IDE Arduino.

Avant de mettre le programme sous Arduino IDE, vous devez ajouter des types de cartes supplémentaires.

  1. Pour cela, aller dans Fichier/Préférence puis coller le lien suivant : http://arduino.esp8266.com/stable/package_esp8266com_index.json
  2. Coller le dans le champ texte “URL de gestionnaire des cartes supplémentaires”.
  3. Valider l’entrée en appuyant sur “OK”.
  4. Ensuite,aller dans Outils/Type de carte et choisir Generic ESP8266 module.
  5. Choisir nodemcu dans Outils/Reset Method
  6. Copier/Coller le programme suivant :

Code :

 
#include <Adafruit_GPS.h>// https://github.com/adafruit/Adafruit_GPS.git
#include <SoftwareSerial.h>// déjà intégré à Arduino
#define BAUD_RATE 115200 // vitesse de communication de l’USB
#define BAUD_RATE_GPS 9600 // vitesse de communication entre le GPS et ESP8266 généralement 9600 baud

SoftwareSerial swSer(12, 14, false, 256); // Crée une sortie (RX, TX) dans la variable swSer
void setup()  // Programme d’initialisation
{
 Serial.begin(BAUD_RATE); // Initiation de la sortie UART de HUZZAH
 swSer.begin(BAUD_RATE_GPS); // Initiation de la sortie UART du gps
 pinMode(0, OUTPUT); // Initialise le PIN 0 en sortie
 Serial.print("\nEntering Setup"); // Affiche sur le moniteur “Entering Setup”
 Serial.println("\nSoftware serial test started"); // Affiche sur le moniteur “Software serial test started"

 for (char ch = ' '; ch <= 'z'; ch++) { //test pour afficher tous les caractères à la suite
   swSer.write(ch);
   Serial.write(ch);
   swSer.println("");
   }
 Serial.println("\nSoftware serial test done");// Affiche sur le moniteur “Software serial test done"
}

void clignot() {  // sous-programme qui fait clignoter la led rouge
 for (int i =0; i<= 10; i++) {
   digitalWrite(0, HIGH);  // Allume la LED
   delay(500);  // Attend 500ms
   digitalWrite(0, LOW);  // Eteint la LED
   delay(500);
   }
}

void loop() {
//  clignot(); //test si HUZZAH répond
//affiche ce que le GPS envoie
 if (swSer.available()) {    // regarde si la sortie est “libre”
char c = swSer.read(); // mets ce que envoie le GPS dans la variable caractère c
   Serial.write(c); // Affiche ce que contient la variable c
 }    
}

Le programme ci dessus affiche dans le Moniteur série:


$GPGGA,001336.799,,,,,0,00,,,M,,M,,*78
$GPGSA,A,1,,,,,,,,,,,,,,,*1E
$GPRMC,001336.799,V,,,,,0.00,0.00,060180,,,N*42
$GPVTG,0.00,T,,M,0.00,N,0.00,K,N*32

GPRMC et GPGGA sont les lignes qui contiennent les coordonnées qui nous intéressent. Le GPRMC est une trame d’information (souvent utilisée dans la navigation maritime). Le GPGGA est une trame d’information couramment utilisée pour connaître la position courante du récepteur GPS.

EX:$GPGGA,064036.289,4836.5375,N,00740.9373,E,1,04,3.2,200.2,M,,,,0000*0E

  • 064036.289: Heure exprimée en hhmmss.ms (06H40min36s et 289ms).
  • 4836.5375,N,00740.9373,E : Coordonnées liées à la position.
    1. Latitude 48 degré et  36,5375 minutes Nord (N = Nord / S =Sud).
    2. Longitude -74 degré  et 40,9373 minutes Ouest (W = Ouest / E = Est).
  • 1: Type de positionnement ( 1 = positionnement GPS).
  • 04: Nombre de satellites utilisés pour calculer les coordonnées.
  • 3.2: Précision Horizontale.
  • 200.2,M: Altitude en mètres.
  • ,,,,0000 : D’autres données peuvent être inscrite.
  • *0E : Contrôle de parité de la trame au format hexadécimal.

Pour une meilleure réception des données  du GPS, il est conseillé de l’utiliser en extérieur.

Source:

https://fr.wikipedia.org/wiki/NMEA_0183

https://www.uni-weimar.de/projekte/costumes-and-environment/2017/05/19/tutorial-connecting

[TUTO] – Fabriquer un compteur de likes Facebook, Twitter et Instagram

Aujourd’hui, nous réalisons un compteur de likes Facebook, Instagram et Twitter connecté en wifi. Il vous permettra d’afficher votre nombre de likes depuis votre page facebook, ainsi que votre nombre de followers instagram et twitter.

1. Matériel utilisé

Afin de réaliser votre compteur de likes, il vous faudra :

2. Montage

Connectez les 5 fils de la manière suivante : 

Matrice LEDLinkNode D1
5v5v
GNDGND
CS1D2
WRD3
DATAD4

Si vous disposez d’une imprimante 3D, vous pouvez télécharger le fichier d’impression 3D afin de fabriquer le boîtier. Visser l’écran ainsi que le LinkNode D1 de la manière suivante :

3. Le code

  1. Téléchargez la dernière version de l’IDE Arduino.
  2. Si vous utilisez le LinkNode D1, vous allez devoir ajouter la carte dans la liste des cartes prises en charge par l’IDE Arduino. Ouvrez l’IDE, « Fichier » → « Préférences » et dans « URL de gestionnaire de cartes supplémentaires » ajouter le lien suivant :


    http://arduino.esp8266.com/stable/package_esp8266com_index.json

  3. Vous pouvez télécharger le code du compteur de likes sur github.
  4. Déplacer les librairies téléchargées avec le compteur de likes dans votre répertoire Arduino /librairies
  5. Votre répertoire Arduino devrait ressembler à cela
  6. Raccordez votre compteur de likes grâce à un câble USB/microUSB  vers votre ordinateur.
  7. Ouvrez votre IDE Arduino et modifiez les lignes 23-24 par le nom de votre réseau wifi ainsi que le mot de passe.

3.a Facebook

  1. Pour lier votre compte Facebook, vous devez vous rendre sur l’API Facebook et vous identifier. (Afin de pouvoir afficher le nombre de likes sur votre page vous devez en être administrateur).
  2. Sélectionnez « Mes applications » → « Ajouter une application », nommez votre application et faites « Créer un ID d’app ».
  3. Sélectionnez « Outils » → « Explorateur de l’API Graph », puis récupérez le token d’accès (Ctrl+C).
  4. Toujours dans “Outils”, sélectionnez “Outils de débug de tokens d’accès”, coller (Ctrl+v) le dans la barre associée, puis cliquez sur “Débuguer“. Des informations sur le token d’accès devrait s’afficher dont sa durée d’expiration. Par défaut il expire au bout d’une heure, pour éviter cela cliquez sur “étendre le token d’accès”. Un nouveau token d’accès vous est donné, copiez le.
  5. Afin de récupérer l’ID de votre page, copiez l’url de votre page sur ce site puis cliquez sur “Find numeric ID”.
  6. Ajoutez le token d’accès et votre ID de page dans le fichier like_counter.ino à la ligne 25-26.

3.b Instagram

  1. Afin de lier votre compte Instagram, commencez par vous identifier sur la plateforme dédiée ici.
  2. Cliquez sur « Manage Clients ».
  3. Puis remplissez les champs de la manière suivante.
  4. Dans l’onglet « Security », décochez « Disable implicit OAuth ». Puis cliquez sur « Register ».
  5. Une fois enregistré, vous devriez pouvoir voir votre application comme ceci, et trouver votre Client ID.
  6. Copier / coller l’URL suivante en remplaçant “[CLIENT_ID]” par le votre dans un navigateur web :

    https://instagram.com/oauth/authorize/?client_id=[CLIENT_ID]&redirect_uri=http://localhost&response_type=token

  7. vous devriez récupérer une URL de ce type : http://localhost/#access_token=********** , avec votre access token à la fin.
  8. Il ne vous restera plus qu’à l’ajouter dans le code, ligne 29.

3.c Twitter

  1. Pour lier votre compte Twitter, rien de plus simple. Récupérez votre nom de page dans l’url. (ex: https://twitter.com/letmeknowfr?lang=fr → le nom de notre Twitter est « letmeknowfr »)
  2. Puis ajoutez le dans le programme du compteur ligne 27.

3.d Téléverser le code

  1. Afin de téléverser le code sur votre carte, commencez par sélectionner votre carte. Dans “Outils” → “Type de carte”, sélectionner “WeMos D1 (Retired)” si vous utilisez le LinkNode D1. Puis paramétrer le de la manière suivante :
  2. Sélectionnez le port COM sur lequel votre carte est connectée.
  3. Et enfin, cliquez sur Téléverser.

[Tuto] Commander une led via l’application Blynk

Dans ce tutoriel je vais vous introduire le fonctionnement de l’application Blynk. Ici, je vais vous montrer comment commander une led via son smartphone en toute simplicité.

Matériel nécessaire :
– 1 Arduino YUN
– 1 LED
– 1 Smartphone avec l’application Blynk

1. Mise en place de l’application

screenshot_20160919-145605

Tout d’abord, allez télécharger l’application Blynk sur le store de votre smartphone.

Démarrez l’application et créez-vous un compte :

screenshot_20160919-144235

Créez un nouveau projet:

screenshot_20160919-144409

Choisissez un nom de projet (ici: « Led Blinkin »), le modèle de microcontrôleur utilisé (ici: Arduino Yun) et envoyez-vous par e-mail le token généré, il sera utile pour la liaison entre l’arduino et votre smartphone.

screenshot_20160919-144440

Ici nous voulons interagir sur une Pin de l’arduino afin d’allumer ou non une LED. Il nous faut donc ajouter un bouton qui simulera l’état de sortie de la Pin en question. Pour cela, cliquez sur le petit « + » encerclé, cela vous donnera accès à une multitude de widgets. Nous choisirons dans notre cas le bouton du haut.

screenshot_20160919-144449
screenshot_20160919-144520

Le voilà maintenant placé ! Nous allons le configurer : cliquez dessus.

screenshot_20160919-144534

Donnez lui le nom que vous voulez (ici: Led Button) avec une couleur associée. Ensuite il nous faut choisir la pin sur laquelle l’application va interagir (ici: D13). Nous voulons que le bouton se comporte comme un switch et vous pouvez également personnaliser le message affiché en fonction de l’état du bouton (ici: Light ON/Light OFF).

screenshot_20160919-144635
screenshot_20160919-144645

Nous voilà prêt du côté smartphone. Allons maintenant du côté Arduino.

2. Mise en place du montage Arduino

Dans mon cas je vais utiliser un Arduino YUN connecté en WIFI. Nous allons également utiliser la pin 13 de l’arduino. Branchez la LED entre la pin 13 et le GND.

20160919_144739

Installez la librairie « Blynk » (lien de téléchargement) dans l’IDE Arduino (Tuto disponible ICI). Une fois fait, il va falloir programmé l’Arduino Yun avec le programme dédié trouvable dans les exemples de la librairie.

untitled-2

Dans le programme veillez bien à remplacer à la ligne 28, le « YourAuthToken » par celui que vous vous êtes envoyé par mail auparavant. Téléversez le programme dans l’Arduino et c’est parti !

3. Test

Allez dans votre application Blynk et démarrez votre projet « Led Blinkin » en appuyant sur le bouton start (représenté par une flèche) en haut à droite.

Un message s’affichera en bas, dans le cas ou votre Arduino n’est pas connecté à un réseau.

screenshot_20160919-144534

Si vous appuyer sur le bouton la LED s’allume, si vous appuyez à nouveau la LED s’éteint !

untitled-3

Maintenant c’est à vous. Laissez libre cours à votre imagination !

[Tuto] Hacker un detecteur de fumée et recevoir un mail en cas de début d’incendie

Beaucoup d’entre vous laisse imprimante 3D ou autre machine fonctionner dans vos logements pendant que vous êtes à l’extérieur. Même si c’est pour un court instant, nous ne sommes pas à l’abri d’accident c’est pourquoi dans cet article il va être question de rendre votre détecteur de fumée connecté. Connecté dans le sens où à la moindre détection de fumée votre appareil vous enverra un mail immédiatement.

Voici le matériel nécessaire:

  • Détecteur de fumée
  • Pile 9V
  • Photon
  • Relais 5V
  1. Démonter le detecteur de fumée et repérage

    Dans un premier temps démonter votre detecteur de fumée le plus proprement possible si vous voulez réutilisez votre boitier. Vous y trouverez trois parties, celle avec le coupleur de pile 9V, la partie électronique avec le composant qui détecte ou non la fumée et une partie avec un buzzer.

    img_20160913_174955
    img_20160913_175039
    img_20160913_175030

    Une fois que vous avez repéré la broche reliant la partie électronique avec le buzzer, prenez un voltmètre, mesuré la tension dans les deux cas suivant:

    * lorsque le detecteur de fumée ne détecte rien, normalement 0V (Led rouge clignote lentement)
    * lorsque vous enclenchez l’alarme manuellement (via le bouton de test) (Led rouge clignote rapidement)
    Noter cette valeur de tension, elle devrait se situer entre 5V et 9V. Pour pouvoir utiliser cette broche avec le photon vous allez devoir diviser cette tension pour qu’elle soit d’un maximum de 3V3. Pour cela il faudra faire un pont diviseur de tension à l’aide de deux résistances qu’on nommera R1 et R2.

  2. Montage sur breadboard

     

     

     

    detecteur

    Le rôle du relais ici est de permettre une vérification par deux fois en éteignant le detecteur de fumée puis en le rallumant pour attendre de nouveau le signal si il a bien lieu.

  3. Programmation du Particle Photon

    Configuré votre Photon avec le wifi du lieu où sera installé votre detecteur de fumée, téléverser le code suivant et vous pourrez le tester.

    #define ALIM_PIN A4            // pin de mesure d'alimentation du detecteur de fumee
    #define SEUIL_FUMEE_VALUE 1000 // seuil de mesure sur la pin analogique FUMEE_PIN
    #define RELAY_PIN D6           // pin pour allumage/extinction du relais pour l'alimentation du detecteur de fumee
    
    int fumee_value = 0;    // valeur mesuree sur la pin de detection de fumee
    int alim_value = 0;     // valeur mesuree sur la pin d'alimentation du detecteur de fumee
    
    byte compteur_detection_1 = 0; // Valeur incremente a chaque mesure de fumee_value supérieur au seuil de detection : premiere verification
    byte compteur_detection_2 = 0; // Valeur incremente a chaque "detection d'incendie", : deuxieme verification
    
    unsigned long m_second;
    unsigned long last_serial = 0; // Variable pour affichage sur le serial
    unsigned long last_mesure = 0; // Variable pour mesure periodique des PINs
    unsigned long last_count = 0;  // Variable pour remettre à zero le comptage des detection sur la PIN FUMEE_PIN, compteur_detection_1
    unsigned long last_detection = 0; // Variable pour remettre à zero le comptage des detection d'incendie, compteur_detection_2
    
    void setup() {
        Serial.begin(9600);
        pinMode(RELAY_PIN, OUTPUT);
        //pinMode(FUMEE_PIN, INPUT_PULLDOWN);
        pinMode(ALIM_PIN, INPUT_PULLDOWN);
        
        digitalWrite(RELAY_PIN, HIGH); // Extinction du detecteur de fumee
        delay(2000);
        digitalWrite(RELAY_PIN, LOW); // Allumage du detecteur de fumee
        delay(2000);
        digitalWrite(RELAY_PIN, HIGH); // Extinction du detecteur de fumee
        delay(2000);
        digitalWrite(RELAY_PIN, LOW); // Allumage du detecteur de fumee
        
        Particle.publish("Incendie", "Non");
    }
    
    void loop() {
        m_second = millis();
        
        //Lecture analogique des tensions provenant du detecteur de fumee toute les 500ms
        if(m_second - last_mesure >= 100){
            fumee_value = analogRead(FUMEE_PIN);
            //Serial.println(fumee_value);
            if(fumee_value > SEUIL_FUMEE_VALUE){
                if(compteur_detection_1 == 0){
                    last_count = m_second;
                }
                compteur_detection_1++;
            }
            last_mesure = m_second;
        }
        
        //Remise à zero du compteur de detection toute les 15secondes
        if(m_second - last_count >= 5000){
            
            compteur_detection_1 = 0;
            Serial.println("Remise a zero du compteur de detection 1");
            digitalWrite(RELAY_PIN, LOW); // Allumage ou laisser ON le detecteur de fumee
            last_count = m_second;
        }
        
        // Premiere verification de detection incendie
        if(compteur_detection_1 >= 10){
            Serial.println("detection incendie");
            digitalWrite(RELAY_PIN, HIGH); // Extinction du detecteur de fumee
            if(compteur_detection_2 == 0){
                last_detection = m_second;
            }
            compteur_detection_1 = 0;
            compteur_detection_2++;
            last_count = m_second;
        }
        
        //Remise à zero du compteur de detection d'incendie, compteur_detection_2
        if(m_second - last_detection >= 300000){
            if(compteur_detection_2 < 10){ Particle.publish("Incendie", "Non"); } compteur_detection_2 = 0; Serial.println("Remise a zero du compteur de detection 2"); last_count = m_second; } // Seconde verification de detection incendie if(compteur_detection_2 >= 2){
            Serial.println("Incendie validé!");
            Particle.publish("Incendie", "Oui");
            compteur_detection_2 = 0;
            last_count = m_second;
        }
    }
  4. Ajouter la fonctionnalité envoi de mail en cas de detection de fumée

    Pour configuré l’envoi de mail nous utiliserons la plateforme IFTT: inscrivez vous et recherchez particle photon, sélectionner un des « if then » qui apparaît avec GMAIL et compléter comme cela:

    detecteur_b

  5. Tester

Pour tester appuyer sur le bouton de test assez longtemps jusqu’à la réception du mail.

[Tuto] Régler le Wifi du Spark Core en usb

Régler le Wifi du Spark Core en usb

Le Spark Core (Particle désormais) est conçu pour fonctionner avec une application USB, malgré tout il arrive que l’on n’est pas la possibilité de fonctionner avec ce type de connexion. C’est pourquoi un mode USB existe, nous allons vous expliquer comment le mettre en oeuvre.

Raccorder le Spark au Wifi via USB

Pour commencer, vous pouvez lire la documentation Spark autour de ce sujet https://docs.particle.io/guide/getting-started/connect/core/

Pour Windows, la première étape consiste a installer Node.js en le téléchargeant ici https://nodejs.org/download

Brancher le Spark en « Listenning mode » (clignotement bleu). S’il n’y est pas au démarrage, appuyer sur mode durant 3s pour qu’il passe dans cet état.

Installer les drivers (Voici un très bon tuto expliquer https://community.particle.io/t/installing-the-usb-driver-on-windows-serial-debugging/882). En résumé, télécharger les pilotes Spark https://s3.amazonaws.com/spark-website/Spark.zip puis aller dans panneau de configuration / gestionnaire de périphériques / Clique droit sur « Spark Core » / « Mettre à jour le pilote » / « Rechercher un pilote sur mon ordinateur » / « Choisir parmi une liste de pilote sur mon ordinateur » / « Disque Fourni » / Rechercher l’emplacement ou vous avez mis les pilotes

Lancer ensuite le terminal de commande (Démarrer / Barre de recherche / taper « cmd »), saisisser « particle setup »

Loggez vous avec vos identifiants Spark.

Entrer ensuite les informations du Wifi sur lequel vous voulez vous raccorder.

Voila le Spark clignote Cyan il est connecté au Wifi

Arduino Yun datalogger

Nous allons aujourd’hui réaliser un montage nous permettant de remonter de manière simple la valeur d’un capteur qu’il soit analogique ou numérique avec un Arduino Yun. La lecture d’un capteur analogique avec un Arduino permet de transformer sa valeur lue entre 0 et 5V en un nombre de 0 à 1023.  Le capteur numérique quand à lui est à l’état 0 ou 1.

Notre montage va s’inspirer du tutorial http://arduino.cc/en/Tutorial/YunDatalogger

Le script adapter va scanner chaque entrée analogique puis chaque entrée numérique, puis les envoyer vers emoncms.

Pour commencer, inscrivez vous sur http://emoncms.org/

Voici le script que nous utilisons:

#include <FileIO.h>

#define attente 15000 // Temps entre 2 lectures en millisecondes

String debuturl = "http://emoncms.org/input/post.json?node="; // Debut url
String milieuurl = "&csv="; // Milieu url
String finurl = "&apikey=cdd97ca9046074128405636bb14fb479"; // Fin url

void setup() {
  // Initialisation des communications
  Bridge.begin();
  FileSystem.begin();
}


void loop () {
  // Lecture des capteurs analogiques
  for (int analogPin = 0; analogPin <= 5; analogPin++) {
    String url = debuturl; // Début de l'url
    url += String(analogPin); // Node
    url += milieuurl; // milieu d'url
    int sensor = analogRead(analogPin); // Lecture du capteur
    url += String(sensor); // Insertion dans l'url
    url += finurl; // Fin de l'url
    Process emoncms; // Process
    emoncms.begin("curl"); // Commande curl
    emoncms.addParameter(url); // Création de la requéte
    emoncms.run(); // Envoi de la requéte
  }
  
  delay(attente);// Attente entre 2 lectures
}

L’API key est à personnaliser avec celle que vous récupérer sur emoncms.

Une fois ceci prêt, téléverser le script sur le Arduino.

Maintenant, il faut connecter le Arduino Yun au Wifi. Voici le tutoriel officiel http://arduino.cc/en/Guide/ArduinoYun#toc13. En résumé:

  • Connectez vous à ArduinoYun-XXXXXXXXXXXX
  • Dans votre navigateur, allez dans http://arduino.local ou 192.168.240.1
  • Entrez le mot de passe (par défaut c’est arduino)
  • Cliquez sur Configure
  • Sélectionnez votre réseau Wifi puis entrez la clé WPA et validez
  • Au redémarrage le Arduino est sur le réseau

Les lectures de capteurs vont commencer automatiquement. Vous les verrez sur http://emoncms.org/input/view

Vous pouvez désormais personnaliser le nom des flux (node).

Capture de emoncms

Créer un serveur d’impression 3D avec Octopi

L’impression 3D est une technologie émergente. De nombreux services émergent avec elle. Nous avons chercher un service de gestionnaire d’impression à mettre en place avec notre Prusa i3. Nous avons trouvé Octopi un système fonctionnant sur Raspberry Pi et permettant de superviser les impressions au travers d’une interface Web.

  • 49,00 € Out of stock

    Nouvelle version de la carte majeure de Raspberry Pi ARMv8 64bit 1.4 Ghz, 1Go RAM , WiFI 802.11ac & Bluetooth 4.2 intégré, 4 Ports USB et GPIO 40 broches

    49,00 €
    Add to cart More
    Out of stock

Tuto installation serveur d’impression 3D octoPi sur RaspberryPi

Requirements

Etape 1 : formater sa carte SD

Tapez la commande sudo fdisk -l pour lister vos partitions

Chez moi cela affiche :

sudo fdisk -l

Disk /dev/sda: 1000.2 GB, 1000204886016 bytes

255 têtes, 63 secteurs/piste, 121601 cylindres, total 1953525168 secteurs

Unités = secteurs de 1 * 512 = 512 octets

Taille de secteur (logique / physique) : 512 octets / 4096 octets

taille d’E/S (minimale / optimale) : 4096 octets / 4096 octets

Identifiant de disque : 0x0070ab58

Périphérique Amorçage  Début         Fin      Blocs    Id. Système

/dev/sda1               1  1953525167   976762583+  ee  GPT

La partition 1 ne commence pas sur une frontière de cylindre physique.

Disque /dev/sdb : 7958 Mo, 7958691840 octets

245 têtes, 62 secteurs/piste, 1023 cylindres, total 15544320 secteurs

Unités = secteurs de 1 * 512 = 512 octets

Taille de secteur (logique / physique) : 512 octets / 512 octets

taille d’E/S (minimale / optimale) : 512 octets / 512 octets

Identifiant de disque : 0x000b5098

Périphérique Amorçage  Début         Fin      Blocs    Id. Système

/dev/sdb1            8192      122879       57344    c  W95 FAT32 (LBA)

/dev/sdb2          122880     5785599     2831360   83  Linux

Ma carte sd est sur /dev/sdb. Pour être sur, je vous conseil de faire un premier fdisk -l sans votre carte sd dans l’ordinateur, puis un second avec la carte, pour bien voir la différence.

Maintenant que vous connaissez l’emplacement de vorte carte sd nous allons la sélectionner :

sudo fdisk /dev/sdb

Vous êtes à présent dans l’utilitaire fdisk. Tapez p pour lister les partitions de votre périphérique :

Commande (m pour l’aide) : p

Disque /dev/sdb : 7958 Mo, 7958691840 octets

245 têtes, 62 secteurs/piste, 1023 cylindres, total 15544320 secteurs

Unités = secteurs de 1 * 512 = 512 octets

Taille de secteur (logique / physique) : 512 octets / 512 octets

taille d’E/S (minimale / optimale) : 512 octets / 512 octets

Identifiant de disque : 0x000b5098

Périphérique Amorçage  Début         Fin      Blocs    Id. Système

/dev/sdb1            2048    15544319     7771136    b  W95 FAT32

Cela vous donne un ensemble d’informations sur vos partitions, leur taille, leur systeme de fichiers, etc.

Pour supprimer la partition existante tapez : d , puis sélectionnez la partition : 1.

Si votre carte contient plusieurs partitions, supprimez les toutes en répétant l’opération.

Ensuite créez la nouvelle partition avec la suite de commande :

  • n
  • Indiquez le type de partition : p
  • Son numéro : 1
  • valeur par défaut : appuyez sur <entrer>
  • valeur par défaut : appuyez sur <entrer>

Le résultat chez moi :

Commande (m pour l’aide) : n

Partition type:

  p   primary (0 primary, 0 extended, 4 free)

  e   extended

Select (default p): p

Numéro de partition (1-4, 1 par défaut) : 1

Premier secteur (2048-15544319, 2048 par défaut) :

Utilisation de la valeur 2048 par défaut

Dernier secteur, +secteurs ou +taille{K,M,G} (2048-15544319, 15544319 par défaut) :

Utilisation de la valeur 15544319 par défaut

Vous pouvez relancer la commande : p , pour vérifier que votre partition a bien été créée.

Commande (m pour l’aide) : p

Disque /dev/sdb : 7958 Mo, 7958691840 octets

245 têtes, 62 secteurs/piste, 1023 cylindres, total 15544320 secteurs

Unités = secteurs de 1 * 512 = 512 octets

Taille de secteur (logique / physique) : 512 octets / 512 octets

taille d’E/S (minimale / optimale) : 512 octets / 512 octets

Identifiant de disque : 0x000b5098

Périphérique Amorçage  Début         Fin      Blocs    Id. Système

/dev/sdb1            2048    15544319     7771136   83  Linux

Il faut maintenant changer son filesysteme en FAT32 avec les commandes :

  • t
  • b

Résultat :

Commande (m pour l’aide) : t

Partition sélectionnée 1

Code Hexa (taper L pour lister les codes): b

Type système de partition modifié de 1 à b (W95 FAT32)

Pour terminer tapez la commande : w. C’est l’étape finale qui va écrire la nouvelle table de partition sur votre carte SD.

Résultat :

Commande (m pour l’aide) : w

La table de partitions a été altérée.

Attention : si vous avez créé ou modifié une partition DOS 6.x,

veuillez consulter les pages du manuel de fdisk pour des informations

complémentaires.

Synchronisation des disques.

Etape 2 : copier le .img sur la carte SD

Cela se traduit en une commande :

sudo dd if=~/2014-06-20-wheezy-octopi-0.9.0.img of=/dev/sdb

Mettez après le if= le chemin vers le .img présent sur votre ordinateur et après le of= le chemin vers votre carte SD.

ATTENTION, après le of=, ne pas indiquer le chemin vers la partition, mais bien vers le périphérique.

Pas d’inquiétude si la commande semble ne plus répondre, cela peut prendre de longues minutes pour copier l’ensemble de l’image (qui fait quand même 3Go) vers la carte SD.

Etape 3 : Configurer le raspberry

Une très bonne vidéo sur l’installation d’octoPi est visionnable ici : https://www.youtube.com/watch?v=EHzN_MwunmE

Démarrage de Raspbian :

Au premier démarrage, vous arriverez par défaut sur l’interface clavier de configuration du raspberry.

Sélectionnez “Expand filesystem” pour que le système puisse utiliser toute la mémoire disponible sur votre carte SD.

Puis sélectionnez “finish”.

Le raspberry va vous proposer de redémarrer, pour pouvoir prendre en compte les nouveaux paramètres que vous venez de configurer.

Pour modifier le layout du clavier en français, modifiez le fichier /etc/default/keyboard comme ceci :

# KEYBOARD CONFIGURATION FILE

# Consult the keyboard(5) manual page.

XKBMODEL= »pc105″

XKBLAYOUT= »fr »

XKBVARIANT= »latin9″

XKBOPTIONS= » »

BACKSPACE= »guess »

Si vous utilisez un rasperry relié au reseau par ethernet vous pouvez sauter la fin de l’étape.

Configuration de la wifi :

Le processus d’installation dépend du modèle de votre dongle wifi. La liste des dongles compatibles avec le raspberry est disponible ici :  http://elinux.org/RPi_USB_Wi-Fi_Adapters

Branchez votre dongle wifi au raspberry.

Pour connaître les détails de son dongle, qui permettront d’installer les drivers correspondant tapez la commande : lsusb. Chez moi, le résultat est :

Bus 001 Device 002: ID 1a40:0101 Terminus Technology Inc. 4-Port HUB

Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

Bus 001 Device 003: ID 1a40:0101 Terminus Technology Inc. 4-Port HUB

Bus 001 Device 004: ID 413c:2003 Dell Computer Corp. Keyboard

Bus 001 Device 005: ID 0bda:8179 Realtek Semiconductor Corp

Mon dongle wifi est le device 5, qui a pour id : 0bda:8179

Si c’est aussi votre cas, vous trouverez les drivers correspondant ainsi que les instructions pour l’installer à l‘adresse : http://www.fars-robotics.net/

Sinon, faites une recherche google du genre “[id de votre dongle usb] drivers raspberry” pour trouver les instructions appropriées.

Une fois les drivers installés, il faut configurer les paramètres de connexion au réseau dans le fichier /etc/network/interfaces.

Editez le fichier : sudo nano /etc/network/interfaces

Avec les paramètres suivants :

auto lo

iface lo inet loopback

iface eth0 inet dhcp

allow-hotplug wlan0

iface wlan0 inet manual

wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf

iface default inet dhcp

Puis éditez le fichier /etc/wpa_supplicant/wpa_supplicant.conf :

sudo nano /etc/wpa_supplicant/wpa_supplicant.conf

Avec les paramètres suivants :

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev

update_config=1

network={

   ssid= »le_nom_de_mon_reseau »

   proto=RSN

   key_mgmt=WPA-PSK

   pairwise=CCMP TKIP

   group=CCMP TKIP

   psk= »mon_mot_de_passe »

}

Votre réseau est maintenant configuré. Il devrait se connecter à chaque démarrage sur le réseau défini.

Si il ne se connecte pas automatiquement, forcez le démarrage de la wifi au boot en modifiant le fichier /etc/rc.local

sudo nano /etc/rc.local

ajouter la ligne suivante avant le exit0 :

sudo ifconfig wlan0 up

Il vous suffit maintenant d’ouvrir un navigateur et de visiter l‘url : octopi.local pour accéder à l’interface octoPi 🙂

  • 49,00 € Out of stock

    Nouvelle version de la carte majeure de Raspberry Pi ARMv8 64bit 1.4 Ghz, 1Go RAM , WiFI 802.11ac & Bluetooth 4.2 intégré, 4 Ports USB et GPIO 40 broches

    49,00 €
    Add to cart More
    Out of stock

[Tuto] Réaliser une liaison Wifi

Réaliser une liaison Wifi

Le but de ce montage est de communiquer entre l’ordinateur et le Arduino par la liaison Wifi. Cette liaison Wifi nécessite l’usage d’un shield (=carte d’extension) adapté.

Le kit Wifi se décompose en 4 composants :

  • Un module USB-TTL (Uniquement utilisé durant le paramétrage pour connecter le module Wifi à l’ordinateur au travers d’une liaison série)

  • Une nappe de connexion 4 points (Uniquement utilisé durant le paramétrage pour relier le module USB-TTL et le module Wifi)

  • Un shield de connexion (Assure la connexion entre le Arduino et le module Wifi)

  • Un module Wifi (comporte un convertisseur série ↔ Wifi)

Composants nécessaires :

  • Un Arduino

  • Un câble USB

  • Un kit Wifi

Il faut aussi charger l’ensemble de softwares et fichiers nécessaires.

 
Composants

La première étape consiste à paramétrer le module Wifi pour qu’il connaisse le nom du réseau ainsi que les informations nécessaires à la connexion au réseau Wifi. Pour cela, il faut connecter le module Wifi avec le module USB-TTL en utilisant la nappe de 4 fils prévu à cet effet.Paramétrage du module Wifi :

Avant de brancher à l’ordinateur, il faut vérifier plusieurs choses :

  • L’antenne est-elle bien connectée au module Wifi ?

Antenne
  • Le jumper (Plastique noir entre 2 bornes) du module USB-TTL est-il bien sur 3,3V (connexion entre la broche du centre et la 3,3V) ?

Jumper Alim
  • La nappe est-elle bien sur la rangée extérieur du module Wifi ?

Nappe module

Une fois tout ces points vérifiés, vous pouvez le connecter au PC.

Lancer le logiciel « UART-WIFI » compris dans le package.

Config wifi

Dans le logiciel, vérifiez que le « Port Connect » est sur le bon port COM. Cliquer ensuite sur « Search » et sélectionner votre module, s’il n’apparaît pas attendez et réessayer ou changer de port COM.

Allez ensuite dans votre interface de routeur Wifi (Freebox, Bbox ou autre) pour prendre les informations sur votre réseau Wifi. Pour y accéder bien souvent il faut taper 192 .168.1.1. Ou alors reprendre les informations inscrites sur l’autocollant présent sur votre box.

Dans la case SSID, entrez le nom de votre réseau (dans le cas d’une Bbox « Bbox-XXXXXX »), « Encry mode » entrez le type de sécurité utilisé (dans le cas d’une Bbox « WPA2-PSK(TKIP) »), ajoutez ensuite la clé réseau (=mot de passe) dans la case « Key », choisir « Static IP » et entrer les paramètres suivants :

  • Fied IP Addr : 192.168.1.119
  • Subnet Mask : 255.255.255.0
  • Gateway Addr : 192.168.1.1
  • DNS Addr : 192.168.1.1
Config wifi 2

Nous allons paramétrer le module en IP fixe pour simplifier notre montage. Pour cela, dans la section « Network setting » cliquer sur « NetType »

Cliquer ensuite sur « Modify ». Le module Wifi va redémarrer, il faudra ensuite se reconnecter dessus. Tout vos paramètres seront rechargés.

Ensuite testons la connexion en allant dans « Functionnal test » puis « connect ». Si la connexion est réussi, vous aurez un message du type :

Connect/create network.

Connect/create network complete.

NetMode Encry BSSID Channel SSID

Infra Yes XXXXXXXXXXXX 11 Bbox-XXXXXX

Le module réseau est connecté à votre réseau Wifi. Dans votre navigateur internet (Mozilla, Internet Explorer, Safari ou autre), tapez l’adresse IP saisie plus tôt (192.168.1.119) dans la barre d’adresse.

Le module Wifi est prêt à être utilisé.

Programmation du montage :

Nous allons programmer un serveur tout simple qui affiche un message sur une page Web.

void setup()// Fonction d'initialisation

{

Serial.begin(115200);// Création d'une liaison Wifi

}

void loop()// Fonction principale qui tourne en boucle

{

boolean currentLineIsBlank = true;// Variable pour savoir si l'on retourne à la ligne

while(1){

if(Serial.available()){

char c = Serial.read();// Lecture des données reçues et enregistrement dans une variable

if(c =='n'&& currentLineIsBlank){//Si l'on reçoit une demande extérieur

// Envoyer une page Web

Serial.println("HTTP/1.1 200 OKrnContent-Type: text/htmlrnrn<center><h1>Hello World!! I am WiFi WebServer!!!</h1></center>");

break;

}

if(c =='n'){

// Démarrer une nouvelle ligne

currentLineIsBlank = true;

}

elseif(c !='r'){

// On nous demande autre chose

currentLineIsBlank = false;

}

}

}

}

Il reste à brancher le Arduino pour compiler le programme et le téléverser.

Il faut ensuite assembler l’ensemble.

Réalisation du montage :

Nous allons connecter le shield sur la carte Arduino puis y connecter le module Wifi, comme ceci :

Montage 1
Montage 2
Montage 3
Montage 4

On branche ensuite l’ensemble au PC pour avoir l’alimentation par USB. Le module Wifi va se connecter au réseau. Il faut maintenant l’interroger au travers d’un navigateur internet. Pour cela il faut connaître son adresse IP (l’interface de votre Box ou routeur Wifi vous le permet). Par exemple sur la Bbox, vous pouvez le voir sur la page « Schéma de mon réseau ».

Schema Reseau

Une fois terminé cela nous donne :

ON

Physiquement

Hello world

Dans le navigateur

Pour aller plus loin : Je vous invite à regarder dans le manuel du module Wifi pour y trouver de nouvelles idées de montages, les possibilités sont très grande.

parametrage forcé

Remarque : En cas de mauvaise manipulation, il peut être compliqué de ré-accéder au menu de paramétrage du module Wifi. Il existe un moyen de forcer le module en mode configuration, pour cela il faut relier la broche 2 du module au Vcc(3,3V) comme ceci.