Attribut:Step Content

This is a property of type Text.

Utilisation2944

C

Code Minimal Réseau - (1) Connecter le Wemos D1 mini à internet en wifi +

<nowiki>Cette première étape permet à un Wemos D1 mini (ou autre carte compatible Arduino avec puce Wi-Fi) de se connecter au Wi-Fi dans un environnement connu, et qui ne change pas ; C'est-à-dire que l'on à accès à une borne Wi-Fi, on connait son mot de passe - aka "clé de sécurité réseau", et a priori la carte va rester dans cet environnement. Ces bibliothèques sont pré-chargées dans l'environnement Arduino, il n'est pas nécessaire d'aller les chercher dans le gestionnaire de bibliothèques. <table class="wikitable" cellspacing="0" border="0"> <tr> <td height="17" bgcolor="#999999" align="left"> </td><td valign="middle" bgcolor="#999999" align="center"> </td><td bgcolor="#999999" align="center">Connexion Wi-Fi de base </td></tr><tr> <td rowspan="2" valign="middle" height="49" bgcolor="#999999" align="center">Avant le Setup </td><td valign="middle" bgcolor="#999999" align="center">Importation de la bibliothèque </td><td valign="middle" align="left">#include <ESP8266WiFi.h> // Pour le Wemos D1 Mini, ou ... #include <WiFi.h> // ... Pour l'ESP32 </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Création de l’objet </td><td valign="middle" align="left"> </td></tr><tr> <td rowspan="3" valign="middle" height="17" bgcolor="#999999" align="center">Dans le Setup </td><td valign="middle" bgcolor="#999999" align="center">Démarrage de la connexion </td><td valign="middle" align="left">WiFi.begin(SSID, SecKey) ; // Où SSID est le nom du point d'accès Wi-Fi, et SecKey son mot de passe </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Test de la connexion </td><td valign="middle" align="left">if (WiFi.Status() == WL_CONNECTED) { (...) } </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Récupération de l'adresse IP </td><td>WiFi.localIP() ; </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Dans le Loop </td><td valign="middle" bgcolor="#999999" align="center">Utilisation </td><td>Le test de la connexion, et la récupération de l'adresse IP peuvent aussi être utilisés dans le loop(). </td></tr></table> Pour connaître toutes les autres possibilités de ces bibliothèques, voir leurs références, respectivement [https://github.com/esp8266/Arduino/tree/master/libraries/ESP8266WiFi ici] (D1 Mini) et [https://github.com/espressif/arduino-esp32/tree/master/libraries/WiFi ici] (ESP32). <div class="mw-highlight mw-content-ltr" dir="ltr"><pre> 1 /* ========================================================================================================= 2 * 3 * CODE MINIMAL RESEAU - ETAPE 1 : connexion basique au Wi-Fi 4 * 5 * --------------------------------------------------------------------------------------------------------- 6 * Les petits Débrouillards - décembre 2022 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/ 7 * ========================================================================================================= */ 8 9 // Bibliothèques WiFi : UNE SEULE EST NECESSAIRE, choisir celle correspondant à votre matériel. 10 // ATTENTION AUX MAJUSCULES & MINUSCULES ! Sinon d'autres bibliothèques, plus ou moins valides, seraient utilisées. 11 12 #include <ESP8266WiFi.h> // A utiliser pour le D1 Mini 13 //#include <WiFi.h> // A utiliser pour l'ESP32 14 15 // Définition du point d'accès Wi-Fi et de son mot de passe ("clé de sécurité") 16 // A REMPLACER PAR LES VERITABLES VALEURS CORRESPONDANT A VOTRE EMPLACEMENT 17 18 const char* mySSID = "MA_BOX_INTERNET"; 19 const char* mySecKey = "MA_CLE_DE_SECURITE"; 20 21 /* -------------------------------------------------------------------------------------------------------- 22 * SETUP : Initialisation 23 * -------------------------------------------------------------------------------------------------------- */ 24 void setup() { 25 26 // Initialisation de la liaison série, affichage 1er message 27 28 Serial.begin(115200); 29 delay(100) ; 30 Serial.println(); 31 Serial.println("----------------------------------") ; 32 Serial.println("Exemple de connexion Wi-Fi basique") ; 33 Serial.println("----------------------------------") ; 34 35 // Démarrage de la tentative de connexion, avec le nom du point d'accès Wi-Fi et son mot de passe 36 37 WiFi.begin(mySSID, mySecKey) ; 38 39 // Attente de la connexion pendant 10 secondes (20 x 500 ms) 40 41 Serial.print("Connexion à "); Serial.print(mySSID) ; Serial.print(" ") ; 42 int tryNumber = 1 ; 43 while (WiFi.status() != WL_CONNECTED) 44 { 45 delay(500); 46 Serial.print("."); 47 if (++tryNumber > 20) { 48 Serial.println() ; Serial.println("Pas de connexion, abandon") ; 49 return ; 50 } 51 } 52 53 // La connexion a réussi ! On affiche l'adresse IP obtenue. 54 55 Serial.println(); Serial.print("Connecté ! Adresse IP : "); 56 Serial.println(WiFi.localIP()); 57 58 } 59 60 /* -------------------------------------------------------------------------------------------------------------- 61 * LOOP : fonction appelée régulièrement par le système 62 * ------------------------------------------------------------------------------------------------------------- */ 63 void loop() { 64 /* On ne fait rien de particulier sur cet exemple */ 65 } </pre></div></nowiki> , <nowiki>Dans l'étape précédente on supposait que le Wi-Fi était permanent (cas où les cartes ne quittent pas notre labo, par exemple). Mais si on souhaite faire voyager nos cartes (démos dans des écoles, etc ...), on a trois possibilités : *On vient avec son environnement de développement Arduino, on met à jour le code Arduino avec les nouvelles informations Wi-Fi, et on téléverse le code sur toutes nos cartes ... un peu laborieux, n'est-il pas ? *ou bien, on dispose en permanence d'un téléphone mobile avec forfait données (4G ou +), et on utilise systématiquement celui-ci en mode "Point d'accès mobile". C'est donc ce téléphone qui sera vu en permanence comme le point d'accès Wi-Fi préféré de votre carte (D1 mini ou ESP32), quelque soit l'endroit où vous vous trouvez. Pas toujours possible ... *et sinon, on utilise la bibliothèque "WiFiManager", qui nous simplifie grandement la tâche ! En effet, cette bibliothèque permet d'enregistrer de façon pérenne (même si on débranche la carte) le dernier Point d'Accès Wi-Fi sur lequel la carte a réussi à se connecter. La bibliothèque va d'abord chercher à se connecter sur ce Point d'Accès "connu". Et si ça ne fonctionne pas (on a changé de lieu, par exemple), alors elle va se positionner elle-même en mode "Point d'Accès", et va proposer sur l'adresse 192.168.4.1 une interface web permettant d'afficher les Points d'Accès Wi-Fi environnants, et d'en sélectionner un. Le nouveau Point d'Accès choisi sera sauvegardé pour les fois suivantes. Interface web du WiFi Manager : #Avec un téléphone ou ordinateur, connectez-vous au point d'accès "AP_PetitDeb" et tapez le mot de passe associé. Il y aura probablement un message indiquant qu'Internet n'est pas disponible, c'est normal, ne pas en tenir compte ; #Sur votre navigateur préféré, tapez "192.168.4.1", ce qui fera apparaître l'interface web générée par la bibliothèque WiFiManager. Cliquez sur "Configure WiFi", vous arrivez sur le choix du point d'accès. #Choisissez alors votre point d'accès Wi-Fi préféré, son nom sera reporté dans la case "SSID", complétez avec le mot de passe dans la case "Password", et cliquez sur Save <div class="annotatedImageDiv" typeof="Image" data-resource="Fichier:Code minimal des fonctions r seau WiKi WiFiManager S.png" data-sourceimage="https://www.wikidebrouillard.org/images/f/f8/Code_minimal_des_fonctions_r_seau_WiKi_WiFiManager_S.png"><div class="center"><div class="floatnone"><a href="/wiki/Fichier:Code_minimal_des_fonctions_r_seau_WiKi_WiFiManager_S.png" class="image" title="Utilisation du WiFiManager"><img alt="Image permettant de comprendre l'utilisation de la bibliothèque WiFiManager" src="/images/thumb/f/f8/Code_minimal_des_fonctions_r_seau_WiKi_WiFiManager_S.png/800px-Code_minimal_des_fonctions_r_seau_WiKi_WiFiManager_S.png" width="800" height="574" data-file-width="1200" data-file-height="861" /></a></div></div></div> '''Bibliothèque''' La bibliothèque doit être rajoutée à l'environnement Arduino dans le gestionnaire de Bibliothèques (voir [https://www.wikidebrouillard.org/wiki/Importer_des_biblioth%C3%A8ques_dans_l%27interface_Arduino ici] pour le mode d'emploi) : <div class="annotatedImageDiv" typeof="Image" data-resource="Fichier:Code minimal des fonctions reseau Image.png" data-sourceimage="https://www.wikidebrouillard.org/images/5/53/Code_minimal_des_fonctions_reseau_Image.png"><div class="floatleft"><a href="/wiki/Fichier:Code_minimal_des_fonctions_reseau_Image.png" class="image" title="Bibliothèque WiFiManager"><img alt="Image de la Bibliothèque WiFiManager dans le Gestionnaire de Bibliothèques Arduino" src="/images/5/53/Code_minimal_des_fonctions_reseau_Image.png" width="756" height="110" data-file-width="756" data-file-height="110" /></a></div></div> <table class="wikitable" cellspacing="0" border="0"> <tr> <td height="17" bgcolor="#999999" align="left"> </td><td valign="middle" bgcolor="#999999" align="center"> </td><td bgcolor="#999999" align="center">Bibliothèque Wifi Manager </td></tr><tr> <td rowspan="2" valign="middle" height="49" bgcolor="#999999" align="center">Avant le Setup </td><td valign="middle" bgcolor="#999999" align="center">Importation de la bibliothèque </td><td valign="middle" align="left">#include <WiFiManager.h> </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Création de l’objet </td><td valign="middle" align="left">WiFiManager myWiFiManager; </td></tr><tr> <td rowspan="3" valign="middle" height="17" bgcolor="#999999" align="center">Dans le Setup </td><td valign="middle" bgcolor="#999999" align="center">Déclaration du mode bloquant </td><td valign="middle" align="left">myWiFiManager.setConfigPortalBlocking(true); // ... ou rien (mode par défaut) </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Déclaration du mode non bloquant </td><td>myWiFiManager.setConfigPortalBlocking(false); </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Tentative de connexion à un PA Wi-Fi </td><td>if (myWiFiManager.autoConnect(Nom_AP, MotDePasse_AP)) { (... connexion OK !) } </td></tr><tr> <td valign="middle" height="41" bgcolor="#999999" align="center">Dans le Loop </td><td valign="middle" bgcolor="#999999" align="center">Activation régulière pour le mode non bloquant </td><td valign="middle" align="left">myWiFiManager.process() ; // Obligatoire en mode non bloquant </td></tr></table> Pour connaître toutes les autres possibilités de cette bibliothèque, voir sa référence, [https://jp112sdl.github.io/WiFiManager/ ici]. '''Code minimal : mode bloquant (par défaut)''' <div class="mw-highlight mw-content-ltr" dir="ltr"><pre> 1 /* ========================================================================================================= 2 * 3 * CODE MINIMAL RESEAU - ETAPE 2 : Connexion à un point d'accès choisi par l'utilisateur 4 * 5 * CAS A : MODE BLOQUANT - On attend tant que l'utilisateur n'a pas choisi son Point d'Accès Wi-Fi 6 * 7 * --------------------------------------------------------------------------------------------------------- 8 * Les petits Débrouillards - décembre 2022 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/ 9 * ========================================================================================================= */ 10 11 // Bibliothèque WiFiManager. Un seule bibibliothèque suffit ici, quelque soit la carte (ESP32 ou Wemos D1 Mini) 12 13 #include <WiFiManager.h> // Gestion de la connexion Wi-Fi (recherche de points d'accès) 14 WiFiManager myWiFiManager; // Création de mon instance de WiFiManager. 15 16 // Définition de la carte lorsqu'elle se positionne en mode "Point d'Accès". 17 18 const char* mySSID = "AP_PetitDeb" ; // Nom du point d'accès 19 const char* mySecKey = "PSWD1234" ; // Mot de passe, 8 caractères au minimum 20 21 /* -------------------------------------------------------------------------------------------------------- 22 * SETUP : Initialisation 23 * -------------------------------------------------------------------------------------------------------- */ 24 void setup() { 25 26 // Initialisation de la liaison série, affichage 1er message 27 28 Serial.begin(115200); 29 delay(100) ; 30 Serial.println(); 31 Serial.println("----------------------------------") ; 32 Serial.println("Exemple de connexion Wi-Fi évoluée") ; 33 Serial.println("----------------------------------") ; 34 35 // Tentative de connexion au Wi-Fi. Si la carte n'a pas réussi se connecter au dernier Point d'Accès connu, 36 // alors elle va se positionner en mode Point d'Accès, demandera sur l'adresse 192.168.4.1 quel nouveau 37 // Point d'Accès choisir. Par défaut, on restera bloqué tant que l'utilisateur n'aura pas fait de choix. 38 39 Serial.println("Connexion au Wi-Fi ..."); 40 if (myWiFiManager.autoConnect(mySSID, mySecKey)) { 41 42 // Wi-Fi en mode standard ok --> On affiche l'adresse IP obtenue. 43 44 Serial.println(); Serial.print("Connecté ! Adresse IP : "); 45 Serial.println(WiFi.localIP()); 46 47 } 48 else { 49 Serial.println("Connexion Wi-Fi KO :-("); 50 } 51 52 } 53 54 /* -------------------------------------------------------------------------------------------------------------- 55 * LOOP : fonction appelée régulièrement par le système 56 * ------------------------------------------------------------------------------------------------------------- */ 57 void loop() { 58 /* On ne fait rien de particulier sur cet exemple */ 59 } </pre></div> '''Code minimal : mode non bloquant''' <div class="mw-highlight mw-content-ltr" dir="ltr"><pre> 1 /* ========================================================================================================= 2 * 3 * CODE MINIMAL RESEAU - ETAPE 2 : Connexion à un point d'accès choisi par l'utilisateur 4 * 5 * CAS B : MODE NON BLOQUANT - On peut faire autre chose en attendant que l'utilisateur ait choisi 6 * son Point d'Accès Wi-Fi 7 * 8 * --------------------------------------------------------------------------------------------------------- 9 * Les petits Débrouillards - décembre 2022 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/ 10 * ========================================================================================================= */ 11 12 // Bibliothèque WiFiManager. Un seule bibibliothèque suffit ici, quelque soit la carte (ESP32 ou Wemos D1 Mini) 13 14 #include <WiFiManager.h> // Gestion de la connexion Wi-Fi (recherche de points d'accès) 15 WiFiManager myWiFiManager; // Création de mon instance de WiFiManager. 16 17 // Définition de la carte lorsqu'elle se positionne en mode "Point d'Accès". 18 19 const char* mySSID = "AP_PetitDeb" ; // Nom du point d'accès 20 const char* mySecKey = "PSWD1234" ; // Mot de passe, 8 caractères au minimum 21 22 // Pour les besoins de l'exemple (traces) 23 24 bool IAmNotConnected = true ; 25 26 /* -------------------------------------------------------------------------------------------------------- 27 * SETUP : Initialisation 28 * -------------------------------------------------------------------------------------------------------- */ 29 void setup() { 30 31 // Initialisation de la liaison série, affichage 1er message 32 33 Serial.begin(115200); 34 delay(100) ; 35 Serial.println(); 36 Serial.println("----------------------------------") ; 37 Serial.println("Exemple de connexion Wi-Fi évoluée") ; 38 Serial.println("----------------------------------") ; 39 40 // Déclaration du mode "non bloquant". 41 // Bonus : suppression des traces fournies par le WiFiManager (il est très bavard) 42 43 myWiFiManager.setConfigPortalBlocking(false); 44 myWiFiManager.setDebugOutput(false); 45 46 // Tentative de connexion au Wi-Fi. Si la carte n'a pas réussi se connecter au dernier Point d'Accès connu, 47 // alors elle va se positionner en mode Point d'Accès, demandera sur l'adresse 192.168.4.1 quel nouveau 48 // Point d'Accès choisir. On ne reste pas bloqué, la suite du setup() va se dérouler, et le WiFiManager 49 // traitera les demandes ultérieurement, dans la fonction loop(). 50 51 Serial.println("Connexion au Wi-Fi ..."); 52 if (myWiFiManager.autoConnect(mySSID, mySecKey)) { 53 54 // Wi-Fi en mode standard ok --> On affiche l'adresse IP obtenue. 55 56 Serial.println(); Serial.print("Connecté ! Adresse IP : "); 57 Serial.println(WiFi.localIP()); 58 59 } 60 else { 61 62 // Wi-Fi standard KO, on est passé en mode AP, qui sera traité dans le loop(). 63 64 Serial.println("Pas de point Wi-Fi connu, passage en mode AP (identifiant \"" + String(mySSID) + "\")"); 65 } 66 67 } 68 69 /* -------------------------------------------------------------------------------------------------------------- 70 * LOOP : fonction appelée régulièrement par le système 71 * ------------------------------------------------------------------------------------------------------------- */ 72 void loop() { 73 74 // Obligatoire en mode non bloquant, pour que le WiFiManager continue sa tâche. 75 76 myWiFiManager.process() ; 77 78 // Test pour savoir si on est enfin connecté - on ne l'affiche qu'une fois pour limiter les traces 79 80 if (IAmNotConnected) { 81 if (WiFi.status() == WL_CONNECTED) { 82 Serial.print("Connecté au point d'accès " + String(WiFi.SSID()) + ", Adresse IP : ") ; 83 Serial.println(WiFi.localIP()); 84 IAmNotConnected = false ; 85 } 86 } 87 88 } </pre></div> </nowiki> , <nowiki>Il existe des cas particuliers où une application n'a en fait pas besoin du Wi-Fi pour aller envoyer ou recevoir des données d'Internet, mais souhaite être juste être considérée comme un Point d'Accès Wi-Fi. Ce mode est suffisant si l'on souhaite commander notre carte depuis un système proche. Par exemple pour commander un système domotique en mode web depuis notre mobile ... petit "spoiler" de l'épisode 2 :-) Pour utiliser le mode "Point d'Accès", on garde les librairies de base, vues à l'étape 1, en utilisant d'autres fonctions. <table class="wikitable" cellspacing="0" border="0"> <tr> <td height="17" bgcolor="#999999" align="left"> </td><td valign="middle" bgcolor="#999999" align="center"> </td><td bgcolor="#999999" align="center">Mode Point d'Accès </td></tr><tr> <td rowspan="2" valign="middle" height="49" bgcolor="#999999" align="center">Avant le Setup </td><td valign="middle" bgcolor="#999999" align="center">Importation de la bibliothèque </td><td valign="middle" align="left">#include <ESP8266WiFi.h> // Pour le Wemos D1 Mini, ou ... #include <WiFi.h> // ... Pour l'ESP32 </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Création de l’objet </td><td valign="middle" align="left"> </td></tr><tr> <td rowspan="3" valign="middle" height="17" bgcolor="#999999" align="center">Dans le Setup </td><td valign="middle" bgcolor="#999999" align="center">Lancement du mode AP avec mot de passe </td><td valign="middle" align="left">if (WiFi.softAP(SSID, SecKey)) { (... succès ... } ; // Où SSID est le nom du point d'accès Wi-Fi, et SecKey son mot de passe </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Lancement du mode AP sans mot de passe </td><td valign="middle" align="left">if (WiFi.softAP(SSID)) { (... succès ... } ; // Où SSID est le nom du point d'accès Wi-Fi </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Récupération de l'adresse IP de base </td><td>WiFi.softAPIP() ; </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Dans le Loop </td><td valign="middle" bgcolor="#999999" align="center">Utilisation </td><td>La récupération de l'adresse IP peut aussi être utilisée dans le loop(). </td></tr></table> Pour connaître toutes les autres possibilités de ces bibliothèques, voir leurs références, respectivement [https://github.com/esp8266/Arduino/tree/master/libraries/ESP8266WiFi ici] (D1 Mini) et [https://github.com/espressif/arduino-esp32/tree/master/libraries/WiFi ici] (ESP32). <div class="mw-highlight mw-content-ltr" dir="ltr"><pre> 1 /* ========================================================================================================= 2 * 3 * CODE MINIMAL RESEAU - ETAPE 3 : Configuration en mode Point d'Accès 4 * 5 * --------------------------------------------------------------------------------------------------------- 6 * Les petits Débrouillards - décembre 2022 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/ 7 * ========================================================================================================= */ 8 9 // Bibliothèques WiFi : UNE SEULE EST NECESSAIRE, choisir celle correspondant à votre matériel. 10 // ATTENTION AUX MAJUSCULES & MINUSCULES ! Sinon d'autres bibliothèques, plus ou moins valides, seraient utilisées. 11 12 #include <ESP8266WiFi.h> // A utiliser pour le D1 Mini 13 //#include <WiFi.h> // A utiliser pour l'ESP32 14 15 const char* mySSID = "AP_PetitDeb" ; 16 const char* mySecKey = "PSWD1234" ; 17 18 /* -------------------------------------------------------------------------------------------------------- 19 * SETUP : Initialisation 20 * -------------------------------------------------------------------------------------------------------- */ 21 void setup() { 22 23 // Initialisation de la liaison série, affichage 1er message 24 25 Serial.begin(115200); 26 delay(100) ; 27 Serial.println(); 28 Serial.println("-----------------------------") ; 29 Serial.println("Exemple en mode Point d'Accès") ; 30 Serial.println("-----------------------------") ; 31 32 // Déclaration du mode "Point d'Accès" 33 34 Serial.println("Déclaration Mode AP, SSID \"" + String(mySSID) + "\"") ; 35 36 if (WiFi.softAP(mySSID,mySecKey)) { 37 38 // Voilà, nous somme en mode "Point d'Accès", notre carte sera visible des systèmes Wi-Fi environnants, 39 // au même titre que les autres box Wi-Fi du voisinage. Par contre, ça s'arrête là, et si une fois 40 // connecté sur ce Point d'Accès "AP_PetitDeb" on cherche à joindre notre carte sur l'adresse IP obtenue 41 // ci-dessous par WiFi.softAPIP(), on aura droit à un beau "ERR_CONNECTION_REFUSED". Normal, on n'a pas 42 // précisé dans l'application ce qu'il faut faire : voir exemple suivant Code_Minimal_Etape4. 43 44 Serial.print("Mode AP OK, IP Address : ") ; 45 Serial.println(WiFi.softAPIP()) ; 46 } 47 else { 48 Serial.println("Mode AP KO ... :-(") ; 49 } 50 51 } 52 53 /* -------------------------------------------------------------------------------------------------------------- 54 * LOOP : fonction appelée régulièrement par le système 55 * ------------------------------------------------------------------------------------------------------------- */ 56 void loop() { 57 58 // Rien de spécial dans cet exemple 59 60 } </pre></div></nowiki> , …

Code Minimal Réseau - (2) Héberger un site web sur mon Wemos D1 mini +

<nowiki>Une première possibilité d'utilisation du Wi-Fi sur nos cartes, est d'y définir un mini-serveur web , qui nous permettra d'afficher voire de modifier, depuis n'importe quel navigateur, des données gérées par la carte - et par conséquent de récupérer la valeur de capteurs (température, ...) ou gérer des actionneurs (moteurs, leds, ...). On peut trouver quelques exemples d'applications de ce type, réalisée par des Petits Débrouillards, en particulier le [https://github.com/julienrat/petitbot Petit Bot], petit robot commandable, ou encore [https://www.wikidebrouillard.org/wiki/Commander_un_D1_mini_avec_une_interface_web Commander un D1 mini avec une interface web], permettant d'animer des leds, de gérer un moteur, et de récupérer des données du D1 mini sur une interface web. <table class="wikitable" cellspacing="0" border="0"> <tr> <td height="17" bgcolor="#999999" align="left"> </td><td valign="middle" bgcolor="#999999" align="center"> </td><td bgcolor="#999999" align="center">Site web </td></tr><tr> <td rowspan="2" valign="middle" height="49" bgcolor="#999999" align="center">Avant le Setup </td><td valign="middle" bgcolor="#999999" align="center">Importation de la bibliothèque </td><td valign="middle" align="left">#include <ESP8266WebServer.h> // Pour le D1 Mini, ou ... #include <WebServer.h> // ... pour l'ESP32 </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Création du serveur web (sur le port 80) </td><td valign="middle" align="left">ESP8266WebServer myWeb(80); // Pour le D1 Mini , ou ... // WebServer myWeb(80) ; // ... pour l'ESP32 </td></tr><tr> <td rowspan="2" valign="middle" height="17" bgcolor="#999999" align="center">Dans le Setup </td><td valign="middle" bgcolor="#999999" align="center">Déclaration de la fonction qui s'occupera de la génération de la page web </td><td valign="middle" align="left">myWeb.on ( "/", runPage01 ); </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Démarrage du serveur web </td><td>myWeb.begin(); </td></tr><tr> <td valign="middle" height="41" bgcolor="#999999" align="center">Dans le Loop </td><td valign="middle" bgcolor="#999999" align="center">Traitement des requêtes web </td><td valign="middle" align="left">myWeb.handleClient(); </td></tr></table> '''Code Minimal 4a : affichage d'un paramètre de la carte.''' La page web hébergée sur notre carte doit être codée en HTML. La page peut être assez évoluée, intégrer du code javascript, être formatée en mode CSS, etc ... Dans l'exemple "minimal" ci-dessous, on se contente d'une page HTML basique. ''Une fois le code téléversé sur votre carte, pour voir le résultat, connectez-vous (avec un ordinateur ou un mobile) sur le point d'accès "AP_PetitDeb" (mot de passe "PSWD1234"), puis lancez votre navigateur préféré et tapez 192.168.4.1.'' <div class="annotatedImageDiv" typeof="Image" data-resource="Fichier:Code minimal des fonctions reseau Ecran-Etape-4.png" data-sourceimage="https://www.wikidebrouillard.org/images/9/98/Code_minimal_des_fonctions_reseau_Ecran-Etape-4.png"><div class="center"><div class="floatnone"><a href="/wiki/Fichier:Code_minimal_des_fonctions_reseau_Ecran-Etape-4.png" class="image" title="Ecran-Etape-4A"><img alt="Ecran-Etape-4A" src="/images/9/98/Code_minimal_des_fonctions_reseau_Ecran-Etape-4.png" width="785" height="336" data-file-width="785" data-file-height="336" /></a></div></div></div> <div class="mw-highlight mw-content-ltr" dir="ltr"><pre> 1 /* ========================================================================================================= 2 * 3 * CODE MINIMAL RESEAU - ETAPE 4 : site WEB 4 * 5 * CAS A : Page HTML Basique, consultation d'une variable de la carte 6 * 7 * --------------------------------------------------------------------------------------------------------- 8 * Les petits Débrouillards - décembre 2022 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/ 9 * ========================================================================================================= */ 10 11 // Bibliothèques WiFi et WebServer: ATTENTION, choisir celles correspondant à votre matériel. 12 // ATTENTION AUX MAJUSCULES & MINUSCULES ! Sinon d'autres bibliothèques, plus ou moins valides, seraient utilisées. 13 14 #include <ESP8266WiFi.h> // A utiliser pour le D1 Mini 15 #include <ESP8266WebServer.h> // A utiliser pour le D1 Mini 16 //#include <WiFi.h> // A utiliser pour l'ESP32 17 //#include <WebServer.h> // A utiliser pour l'ESP32 18 19 const char* mySSID = "AP_PetitDeb" ; // On va utiliser le mode "Access Point" pour cet exemple 20 const char* mySecKey = "PSWD1234" ; 21 22 // Déclaration de notre serveur web interne. 23 24 ESP8266WebServer myWeb(80); // A utiliser pour le D1 Mini 25 // WebServer myWeb(80) ; // A utiliser pour l'ESP32 26 27 /* -------------------------------------------------------------------------------------------------------- 28 * webPage01 : formattage HTML de la page web. 29 * - En fait cette fonction doit rendre une chaîne (String) contenant l'intégralité du code HTML qui sera 30 * envoyé au navigateur de l'utilisateur. 31 * - On peut y insérer des informations de la carte, comme ici par exemple, le nom du Point d'accès (mySSID). 32 * Dans une véritable application, ça pourrait être la valeur d'un capteur de température. 33 * - Pour pouvoir débugger facilement le code HTML/Javascript sur un browser (par exemple Firefox / Outils 34 * supplémentaires / Outils de développement Web), il est préférable d'indenter le code à l'intérieur de la chaîne 35 * de caractère, et de mettre des sauts de ligne ("\n") à la fin de chaque ligne de code HTML. 36 * -------------------------------------------------------------------------------------------------------- */ 37 String webPage01() { 38 39 String p; 40 p = "<html lang=fr-FR><head><title>ETAPE 4 (Mini-Web)</title></head>\n" ; 41 p += "<body>\n" ; 42 p += " <center>\"12\">\n" ; 43 p += " Bonjour, je suis " + String(mySSID) + "...\n" ; // C'est ici qu'on place l'information SSID. 44 p += " ... très heureux de te rencontrer !\n" ; 45 p += " </center>\n" ; 46 p += "</body></html>\n" ; 47 return p; 48 49 } 50 51 /* -------------------------------------------------------------------------------------------------------- 52 * runPage01 : gestion de la page web 53 * -------------------------------------------------------------------------------------------------------- */ 54 void runPage01() { 55 56 // Affichage de la page Web. 57 myWeb.send ( 200, "text/html", webPage01() ); 58 } 59 60 /* -------------------------------------------------------------------------------------------------------- 61 * SETUP : Initialisation 62 * -------------------------------------------------------------------------------------------------------- */ 63 void setup() { 64 65 // Initialisation de la liaison série, affichage 1er message 66 67 Serial.begin(115200); 68 delay(100) ; 69 Serial.println(); 70 Serial.println("----------------------") ; 71 Serial.println("Exemple de serveur WEB") ; 72 Serial.println("----------------------") ; 73 74 // Déclaration du mode "Point d'Accès". On s'arrête là si échec. 75 76 Serial.println("Déclaration Mode AP, SSID \"" + String(mySSID) + "\"") ; 77 if (!WiFi.softAP(mySSID,mySecKey)) { 78 Serial.println("Mode AP KO ... :-(") ; 79 return ; 80 } 81 82 // Affichage de l'adresse IP principale du Point d'Accès. 83 84 Serial.print("Mode AP OK, IP Address : ") ; 85 Serial.println(WiFi.softAPIP()) ; 86 87 // Définition des points d'entrée du serveur Web (un seul ici), et démarrage du serveur. 88 89 myWeb.on ( "/", runPage01 ); 90 myWeb.begin(); 91 92 } 93 94 /* -------------------------------------------------------------------------------------------------------------- 95 * LOOP : fonction appelée régulièrement par le système 96 * ------------------------------------------------------------------------------------------------------------- */ 97 void loop() { 98 99 // Traitement des requêtes web. 100 myWeb.handleClient(); 101 102 } </pre></div> </nowiki> , <nowiki> '''Code Minimal 4b : actionner la carte via l'interface web''' Dans l'exemple précédent, on se contente de récupérer un paramètre de la carte. Mais il est également possible de modifier un paramètre (par exemple l'état d'une des sorties de la carte, et donc d'agir sur un de ses périphériques : led, moteur, ...). Le code ci-dessous présente donc un code "moins minimal", permettant d'afficher et de modifier une variable du programme Arduino. Dans une application réelle, il suffira alors d'utiliser cette variable pour afficher et agir sur sur l'état d'une des entrées/sorties de la carte. La partie HTML est un peu plus complexe, car on va y définir une fonction javascript, qui permettra de faire passer des informations du navigateur au serveur web hébergé. Voir les explications complémentaires dans le code lui-même. <div class="annotatedImageDiv" typeof="Image" data-resource="Fichier:Code minimal des fonctions reseau Ecran-Etape4B.png" data-sourceimage="https://www.wikidebrouillard.org/images/2/27/Code_minimal_des_fonctions_reseau_Ecran-Etape4B.png"><div class="center"><div class="floatnone"><a href="/wiki/Fichier:Code_minimal_des_fonctions_reseau_Ecran-Etape4B.png" class="image" title="Ecran-Etape4B"><img alt="Ecran-Etape4B" src="/images/2/27/Code_minimal_des_fonctions_reseau_Ecran-Etape4B.png" width="790" height="336" data-file-width="790" data-file-height="336" /></a></div></div></div> <div class="mw-highlight mw-content-ltr" dir="ltr"><pre> 1 /* ========================================================================================================= 2 * 3 * CODE MINIMAL RESEAU - ETAPE 4 : site WEB 4 * 5 * CAS B : Page HTML plus évoluéee, et modification d'une variable de la carte 6 * 7 * --------------------------------------------------------------------------------------------------------- 8 * Les petits Débrouillards - décembre 2022 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/ 9 * ========================================================================================================= */ 10 11 // Bibliothèques WiFi et WebServer: ATTENTION, choisir celles correspondant à votre matériel. 12 // ATTENTION AUX MAJUSCULES & MINUSCULES ! Sinon d'autres bibliothèques, plus ou moins valides, seraient utilisées. 13 14 #include <ESP8266WiFi.h> // A utiliser pour le D1 Mini 15 #include <ESP8266WebServer.h> // A utiliser pour le D1 Mini 16 //#include <WiFi.h> // A utiliser pour l'ESP32 17 //#include <WebServer.h> // A utiliser pour l'ESP32 18 19 const char* mySSID = "AP_PetitDeb" ; // On va utiliser le mode "Access Point" pour cet exemple 20 const char* mySecKey = "PSWD1234" ; 21 22 // Déclaration de notre serveur web interne, qui écoutera sur le port 80. 23 24 ESP8266WebServer myWeb(80); // A utiliser pour le D1 Mini 25 // WebServer myWeb(80) ; // A utiliser pour l'ESP32 26 27 // Variable qui sera affichée et modifiée depuis notre interface web. 28 29 int myValue = 0 ; 30 31 /* -------------------------------------------------------------------------------------------------------- 32 * webPage01 : formattage HTML de la page web. 33 * - En fait cette fonction doit rendre une chaîne (String) contenant l'intégralité du code HTML qui sera 34 * envoyé au navigateur de l'utilisateur. 35 * - Comme dans l'exemple précédent (Exemple_4A), on insère dans cette chaîne une information de la carte, 36 * ici la valeur de notre variable 'my value'. Mais on va aussi ajouter des boutons permettant de modifier 37 * cette valeur sur la carte. 38 * - Idem Exemple_4A : pour pouvoir débugger facilement le code HTML/Javascript sur un browser (par exemple 39 * Firefox / Outils supplémentaires / Outils de développement Web), il est préférable d'indenter le code à 40 * l'intérieur de la chaîne de caractère, et de mettre des sauts de ligne ("\n") à la fin de chaque ligne 41 * de code HTML. 42 * -------------------------------------------------------------------------------------------------------- */ 43 String webPage01() { 44 45 String p; 46 47 // Début de construction de la page web (entête, titre, paramètres) 48 49 p = "<html lang=fr-FR><head>\n" ; 50 p += "<title>ETAPE 4B</title>\n" ; // Titre de la page 51 p += " <meta charset='UTF-8'>\n" ; // Codage des caractères, UTF-8 est fortement recommandé 52 p += "</head>\n" ; 53 54 // Définitions CSS (), qui permettent de décrire le format des objets sur la page web. 55 // Si vous voulez tout savoir sur CSS, on peut trouver une bonne introduction ici : https://developer.mozilla.org/fr/docs/Learn/CSS 56 // et une référence complète ici : https://developer.mozilla.org/fr/docs/Web/CSS/Reference 57 58 p += "<style>\n" ; 59 p += " body { background-color: #000088; color: white; font-size: 25px; }\n"; // couleur fond écran (bleu foncé) et textes (blanc). 60 p += " input { width:25%; margin:10px; font-size:20px; border-radius: 5px; }\n"; // format des boutons (taille, coins arrondis, ...). 61 p += "</style>\n" ; 62 63 // Début du code javascript. Javascript est le langage utilisé au niveau des navigateurs web (Firefox, Microsoft Edge, Google Chrome, ...) 64 // pour introduire un peu de dynamisme et d'intelligence dans les pages web. Cela peut permettre, par exemple, de réaliser une action 65 // locale et immediate, telle que l'agrandissement d'une image, le changement d'un texte, etc ... sans avoir à réinterroger le serveur web. 66 // 67 // Dans notre cas, la fonction 'addition(val)' ci-dessous va ajouter le paramètres 'val' à l'adresse du serveur web, et va ensuite appeler 68 // la page web de notre carte, avec ce paramètre. Par exemple, si l'adresse du site web de notre carte est 192.168.4.1, l'appel à la fonction 69 // addition(-1) va demander la page '192.168.4.1?add=-1'. Le paramètre 'add' de valeur '-1' sera alors exploité par la carte dans la 70 // fonction runPage01() définie plus bas. 71 // 72 // Dans un exemple réel on pourrait bien sûr définir plusieurs paramètres, du style '192.168.4.1?voyant=vert&servo1=90&servo2=0' 73 74 p += "<script>\n" ; 75 p += "function addition(val) {\n"; 76 p += " window.location = window.location.pathname + '?add=' + val ;\n"; 77 p += "}\n"; 78 p += "</script>\n" ; 79 80 // Corps de la page web : affichage de la valeur récupérée sur la carte, et de deux boutons 'ajouter 1' et 'enlever 1'. 81 // La fonction addition() définie dans le code javascript ci-dessus, sera appelée lorsqu'on appuie sur ces boutons. 82 83 p += "<body><center>\n" ; 84 p += " Valeur actuelle : " + String(myValue) + "\n"; 85 p += " <form>\n"; 86 p += " <input type='submit' value='ajouter 1' formaction='javascript:addition(1);' formmethod=post>\n" ; 87 p += " <input type='submit' value='enlever 1' formaction='javascript:addition(-1);' formmethod=post>\n" ; 88 p += " </form>\n"; 89 p += "</center></body></html>" ; 90 91 // ça y est, la page web est complètement constituée ! 92 93 return p; 94 95 } 96 97 /* -------------------------------------------------------------------------------------------------------- 98 * runPage01 : gestion de la page web 99 * -------------------------------------------------------------------------------------------------------- */ 100 void runPage01() { 101 102 // Si la page a un paramètre 'add', alors on récupère sa valeur, et on l'ajoute à notre variable 'myValue'. 103 104 if ( myWeb.hasArg("add") ) { 105 Serial.println("Traitement pge web, arg = '" + String(myWeb.arg("add")) + "'") ; 106 int myArg = myWeb.arg("add").toInt() ; 107 myValue = myValue + myArg ; 108 Serial.println("Traitement page web, arg = '" + String(myWeb.arg("add")) + "' --> Nouvelle valeur : " + String(myValue)) ; 109 } 110 111 // On renvoie la page Web. 112 myWeb.send ( 200, "text/html", webPage01() ); 113 } 114 115 /* -------------------------------------------------------------------------------------------------------- 116 * SETUP : Initialisation 117 * -------------------------------------------------------------------------------------------------------- */ 118 void setup() { 119 120 // Initialisation de la liaison série, affichage 1er message 121 122 Serial.begin(115200); 123 delay(100) ; 124 Serial.println(); 125 Serial.println("----------------------") ; 126 Serial.println("Exemple de serveur WEB") ; 127 Serial.println("----------------------") ; 128 129 // Déclaration du mode "Point d'Accès". On s'arrête là si échec. 130 131 Serial.println("Déclaration Mode AP, SSID \"" + String(mySSID) + "\"") ; 132 if (!WiFi.softAP(mySSID,mySecKey)) { 133 Serial.println("Mode AP KO ... :-(") ; 134 return ; 135 } 136 137 // Affichage de l'adresse IP principale du Point d'Accès. 138 139 Serial.print("Mode AP OK, IP Address : ") ; 140 Serial.println(WiFi.softAPIP()) ; 141 142 // Définition des points d'entrée du serveur Web (un seul ici), 143 // et démarrage du serveur. 144 145 myWeb.on ( "/", runPage01 ); 146 myWeb.begin(); 147 148 } 149 150 /* -------------------------------------------------------------------------------------------------------------- 151 * LOOP : fonction appelée régulièrement par le système 152 * ------------------------------------------------------------------------------------------------------------- */ 153 void loop() { 154 155 // Traitement des requêtes web. 156 myWeb.handleClient(); 157 158 } </pre></div></nowiki> , *'''Episode 3 :''' [https://www.wikidebrouillard.org/wiki/Code_Minimal_R%C3%A9seau_-_(3)_Mon_D1_Mini_r%C3%A9cup%C3%A8re_des_donn%C3%A9es_sur_Internet_(Json) Mon Wemos D1 mini récupère des donnée sur Internet (Json)]. *'''Episode 4 :''' [https://www.wikidebrouillard.org/wiki/Code_Minimal_R%C3%A9seau_-_(4)_Mes_Wemos_D1_Mini_discutent_sur_Internet_avec_MQTT Mon Wemos D1 mini discute sur Internet avec MQTT]. ''Ces épisodes sont indépendants les uns des autres''. +

Code Minimal Réseau - (3) Mon D1 Mini récupère des données sur Internet (Json) +

*'''Episode 4 :''' [https://www.wikidebrouillard.org/wiki/Code_Minimal_R%C3%A9seau_-_(4)_Mes_Wemos_D1_Mini_discutent_sur_Internet_avec_MQTT Mon Wemos D1 mini discute sur Internet avec MQTT.] +, <nowiki>Nous allons maintenant nous intéresser à la récupération de données sur Internet (informations sur la météo, sur la pollution, sur les derniers recensements, ...). De nombreux serveurs de données, et en particulier les serveurs "Open Data" (offrant des données libres de droit), sont accessibles en mode web. C'est-à-dire qu'une simple requête dans la barre d'adresse de votre navigateur, permet de récupérer les informations souhaitées. Et, encore mieux, dans la plupart des cas, la réponse revient sous une forme standardisée de type '''JSON''' (JavaScript Objet Notation), que les navigateurs récents sont capables de décoder. A titre d'exemple, ouvrez un nouvel onglet dans votre navigateur, et recopiez dans la barre d'adresse ce qui suit ... https://data.rennesmetropole.fr/api/records/1.0/search/?dataset=etat-du-trafic-en-temps-reel&q=rocade ... et vous devriez avoir en retour un texte de ce type : {"nhits": 63, "parameters": {"dataset": "etat-du-trafic-en-temps-reel", "q": "rocade", "rows": 10, "start": 0, "format": "json", "timezone": "UTC"}, "records": [{"datasetid": "etat-du-trafic-en-temps-reel", "recordid": "c8cd4fc9d2a9f1840170322c834f827fc100cc75", "fields": {"traveltimereliability": 100, "traveltime": 55, "predefinedlocationreference": "30023", "averagevehiclespeed": 91, "datetime": "2022-11-29T15:11:00+01:00", "gml_id": "v_rva_troncon_fcd.fid-722fb9f8_184c264cda5_453f", "trafficstatus": "freeFlow", "func_class": 666, "geo_point_2d": [48.14130932076887, -1.6781068587055177], '''(...)''' ... mais que votre navigateur va quasi-immédiatement immédiatement reconnaître comme un format JSON, et afficher sous une forme plus structurée : <div class="annotatedImageDiv" typeof="Image" data-resource="Fichier:Code minimal des fonctions reseau Code JSON.png" data-sourceimage="https://www.wikidebrouillard.org/images/d/d7/Code_minimal_des_fonctions_reseau_Code_JSON.png"><div class="center"><div class="floatnone"><a href="/wiki/Fichier:Code_minimal_des_fonctions_reseau_Code_JSON.png" class="image" title="Exemple de réponse JSON"><img alt="Exemple de réponse JSON" src="/images/d/d7/Code_minimal_des_fonctions_reseau_Code_JSON.png" width="564" height="472" data-file-width="564" data-file-height="472" /></a></div></div></div> Nous avons fait ici appel au serveur Open Data de la ville de Rennes, et avons fait une requête demandant l'état du trafic sur la rocade principale. Ce même serveur propose un tas d'autres données libres, et on peut trouver sur Internet une multitude d'autres serveurs "Open Data" en mode JSON.</nowiki> , <nowiki>... bon, ok, mais mon D1 mini n'a pas de navigateur ? C'est là où deux bibliothèques vont nous être utiles : *la première pour permettre à notre carte se connecter au serveur de données en mode sécurisé (car la plupart des sites web ont une adresse ''''https'''://www...') : '''WiFiClientSecure'''. Celle-ci est intégrée de base dans l'environnement de développement Arduino. *la seconde pour décoder le format JSON et extraire facilement les éléments de réponse qui nous intéressent : '''ArduinoJson'''. Celle-ci doit être récupérée dans le gestionnaire de bibliothèques : <div class="annotatedImageDiv" typeof="Image" data-resource="Fichier:Code minimal des fonctions reseau Biblio ArduinoJSON.png" data-sourceimage="https://www.wikidebrouillard.org/images/9/92/Code_minimal_des_fonctions_reseau_Biblio_ArduinoJSON.png"><div class="center"><div class="floatnone"><a href="/wiki/Fichier:Code_minimal_des_fonctions_reseau_Biblio_ArduinoJSON.png" class="image" title="Bibliothèque ArduinoJSON"><img alt="Bibliothèque ArduinoJSON" src="/images/9/92/Code_minimal_des_fonctions_reseau_Biblio_ArduinoJSON.png" width="752" height="107" data-file-width="752" data-file-height="107" /></a></div></div></div> Les possibilités sont multiples, et l'exploitation des données JSON par les cartes D1 mini ou ESP32, peut prendre des formes très sympathiques : voir par exemple les réalisations "[https://www.wiki.lesfabriquesduponant.net/index.php?title=POCL_:_VOIR_DEMAIN Voir Demain]" et "[https://www.wiki.lesfabriquesduponant.net/index.php?title=POCL_:_Hawaiiiii Hawaiiiii]" issues d'un hackathon organisé en décembre 2021 par Les Petits Débrouillards Grand Ouest et L'Edulab de l'Université de Rennes 2. <div class="annotatedImageDiv" typeof="Image" data-resource="Fichier:Code minimal des fonctions reseau Copie tableau mode img cause bug si tableau wiki.png" data-sourceimage="https://www.wikidebrouillard.org/images/9/94/Code_minimal_des_fonctions_reseau_Copie_tableau_mode_img_cause_bug_si_tableau_wiki.png"><a href="/wiki/Fichier:Code_minimal_des_fonctions_reseau_Copie_tableau_mode_img_cause_bug_si_tableau_wiki.png" class="image" title="Fonctions JSON"><img alt="Fonctions JSON" src="/images/thumb/9/94/Code_minimal_des_fonctions_reseau_Copie_tableau_mode_img_cause_bug_si_tableau_wiki.png/800px-Code_minimal_des_fonctions_reseau_Copie_tableau_mode_img_cause_bug_si_tableau_wiki.png" width="800" height="191" data-file-width="1293" data-file-height="309" /></a></div> Pour connaître toutes les autres possibilités de cette bibliothèque, voir sa référence, [https://github.com/256dpi/arduino-mqtt ici]. '''Code minimal :''' Bon, en fait, pas tout à fait "minimal" : *pour des raisons de clarté, nous avons défini deux fonctions : '''serverRequest''' pour générer la requête auprès du serveur et récupérer la réponse, et '''showJSONAnswer''' pour analyser la réponse (décodage des informations JSON). *pour faciliter la réutilisation de ce code, plutôt que de tout traiter dans le setup(), nous activerons ces fonctions régulièrement, depuis la boucle loop(), ce qui est le mode de fonctionnement habituel. <div class="mw-highlight mw-content-ltr" dir="ltr"><pre> 1 /* ========================================================================================================= 2 * 3 * CODE MINIMAL RESEAU - ETAPE 5 : Données JSON 4 * 5 * --------------------------------------------------------------------------------------------------------- 6 * Les petits Débrouillards - décembre 2022 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/ 7 * ========================================================================================================= */ 8 9 // Bibliothèques requises 10 // ATTENTION AUX MAJUSCULES & MINUSCULES ! Sinon d'autres bibliothèques, plus ou moins valides, seraient utilisées. 11 12 #include <WiFiManager.h> // Gestion de la connexion Wi-Fi (recherche de points d'accès) 13 #include <WiFiClientSecure.h> // Gestion de la connexion (HTTP) à un serveur de données 14 #include <ArduinoJson.h> // Fonctions de décodage JSON des réponses du serveur. 15 16 17 18 // Variables globales 19 20 WiFiManager myWiFiManager; // Création de mon instance de WiFiManager. 21 WiFiClientSecure myWiFiClient; // Création de mon instance de client WiFi. 22 const char* mySSID = "AP_PetitDeb" ; // Nom de la carte en mode Point d'Accès. 23 const char* mySecKey = "PSWD1234" ; // Mot de passe associé, 8 caractères au minimum. 24 25 char* Data_HOST = "data.rennesmetropole.fr"; // Serveur web hébergeant les données qui nous intéressent 26 int Data_PORT = 443; // Port sur lequel envoyer la requête 27 char* Data_REQUEST = // Requête (sur cet exemple : demande de l'état du trafic au point 28 // 31553, correspondant à la porte de Saint-Malo de la rocade de Rennes 29 "/api/records/1.0/search/?dataset=etat-du-trafic-en-temps-reel&q=31553"; 30 31 32 const int MAX_RESPONSE_SIZE = 6000 ; // Taille max de la réponse attendue d'un serveur. A modifier en fonction du besoin. 33 char Data_Response[MAX_RESPONSE_SIZE] ; // Buffer qui contiendra la réponse du serveur. 34 35 #define TEN_SECONDS 10000 // On appelera le serveur de données toutes les 10000 ms = 10 secondes. 36 unsigned long myWakeUp ; // Timer mis en place pour limiter le nombre d'appels au serveur de données. 37 38 /* -------------------------------------------------------------------------------------------------------------- 39 * serverRequest() : Envoi requête HTTP au serveur et récupération de la réponse 40 * paramètres : 41 * - pHost : nom du serveur ; 42 * - pPort : port sur lequel est appelé le serveur ; 43 * - pRequest : requête au serveur. 44 * - pResponse : endroit où stocker la réponse 45 * - pRespMax : nombre max de caractères autorisés pour la réponse 46 * valeur de retour : 47 * -2 = réponse tronquée (trop de caractères) ; 48 * -1 = pas de réponse ; 49 * 0 = pas de connexion au serveur ; 50 * 1 = ok. 51 * ------------------------------------------------------------------------------------------------------------- */ 52 int serverRequest(char* pHost, int pPort, char* pRequest, char *pResponse, int pRespMax) { 53 54 const int API_TIMEOUT = 15000; // Pour être sûr de recevoir l'en-tête de la réponse client. 55 56 // Comme la connexion est sécurisée (protocole HTTPS), il faudrait indiquer le certificat du site web. 57 // Pour simplifier, on va utiliser l'option magique ".setInsecure()", ce qui n'est pas important dans 58 // notre exemple, où les données échangées ne sont pas confidentielles. 59 60 myWiFiClient.setInsecure(); 61 myWiFiClient.setTimeout(API_TIMEOUT); 62 63 // Connexion au serveur (on essaie 5 fois, avec un intervalle d'une seconde) 64 65 Serial.print("--- Connexion au serveur [" + String(pHost) + "] "); 66 int nbTries = 1; 67 while(!myWiFiClient.connect(pHost, pPort)) { 68 Serial.print("."); 69 if (++nbTries > 5) { 70 Serial.println("--- Connexion impossible :-("); 71 myWiFiClient.stop(); 72 return(0); 73 } 74 delay(1000); 75 } 76 77 // Connecté à notre serveur ! --> Envoi de la requête URL. Il faut envoyer en fait une suite de lignes : 78 // "GET <notre requête> HTTP/1.1" 79 // "Host: <nom du serveur>" 80 // "Connection: close" 81 // <ligne vide> 82 // Cet envoi se fait simplement grâce à la fonction println du client WiFi, similaire à celle que 83 // l'on utilise pour envoyer des données au moniteur série pour nos traces. 84 85 String myURL = String(pRequest); 86 Serial.println() ; 87 Serial.println("--- Connexion OK ! --> Envoi requête URL - " + myURL); 88 myWiFiClient.println("GET " + myURL + " HTTP/1.1") ; 89 myWiFiClient.println("Host: " + String(pHost)) ; 90 myWiFiClient.println("Connection: close") ; 91 myWiFiClient.println() ; 92 93 // Attente de la réponse ....(on essaie 50 fois, avec un intervalle de 100ms, donc 5 secondes en tout) 94 95 nbTries = 1; 96 while(!myWiFiClient.available()){ 97 if (++nbTries > 50) { 98 Serial.println("--- Pas de réponse :-("); 99 myWiFiClient.stop(); 100 return(-1); 101 } 102 delay(100); 103 } 104 105 // Récupération de l'en-tête de la réponse (dont on ne fera rien) 106 // Cette entête est une suite de caractères, composant un certain nombre de lignes (ie se terminant par '\n'), 107 // la dernière ligne de l'entête n'est composée que du caractère "\r" (suivie du '\n') ; 108 109 Serial.println("--- Réponse OK --> Récupération de l'en-tête ..."); 110 String myLine ; 111 while (myWiFiClient.available()) { 112 myLine = myWiFiClient.readStringUntil('\n'); 113 if (myLine == "\r") { 114 break; 115 } 116 } 117 118 // Entête reçue ! On va alors recopier dans pResponse tous les caractères qui suivent 119 // en faisant attention à ne pas dépasser la taille du buffer. 120 121 Serial.println("--- Entête ok --> Récupération des données ..."); 122 int myIndex = 0 ; 123 while (myWiFiClient.available()) { 124 125 char myResp = myWiFiClient.read(); 126 /* Debug supprimé ... Serial.println(myResp) ; */ 127 pResponse[myIndex] = myResp; 128 if (myIndex++ >= pRespMax) { 129 Serial.println("*** Réponse trop longue : " + String(pRespMax) + "caractères, et ne peut pas être traitée") ; 130 myWiFiClient.stop(); 131 return(-2); 132 } 133 pResponse[myIndex] = '\0'; // Vu sur forums : conseillé d'ajouté 'fin de chaîne' systématiquement 134 delay(1) ; // Et également d'ajouter ce tout petit délai pour éviter des plantages. 135 136 } 137 138 // Tout s'est bien passé ! On arrête notre client WiFi 139 140 Serial.println("--- Récupération des données ok (" + String(myIndex) + " caractères).") ; 141 myWiFiClient.stop(); 142 return(1) ; 143 144 } 145 146 /* -------------------------------------------------------------------------------------------------------- 147 * showJSONAnswer : Décodage de la structure de données JSON 148 * Paramètres : 149 * - pResponse : endroit se trouve la réponse (au format JSON) du serveur 150 * - pRespMax : nombre max de caractères autorisés pour la réponse 151 * -------------------------------------------------------------------------------------------------------- */ 152 void showJSONAnswer(char *pResponse, int pRespMax) { 153 154 // Création de notre structure JSON 155 // Le besoin en mémoire (capacity) doit être vérifié sur l'assistant https://arduinojson.org/v6/assistant/ 156 // 1) dans la première page de l'assistant, sélectionnez le processeur (par exemple "ESP8266"), le mode 157 // "Deserialize", et le type d'entrée "char*", puis cliquez sur le bouton "Netx:JSON" 158 // 2) Lancez votre requête depuis un navigateur. Dans notre exemple, tapez dans la barre d'adresse : 159 // "https://data.rennesmetropole.fr/api/records/1.0/search/?dataset=etat-du-trafic-en-temps-reel&q=31553" 160 // 3) Recopiez la réponse obtenue - sous sa forme "Données Brutes" du navigateur vers l'assistant 161 // 4) L'assistant va alors préconiser le bon objet à créer (StaticJsonDocument ou DynamicJsonDocument), 162 // ainsi que la taille à réserver. L'assistant va même proposer un exemple de programme exploitant toutes 163 // les informations de la structure JSON. 164 // Pour notre exemple, l'assistant a proposé la définition qui suit. 165 166 StaticJsonDocument<1024> doc; 167 168 // Décodage de la réponse JSON. 169 // La fonction deserializeJson va transformer la réponse "texte" du serveur, en une structure de données recopiée 170 // dans la variable 'doc', où il sera ensuite facile d'aller chercher les informations souhaitées. 171 172 DeserializationError error = deserializeJson(doc, pResponse, pRespMax); 173 if (error) { 174 Serial.println("--- Décodage réponse JSON KO, code " + String(error.f_str())) ; 175 return; 176 } 177 Serial.println("--- Décodage réponse JSON OK !") ; 178 179 // Nous pouvons maintenant extraire facilement les informations qui nous intéressent, 180 // en n'oubliant pas le niveau de profondeur de la donnée au sein de la structure JSON. 181 // Ce niveau de profondeur est incrémenté par le nombre de '{' ou '[' rencontrés, et 182 // décrémenté lors de la rencontre des ']' et {}'. Sur notre exemple 'rocade de Rennes', 183 // cela donne ceci : 184 // +-----------------------------------------------------------------+ 185 // | { | ... Entrée niveau 1 186 // | "nhits": 1, | 187 // | "parameters": { | ... Entrée niveau 2 188 // | "dataset": "etat-du-trafic-en-temps-reel", | 189 // | (...) | 190 // | }, | ... Retour niveau 1 191 // | "records": [ | ... Début d'un tableau : niveau 2 192 // | { | ... Entrée niveau 3 193 // | (...) | | 194 // | "fields": { | ... Entrée niveau 4 195 // | (...) | 196 // | "averagevehiclespeed": 88, | 197 // | (...) | 198 // | "datetime": "2022-11-30T11:57:00+01:00", | 199 // +-----------------------------------------------------------------+ 200 // ... et donc : 201 // - (1er niveau) --------- doc["nhits"] donnera la valeur 1, 202 // - (2ème niveau) -------- doc["parameters"]["dataset"] donnera la valeur "etat-du-trafic-en-temps-reel" 203 // - (4ème niveau) -------- doc["records"][0]["fields"]["averagevehiclespeed"] donnera la valeur 87 204 205 // Extraction et affichage sur le port série de trois valeurs 206 207 String myLocRef = String(doc["records"][0]["fields"]["predefinedlocationreference"]) ; 208 String myTime = String(doc["records"][0]["fields"]["datetime"]) ; 209 int mySpeed = doc["records"][0]["fields"]["averagevehiclespeed"] ; 210 211 Serial.print("Vitesse au point " + myLocRef + " ") ; 212 Serial.print("le " + myTime.substring(8,10) + "/" + myTime.substring(5,7) + "/" + myTime.substring(0,4) + " ") ; 213 Serial.print("à " + myTime.substring(11,13) + "h" + myTime.substring(14,16) + " ") ; 214 Serial.println(" : " + String(mySpeed) + " km/h.") ; 215 216 } 217 218 /* -------------------------------------------------------------------------------------------------------- 219 * SETUP : Initialisation 220 * -------------------------------------------------------------------------------------------------------- */ 221 void setup() { 222 223 // Initialisation de la liaison série, affichage 1er message 224 225 Serial.begin(115200); 226 delay(100) ; 227 Serial.println(); 228 Serial.println("-----------------------") ; 229 Serial.println("Exemple extraction JSON") ; 230 Serial.println("-----------------------") ; 231 232 // Tentative de connexion au Wi-Fi. Si la carte n'a pas réussi se connecter au dernier Point d'Accès connu, 233 // alors elle va se positionner en mode Point d'Accès, demandera sur l'adresse 192.168.4.1 quel nouveau 234 // Point d'Accès choisir. Par défaut, on restera bloqué tant que l'utilisateur n'aura pas fait de choix. 235 236 Serial.println("Connexion au Wi-Fi ..."); 237 if (myWiFiManager.autoConnect(mySSID, mySecKey)) { 238 Serial.println(); Serial.print("Connecté ! Adresse IP : "); 239 Serial.println(WiFi.localIP()); 240 } 241 else { 242 Serial.println("Connexion Wi-Fi KO :-("); 243 } 244 245 // Initialisation du timer qui sera testé dans loop() - pour faire appel au serveur seulement toutes les 10 secondes 246 // millis() est une fonction système donnant le nombre de ms depuis le lancement ou la réinitialisation de la carte. 247 248 unsigned long myWakeUp = millis() + TEN_SECONDS ; 249 250 } 251 252 /* -------------------------------------------------------------------------------------------------------------- 253 * LOOP : fonction appelée régulièrement par le système 254 * ------------------------------------------------------------------------------------------------------------- */ 255 void loop() { 256 257 unsigned long myNow = millis() ; 258 if (myNow >= myWakeUp) { 259 Serial.println("Wake Up ! Nouvelle demande au serveur ...") ; 260 if (serverRequest(Data_HOST, Data_PORT, Data_REQUEST, Data_Response, MAX_RESPONSE_SIZE) == 1) { 261 Serial.println("Réponse reçue du serveur, lancement analyse JSON ...") ; 262 showJSONAnswer(Data_Response, MAX_RESPONSE_SIZE) ; 263 } 264 myWakeUp = myNow + TEN_SECONDS ; 265 } 266 267 } </pre></div> </nowiki>

Code Minimal Réseau - (4) Mes Wemos D1 Mini discutent sur Internet avec MQTT +

MQTT (Message Queuing Telemetry Transport) permet l'envoi et la réception de messages de petite taille. MQTT s'appuie sur un "broker MQTT", serveur externe, qui va recevoir les données d'un système, et les redistribuer à d'autres systèmes. MQTT est souvent utilisé pour collecter des données en provenance de petits capteurs (par exemple, capteurs de température dans un système domotique, capteurs de pollution au niveau d'une région voire d'un pays), car il a aussi comme avantage d'être peu consommateur de ressources. MQTT est basé sur un principe d'abonnement : le système émetteur doit préciser à quel sujet ("topic") se rattache son message, et tous les systèmes qui s'étaient préalablement abonnés à ce "topic" recevront alors le message. Principe proche de Twitter ou Instagram et leurs "hashtags", donc. On peut implémenter son propre broker MQTT (le code est libre d'usage), ou s'appuyer sur des brokers gérés par des associations ou des entreprises. Dans l'exemple ci-après, on utilise le broker des Petits Débrouillards, à utiliser avec modération. Mais ce n'est pas l'objet du tutoriel, nous nous intéressons ici uniquement à la partie "client", c'est à dire ce qu'il faut mettre en œuvre sur nos cartes D1 mini ou ESP. +, <nowiki>Il existe plusieurs bibliothèques Arduino permettent de gérer des messages MQTT. Pour notre part, on utilise celle-ci (à aller chercher dans le gestionnaire de bibliothèque) : <div class="annotatedImageDiv" typeof="Image" data-resource="Fichier:Code minimal des fonctions reseau Biblio MQTT.png" data-sourceimage="https://www.wikidebrouillard.org/images/d/d7/Code_minimal_des_fonctions_reseau_Biblio_MQTT.png"><a href="/wiki/Fichier:Code_minimal_des_fonctions_reseau_Biblio_MQTT.png" class="image" title="Bibliothèque MQTT"><img alt="Bibliothèque MQTT" src="/images/d/d7/Code_minimal_des_fonctions_reseau_Biblio_MQTT.png" width="945" height="118" data-file-width="945" data-file-height="118" /></a></div> <table class="wikitable" cellspacing="0" border="0"> <tr> <td height="17" bgcolor="#999999" align="left"> </td><td valign="middle" bgcolor="#999999" align="center"> </td><td bgcolor="#999999" align="center">Gestion du MQTT </td></tr><tr> <td rowspan="2" valign="middle" height="49" bgcolor="#999999" align="center">Avant le Setup </td><td valign="middle" bgcolor="#999999" align="center">Importation de la bibliothèque </td><td valign="middle" align="left">#include <MQTT.h> </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Création de l’objet </td><td valign="middle" align="left">MQTTClient myMQTTClient; </td></tr><tr> <td rowspan="5" valign="middle" height="17" bgcolor="#999999" align="center">Dans le Setup (ou le loop) </td><td valign="middle" bgcolor="#999999" align="center">Initialisation </td><td valign="middle" align="left">myMQTTClient.begin(@IP Broker, Port Broker, Client Wifi) ; </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Se préparer à la réception de messages </td><td valign="middle" align="left">myMQTTClient.onMessage(référence de la fonction à appeler sur réception d'un message) ; </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Connexion au broker MQTT </td><td>myMQTTClient.connect(ID unique) </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Souscrire à un "topic" particulier </td><td>myMQTTClient.subscribe(topic) ; </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Publier un message </td><td>myMQTTClient.publish(topic, message) ; </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Dans le Loop </td><td valign="middle" bgcolor="#999999" align="center">Activation régulière </td><td>obligatoire : myMQTTClient.loop() ; </td></tr></table> Pour connaître toutes les autres possibilités de cette bibliothèque, voir sa référence, [https://github.com/256dpi/arduino-mqtt ici]. '''Code minimal :''' Dans cet exemple, notre carte est à la fois émettrice (elle va envoyer des "Pings") et réceptrice sur le topic "PING_PONG". Elle va aussi répondre "Pong" sur réception d'un "Ping". En règle générale, dans les vraies applications, une carte est souvent émettrice (envoi de données d'un capteur de pollution, par exemple), et il peut y avoir une seule autre carte chargée d'exploiter les données remontées par plusieurs capteurs. <div class="mw-highlight mw-content-ltr" dir="ltr"><pre> 1 /* ========================================================================================================= 2 * 3 * CODE MINIMAL RESEAU - ETAPE 6 : Messages MQTT 4 * 5 * --------------------------------------------------------------------------------------------------------- 6 * Les petits Débrouillards - décembre 2022 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/ 7 * ========================================================================================================= */ 8 9 // Bibliothèques requises 10 // ATTENTION AUX MAJUSCULES & MINUSCULES ! Sinon d'autres bibliothèques, plus ou moins valides, seraient utilisées. 11 12 #include <WiFiManager.h> // Gestion de la connexion Wi-Fi (recherche de points d'accès) 13 #include <WiFiClientSecure.h> // Gestion de la connexion à un serveur de données 14 #include <MQTT.h> // Gestion des requêtes MQTT 15 16 17 // Variables globales 18 19 WiFiManager myWiFiManager; // Manager Wi-Fi 20 WiFiClient myWiFiClient ; // Client WiFi 21 const char* mySSID = "AP_PetitDeb" ; // Nom de la carte en mode Point d'Accès. 22 const char* mySecKey = "PSWD1234" ; // Mot de passe associé, 8 caractères au minimum. 23 24 25 #define MQTT_BROKER_IP "debrouillards.ddns.net" // Serveur sur lequel est installé le Broker MQTT. 26 #define MQTT_BROKER_PORT 1883 // Port sur lequel écoute le broker MQTT 27 28 char MY_MQTT_ID[20] ; // Id unique de notre objet, basé sur ESP.getChipId() 29 const char MY_MQTT_TOPIC[] = "PING_PONG" ; // Nom de notre topic (sujet) MQTT 30 31 MQTTClient myMQTTClient; // Client MQTT 32 33 bool IHaveToAnswer = false ; // Passe à 'true' si on doit répondre. 34 35 #define TEN_SECONDS 10000 // On enverra un message au broker toutes les 10000 ms = 10 secondes. 36 unsigned long myWakeUp ; // Timer mis en place pour limiter le nombre d'envois au broker. 37 38 /* -------------------------------------------------------------------------------------------------------------- 39 * MQTT_Received : réception d'un message MQTT 40 * ------------------------------------------------------------------------------------------------------------- */ 41 void MQTT_Received(String &topic, String &payload) { 42 43 char myTrace[80] ; 44 45 sprintf(myTrace, "Réception sur le topic \"%s\" du message MQTT \"%s\".", topic, payload) ; 46 Serial.println(myTrace) ; 47 48 // Comme indiqué dans la documentation, il ne faut pas renvoyer de messages dans cette fonction, 49 // ça risque de mal se passer (blocages, ...). Si on souhaite répondre au message reçu, il vaut 50 // mieux mettre à jour une variable globale, qui sera vérifiée dans la partie loop(). 51 52 if (payload == String("Ping")) { 53 IHaveToAnswer = true ; 54 } 55 56 } 57 58 /* -------------------------------------------------------------------------------------------------------------- 59 * MQTT_Connect : Connexion - ou reconnexion - au broker MQTT. 60 * ------------------------------------------------------------------------------------------------------------- */ 61 void MQTT_Connect() { 62 63 // Vérification WiFi OK. 64 65 int nbTries = 0 ; 66 while (WiFi.status() != WL_CONNECTED) { 67 if (nbTries++ > 10) { 68 Serial.println("Connexion WiFi KO :-(") ; 69 return ; 70 } 71 delay(500); 72 } 73 74 // Connexion au broker. 75 76 Serial.println("--- Connexion MQTT, Id unique \"" + String(MY_MQTT_ID) + "\" ") ; 77 nbTries = 0 ; 78 while (!myMQTTClient.connect(MY_MQTT_ID)) { 79 Serial.print(".") ; 80 if (nbTries++ > 10) { 81 Serial.println(" KO :-(") ; 82 return ; 83 } 84 delay(500); 85 } 86 87 // Abonnement au topic. 88 89 Serial.println("--- Abonnement au sujet \"" + String(MY_MQTT_TOPIC) + "\"") ; 90 myMQTTClient.subscribe(MY_MQTT_TOPIC); 91 92 } 93 /* -------------------------------------------------------------------------------------------------------- 94 * SETUP : Initialisation 95 * -------------------------------------------------------------------------------------------------------- */ 96 void setup() { 97 98 // Initialisation de la liaison série, affichage 1er message 99 100 Serial.begin(115200); 101 delay(100) ; 102 Serial.println(); 103 Serial.println("---------------------") ; 104 Serial.println("Exemple messages MQTT") ; 105 Serial.println("---------------------") ; 106 107 // Tentative de connexion au Wi-Fi. Si la carte n'a pas réussi se connecter au dernier Point d'Accès connu, 108 // alors elle va se positionner en mode Point d'Accès, demandera sur l'adresse 192.168.4.1 quel nouveau 109 // Point d'Accès choisir. Par défaut, on restera bloqué tant que l'utilisateur n'aura pas fait de choix. 110 111 Serial.println("Connexion au Wi-Fi ..."); 112 if (myWiFiManager.autoConnect(mySSID, mySecKey)) { 113 Serial.println(); Serial.print("Connecté ! Adresse IP : "); 114 Serial.println(WiFi.localIP()); 115 } 116 else { 117 Serial.println("Connexion Wi-Fi KO :-("); 118 } 119 120 // Initialisation du MQTT 121 122 Serial.println("Initialisation MQTT ..."); 123 myMQTTClient.begin(MQTT_BROKER_IP, MQTT_BROKER_PORT, myWiFiClient); // lancement du client MQTT ... 124 myMQTTClient.onMessage(MQTT_Received); // ... qui appelera la fonction MQTT_Received si un message est reçu. 125 126 strncpy(MY_MQTT_ID, String(ESP.getChipId()).c_str(),sizeof(MY_MQTT_ID)) ; // Fabrication de mon ID unique, sur la base du n° de puce 127 MY_MQTT_ID[sizeof(MY_MQTT_ID)-1] = '\0' ; 128 129 // Connexion au broker 130 131 MQTT_Connect() ; 132 133 // Initialisation du timer qui sera testé dans loop() - pour faire appel au serveur seulement toutes les 10 secondes 134 // millis() est une fonction système donnant le nombre de ms depuis le lancement ou la réinitialisation de la carte. 135 136 unsigned long myWakeUp = millis() + TEN_SECONDS ; 137 138 } 139 140 /* -------------------------------------------------------------------------------------------------------------- 141 * LOOP : fonction appelée régulièrement par le système 142 * ------------------------------------------------------------------------------------------------------------- */ 143 void loop() { 144 145 // Réactivation du client MQTT 146 147 myMQTTClient.loop() ; 148 delay(10) ; // Problèmes de stabilité Wi-Fi ? (Cf. doc MQTT) 149 150 // Reconnexion au broker MQTT si nécessaire ... 151 152 if (!myMQTTClient.connected()) { 153 MQTT_Connect(); 154 } 155 156 // Si on a précédemment reçu un 'Ping', on va répondre 'Pong' 157 158 if (IHaveToAnswer) { 159 IHaveToAnswer = false ; 160 Serial.println("Envoi de la réponse \"Pong\" sur le topic \"" + String(MY_MQTT_TOPIC) + "\".") ; 161 myMQTTClient.publish(MY_MQTT_TOPIC, "Pong") ; 162 } 163 164 // Envoi d'un message toutes les 10 secondew. 165 166 unsigned long myNow = millis() ; 167 if (myNow >= myWakeUp) { 168 Serial.println("Wake Up ! envoi du message \"Ping\" sur le topic \"" + String(MY_MQTT_TOPIC) + "\".") ; 169 myMQTTClient.publish(MY_MQTT_TOPIC, "Ping") ; 170 myWakeUp = myNow + TEN_SECONDS ; 171 } 172 173 174 } </pre></div></nowiki> , ... Si vous avez suivi tous les épisodes ... :-) Les exemples de code "minimal" fournis peuvent servir de base pour vos futures réalisations, ou pour gagner un temps précieux pendant un hackathon. Tous les codes sont regroupés dans un dossier compressé, accessible dans la rubrique "Fichiers" en début de cette page. Pour aller plus loin, n'hésitez pas à copier ces programmes minimaux, et à les modifier en douceur pour obtenir autre chose que des traces dans le moniteur série Arduino. Juste quelques idées ... *Sur la base du code de l'étape 4 (serveur web), et d'un [https://www.wikidebrouillard.org/wiki/Item:Servomoteur servomoteur], fabriquer un coffre secret qui ne s'ouvre que lorsque son/sa propriétaire tape un code sur son téléphone ; *Sur la base du code de l'étape 5 (JSON) et d'un [https://www.wikidebrouillard.org/wiki/Item:Ruban_de_Led_-_WS2812B ruban de leds], faire un thermomètre affichant la température de votre ville préférée. Il y a de nombreux sites web proposant gratuitement (si on n'abuse pas) des informations météo en mode JSONs, par exemple : **[https://api.tutiempo.net/fr/json.html TuTiempo.net] **[https://openweathermap.org/api OpenWeather] **[https://prevision-meteo.ch/services Previsionsmeteo.ch] *Sur la base du code de l'étape 6 (MQTT), et d'un [https://www.wikidebrouillard.org/wiki/Item:Capteur_de_temp%C3%A9rature_et_d%27humidit%C3%A9_DHT11 capteur de température et d'humidité], ... ah, on me glisse dans l’oreillette que [https://www.wikidebrouillard.org/wiki/Envoyer_des_donn%C3%A9es_sur_le_WEB_gr%C3%A2ce_%C3%A0_MQTT ça existe déjà sur le Wikidébrouillard] ! (avec une autre bibliothèque MQTT). ... Ou bien alors, avec deux D1 Mini, deux [https://www.wikidebrouillard.org/wiki/Item:Bouton_poussoir boutons poussoirs] et deux [https://www.wikidebrouillard.org/wiki/Item:Ruban_de_Led_-_WS2812B rubans de leds], faire une version "jeu à distance" du célèbre [https://www.wikidebrouillard.org/wiki/D1-Pong D1-Pong] ! +

Code minimal des actionneurs pour Arduino +

Avec Arduino nous réalisons des montages qui utilisent 4 types de composants : * des capteurs, * des actionneurs, * des cartes électroniques programmables, * des éléments structurant les circuits (breadbord, cables, autres composant électroniques, etc.). Un capteur capte des informations qui sont utilisées par le programme de la carte pour déclencher des actions : * illuminer, * bouger, * chauffer, * colorer, * lancer une musique, * ... Les actionneurs sont donc très divers et ont leurs mode de fonctionnement. Généralement, il s'agit de leurs envoyer une information ou une quantité de courant. +, Pour utiliser une LED, il faut : * des cables duponts, * une breadboard, * une résistance, * une LED +

Code minimal des capteurs pour Arduino +

Il existe deux catégories de capteurs : * Les capteurs Analogiques * Les capteurs Numériques Les capteurs Analogiques : Ils renvoient du courant à l'Arduino. Ils sont reliés aux broches Analogiques de la carte qui sont capables de transformer le courant en information (un signal numérique). Les capteurs Numériques : Il renvoient un 1 ou un 0 à l'Arduino +, <nowiki>Un bouton poussoir est un composant qui ouvre (le courant ne passe plus) ou ferme (le courant passe) un circuit électrique. <table class="wikitable" cellspacing="0" border="0"> <tr> <td height="17" bgcolor="#999999" align="left"> </td><td valign="middle" bgcolor="#999999" align="center"> </td><td bgcolor="#999999" align="center">Bouton poussoir </td></tr><tr> <td rowspan="2" valign="middle" height="49" bgcolor="#999999" align="center">Avant le Setup </td><td valign="middle" bgcolor="#999999" align="center">Importation de la bibliothèque </td><td valign="middle" align="left"> </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Création de l’objet </td><td valign="middle" align="left"> </td></tr><tr> <td valign="middle" height="17" bgcolor="#999999" align="center">Dans le Setup </td><td valign="middle" bgcolor="#999999" align="center">Démarrage de l’objet </td><td valign="middle" align="left">pinMode(num_broche,INPUT_PULLUP) ; </td></tr><tr> <td valign="middle" height="41" bgcolor="#999999" align="center">Dans le Loop </td><td valign="middle" bgcolor="#999999" align="center">Utilisation </td><td valign="middle" align="left">int val_bouton = digitalRead(num_broche); </td></tr></table> <div class="mw-highlight mw-content-ltr" dir="ltr"><pre> 1 //////////////////////// 2 // *Code Minimal* // 3 // -Le Bouton- // 4 //////////////////////// 5 /*Les programmes "Code Minimal" des petits débrouillards sont conçu pour 6 permettre la prise en main rapide d'un composant électronique. 7 A retrouver sur https://www.wikidebrouillard.org 8 9 -Le Bouton- 10 11 Matériel : 12 - un D1 mini 13 - un bouton 14 15 le bouton branché à la broche D3 du D1 mini 16 car la broche D3 possède une résistance de pullup interne 17 Une résistance de pullup c'est lorsque la broche est branchée a une résistance reliée au niveau haut de la carte(HIGH) 18 dans le D1 mini il y a donc une résistance de 10Kohm qui relie la broche D3 au +3,3V 19 D3---^/\/v---+3V3 20 21 ___ 22 / ___ \ 23 |_| | | 24 /_/ 25 _ ___ _ 26 |_| |___|_| |_ 27 ___|_ _| 28 |___| |_| 29 Les petits Débrouillards - décembre 2020 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/ 30 */ 31 32 // Déclaration des variables constantes 33 const int brocheBouton = D3; // Broche où est connectée le bouton 34 const int brocheLed = D4; // Broche D4, où la led interne au wemos est connectée 35 36 // Boucle d'initialisation 37 void setup() { 38 pinMode(brocheLed, OUTPUT); // Initialisation de la broche de la led en sortie 39 40 pinMode(brocheBouton, INPUT_PULLUP); // Initialisation de la broche du bouton en entrée et activation du pull-up interne 41 } 42 43 //Boucle principale 44 void loop() { 45 // Lecture de l'état du bouton et stockage dans la variable etatBouton 46 // Déclaration de variable d'état locale (dite locale car déclarée dans la boucle "loop"). 47 bool etatBouton = digitalRead(brocheBouton); //// Variable permettant de récupérer l'état du bouton 48 49 // Si le bouton est appuyé, on éteins la led 50 if (etatBouton == HIGH) { 51 // extinction de la led 52 digitalWrite(brocheLed, HIGH); 53 } else { 54 // sinon allumage de la led 55 digitalWrite(brocheLed, LOW); 56 } 57 } </pre></div> </nowiki> , <nowiki>==Bibliothèque : == Pour utiliser facilement ce capteur, nous vous conseillons d'utiliser la bibliothèque Grove BME280 (présente dans le gestionnaire de bibliothèques arduino) plus d'infos pour [https://www.wikidebrouillard.org/wiki/Importer_des_biblioth%C3%A8ques_dans_l%27interface_Arduino Importer des bibliothèques dans l'interface Arduino]<div class="annotatedImageDiv" typeof="Image" data-resource="Fichier:Item-BME280 Capture decran du 2020-12-11 14-37-37.png" data-sourceimage="https://www.wikidebrouillard.org/images/9/94/Item-BME280_Capture_decran_du_2020-12-11_14-37-37.png"><div class="center"><div class="floatnone"><a href="/wiki/Fichier:Item-BME280_Capture_decran_du_2020-12-11_14-37-37.png" class="image"><img alt="Item-BME280 Capture decran du 2020-12-11 14-37-37.png" src="/images/9/94/Item-BME280_Capture_decran_du_2020-12-11_14-37-37.png" width="828" height="114" data-file-width="828" data-file-height="114" /></a></div></div></div>La bibliothèque est disponible ici : https://github.com/Seeed-Studio/Grove_BME280 ==Câblage : == <div class="annotatedImageDiv" typeof="Image" data-resource="Fichier:Item-BME280 Capture decran du 2020-12-11 14-42-46.png" data-sourceimage="https://www.wikidebrouillard.org/images/3/33/Item-BME280_Capture_decran_du_2020-12-11_14-42-46.png"><div class="center"><div class="floatnone"><a href="/wiki/Fichier:Item-BME280_Capture_decran_du_2020-12-11_14-42-46.png" class="image"><img alt="Item-BME280 Capture decran du 2020-12-11 14-42-46.png" src="/images/thumb/3/33/Item-BME280_Capture_decran_du_2020-12-11_14-42-46.png/400px-Item-BME280_Capture_decran_du_2020-12-11_14-42-46.png" width="400" height="289" data-file-width="937" data-file-height="677" /></a></div></div></div> ==Le code minimal : == <table class="wikitable" cellspacing="0" border="0"> <tr> <td height="17" bgcolor="#999999" align="left"> </td><td valign="middle" bgcolor="#999999" align="center"> </td><td bgcolor="#999999" align="center">BME280 </td></tr><tr> <td rowspan="2" valign="middle" height="49" bgcolor="#999999" align="center">Avant le Setup </td><td valign="middle" bgcolor="#999999" align="center">Importation de la bibliothèque </td><td valign="middle" align="left">#include "Seeed_BME280.h" #include <Wire.h> </td></tr><tr> <td valign="middle" bgcolor="#999999" align="center">Création de l’objet </td><td valign="middle" align="left">BME280 bme280; // je crée l'objet "bme280" (qui est un BME280) </td></tr><tr> <td valign="middle" height="17" bgcolor="#999999" align="center">Dans le Setup </td><td valign="middle" bgcolor="#999999" align="center">Démarrage de l’objet </td><td valign="middle" align="left">bme280.init(); // ou bme280.init(0x76); ou bme280.init(0x77); </td></tr><tr> <td valign="middle" height="41" bgcolor="#999999" align="center">Dans le Loop </td><td valign="middle" bgcolor="#999999" align="center">Utilisation </td><td valign="middle" align="left">bme280.getTemperature() </td></tr></table> ==Autres fonctionnalités== <table class="wikitable"> <tr> <th colspan="2">Fonction </th></tr><tr> <td>bme280.getPressure() </td><td>Récupère la pression en pascal </td></tr><tr> <td>bme280.getHumidity() </td><td>Récupère l'humidité en % </td></tr></table> ==Exemple : == <div class="mw-highlight mw-content-ltr" dir="ltr"><pre> 1 #include "Seeed_BMP280.h" // import de la bibliothèque BMP280 2 #include <Wire.h> // Import de la bibliothèque I2C 3 BMP280 bmp280; // création de l'objet 4 void setup() 5 { 6 Serial.begin(9600); //initialisation de la liaison série 7 bmp280.init(); //initialisation du capteur 8 } 9 void loop() 10 { 11 float temp = bmp280.getTemperature(); //récupération de la température 12 Serial.print("Température : "); // affichage de la température dans le terminal série 13 Serial.println(temp); 14 } </pre></div> </nowiki> , …

Code minimal des fonctions réseau +

... puisque la page est obsolète ... (mais le Wiki impose au moins une étape) +

Coefficient de ruissellement +

Si tu as déjà utilisé une bouteille avec un bouchon percé pour une autre expérience, tu peux la récupérer et passer cette étape ! Pose le bouchon sur une table et perce une dizaine de trous en appuyant et tournant avec une vrille, une vis ou un clou. Plus tu auras de trous, plus ta pluie sera efficace ! Ensuite, tu peux remplir la bouteille d’eau et remettre le bouchon. Tu peux également ajouter du colorant alimentaire à l’eau si tu veux mieux la voir. +, Avant tout, il faut s’assurer que les éponges tiennent dans les barquettes plastiques choisies. Elles n’ont pas besoin d’en occuper tout l’espace, mais c’est mieux si c’est le cas ! Si besoin, découpe-les pour les faire rentrer. Dans l’idéal, il faudra 2 éponges identiques. Dans notre expérience, elles représenteront différents sols. La première devra être humide. Pour cela, plonge-la dans l’eau puis essore la bien. La deuxième devra être gorgée d'eau. Dans ce cas, presse la bien pour chasser l'air et laisse la reprendre sa forme sous l'eau. Découpe une feuille de plastique (ou d’aluminium) à la taille d’une des éponges. +, La barquette plastique nous servira de bassin versant. Tu peux déjà identifier ses limites : les bords définissent la ligne de partage des eaux. Pour l’estuaire, nous allons découper une ouverture au centre d’un des petits côtés de la barquette. Découpe aux ciseaux une petite ouverture (quelques millimètres de largeur) sur chaque barquette. +, …

Colonne d'eau en l'air +

On remplit une bouteille d'eau que l'on pose sur la table. - Ensuite on prend la boite hermétique, que l'on perce a plusieurs endroits en dessous et un trou de même diamètre au centre du couvercle. - On prend une autre bouteille assez large pour pouvoir y mettre la boite hermétique ( de façon a ce qu'elle dépasse légèrement ). - On verse le contenu de la bouteille d'eau dans la boite hermétique, jusqu'à ras bord. puis on ferme le bouchon. +

Combien de pièces peut-on mettre dans un verre rempli d'eau +

Ajouter des pièces les unes après les autres. +, L'eau se bombe (elle fait une voute sur le dessus du verre) +, Remplir un verre d'eau à ras bord. +

Commander un D1 mini avec une interface web +

Le schéma de montage, également indiqué dans le code Arduino, est défini dans la première image. Nous recommandons d'utiliser une "breadboard", pour fixer le D1 mini et gérer l'ensemble des connexions. Nous avons utilisé ici celle livrée dans le kit d'initiation Arduino (Starter kit Arduino®). Les leds, les résistances, et le potentiomètre, proviennent d'ailleurs du même kit. Le montage des 5 leds (sur les pins D0 à D4) ne pose pas de problème particulier, attention cependant à respecter la polarité +/-, et ne pas oublier de mettre les résistances afin de limiter le courant électrique. Concernant le servo moteur, il faut l'alimenter via le pin GND, bien sûr, et la sortie 5V du D1 mini (celui-ci a également une sortie 3,3v, insuffisante pour le servomoteur). La commande du servomoteur sera connectée quant à elle, sur le pin D7 du D1 mini. Et enfin,le potentiomètre aura ses deux connexions externes connectées d'une part sur GND, d'autre part sur le pin '''3,3V''' (important, car c'est la tension maximale qui sera alors disponible sur la connexion centrale du potentiomètre, et qui sera acceptée par le pin A0 du D1 mini ; au-delà le D1 mini risque de souffrir). +, Le code Arduino est commenté, et devrait permettre de comprendre le fonctionnement des différents éléments, et de procéder à des modifications. Pour simplifier la compréhension (et il est d'ailleurs recommandé de faire de même pour vos propres programmes un tant soit peu complexes), on a utilisé plusieurs onglets pour séparer les différentes fonctionnalités : #'''A_D1_WiFi''' contient les variables globales (susceptibles d'être également utilisées dans les autres onglets), ainsi que les deux fonctions 'de base' du D1 Mini, similaires à celles utilisées dans les Arduino : #*'''setup''' : c'est la première fonction appelée au démarrage du D1 Mini, après téléversement ou ré-allumage. C'est ici qu'on va initialiser le WiFi, démarrer le serveur web, définir l'état initial des leds, etc ... #*'''loop''' : cette fonction est appelée régulièrement, c'est à partir de là qu'on réalise les activités souhaitées, telles que consultation ou modification des différents pins, calculs divers, etc ... #'''B_Serveur_Web''' : gère toute la partie web, à savoir la génération de la page web, et également le traitement à effectuer lorsque cette page est demandée par un client (navigateur sur un PC ou un téléphone). C'est le module le plus complexe, il nécessite de connaître HTML, CSS, et Javascript pour tenter des modifications. #'''C_Cmd_Leds''' gère les commandes dites 'évoluées' des leds (par exemple clignotement ou défilement). A partir de l'état (éteint ou allumé) actuel des leds, les fonctions de ce module déterminent quel doit être le nouvel état de ces leds. Elles réactivent ensuite un timer permettant de définir quand le prochain changement aura lieu (et donc la vitesse de clignotement ou de défilement). #'''D_Servomoteur''' gère le servomoteur avec une seule et simple fonction. #'''E_Potentiomètre''' gère la lecture de l'entrée analogique du D1 Mini (qui va lire la valeur fournie par le potentiomètre). Si l'utilisateur a demandé à ce que le potentiomètre agisse sur la vitesse du servomoteur, alors la valeur lue sera appliquée au servomoteur. #'''F_Schéma_Montage''' décrit le montage matériel autour du D1 mini. , On suppose ici que le logiciel Arduino est déjà installé, ainsi que la bibliothèque de gestion du D1 mini (voir pré-requis). #Téléchargez le fichier '''A_D1_WiFi.zip''' (Cf. rubrique "Fichiers ci-dessus"), puis en extraire le répertoire '''A_D1_WiFi''', qui contient tous les modules Arduino (*.ino") - Cf image n° 1. #Double-cliquez sur le fichier '''A_D1_WiFi.ino''', ce qui lancera le logiciel Arduino, sous lequel vous aurez 6 onglets correspondant aux 6 fichiers - Cf. image n° 2. #Connectez le D1 mini au port USB de votre ordinateur. #Dans le menu "Outil", positionnez le bon type de carte, et le bon port - Cf. image n°3. Si cette carte n'est pas définie, ou que le port est grisé, revérifier la configuration Arduino grâce au prérequis [[Utiliser le D1 mini avec Arduino]]. #Cliquez sur l'icône de téléversement - Cf.. image n° 4, et patientez. Si le téléversement se termine bien - Cf. image n°5, bravo ! Si un message d'erreur indique que le port n'est pas le bon, il faut le modifier dans l'onglet outil et relancer cette étape. +, …

Comment séparer les billes +

Munissez vous de deux bouteilles identiques. De préférence lisses. D'un rouleau de scotch De 2 Billes Et d'un cutter +, Découpez le fond des bouteilles a l'aide du cutter. Scotchez-les ensembles par le coté coupé. Puis introduisez les billes dans les bouteilles. +, Après avoir placés les billes au centre du dispositif, faire en sorte que chaque bille atteigne les bords opposés du dispositif +

Comment voter avec BELENIOS +

* Le lien vous redirige vers l’interface de vote (« isoloir virtuel »). * Cliquez sur '''« Commencer »''' pour lancer le processus de vote +, * Sélectionnez votre ou vos choix parmi les options proposées. * Une fois votre sélection faite, cliquez sur '''« Suivant »''' pour valider votre bulletin. +, *Une page vous invite à confirmer votre vote à l’aide d’un '''code de vérification'''. *Ouvrez votre boîte mail, récupérez ce code, puis saisissez-le dans la page de confirmation. *Cliquez enfin sur '''« Soumettre »''' pour finaliser votre vote. +, …

Communication entre ESP +

<nowiki>Pour récupérer l'adresse mac de ton microcontrôleur exécute cette commande dans la console : <div class="mw-highlight mw-content-ltr" dir="ltr"><pre>import network ; import ubinascii ; ubinascii.hexlify(network.WLAN().config('mac'),':').decode() </pre></div>L'adresse mac sera affichée entre guillemets. Tu peux aussi utiliser le bloc '''Récupérer l'adresse MAC'''.</nowiki> +, Premièrement, tu dois enregistrer un ou plusieurs destinataires. Utilise le bloc '''Enregistrer un destinataire''' et renseigne l'adresse MAC du microcontrôleur à qui tu veux envoyer le message. Ensuite, tu peux envoyer un message à tous les destinataires enregistrés avec le bloc '''Envoyer un message à tous les destinataires'''. +, Le bloc '''Quand message reçu''' faire te permet de regarder périodiquement si un message a été reçu et d'exécuter ensuite le code de ton choix. Ce bloc te fournit 2 variables : '''host''' et '''msg'''. '''Host''' contient l'adresse mac de l'expéditeur. '''Msg''' contient le message reçu. +

Comprendre les résistances de pull-up et pull-down +

On réalise le montage comme sur le schéma ou la photo. * La broche 11 est connectée au bouton. * L'autre coté du bouton est connecté au +5V * Lorsqu'on appuie sur le bouton, la broche reçoit 5V (elle est en état "HAUT"). On charge le premier programme sur l'Arduino. On ouvre le moniteur série. Il ressort dans le moniteur série un résultat qui n'est pas satisfaisant : *L'état est fluctuant. *Parfois après un appuis, l'état reste haut longtemps après qu'on ait relâché le bouton. *Le comportement est imprévisible. +, On réalise le montage comme sur le schéma ou la photo. *La broche 11 est connectée au bouton et au +5V par l'intermédiare d'une résistance dite de pullup. *L'autre coté du bouton est connecté au GND *Lorsqu'on appuie sur le bouton, la broche passe de +5V à GND. On charge le premier programme sur l'Arduino On ouvre le moniteur série. Le résultat est mieux ! Les états sont clairs ! +, <nowiki>Oui ! L'Arduino possède une résistance de pullup interne pour chaque broche numérique (c'est le cas pour d'autres carte comme le [[Item:D1 mini|D1 mini]] mais pas sur toutes les broches). Elle s'active dans le "setup" avec la fonction INPUT_PULLUP <div class="mw-highlight mw-content-ltr" dir="ltr"><pre>void setup() { pinMode(brocheBouton, INPUT_PULLUP); } </pre></div> </nowiki> +

Comprendre une interaction et simuler la chaîne alimentaire marine +

Fiche “interactions“ 15 cartes espèces Bobine de ficelle d’au moins 3m +, Chaque participant se voit attribuer une espèce et affiche son rôle. Ensuite, les enfants vont devoir, ensemble, tenter de définir leurs places au sein de la chaîne alimentaire, en formant une ligne courbe censé illustrer cette hiérarchie, où chacun se place en fonction de leurs rôles. +, L’animateur.rice vient alors distribuer une ficelle à l’individu en bas de la chaîne (phytoplancton), puis l’objectif sera que tout le monde soit relier par cette ficelle, qui illustrera leurs interactions. Pour cela, chacun lève la main quand iel pense être en interaction avec tel ou tel spécimen. Enfin, l’animateur.rice demandera, par exemple aux prédateurs supérieurs victimes de pêche accidentelle de tirer sur leur morceau de ficelle, puis au phytoplancton, menacé par l’acidification de l’océan, de tirer à son tour sur la ficelle. Tout le monde ressentira alors la tension de la ficelle, illustrant un système basé sur l’interdépendance des espèces entre elles et et des pressions qu’elles subissent. +, …

Concentration de la lumière +

Matériel: - Une loupe - Une feuille de papier ou un morceau de bois - Un bon soleil de printemps ou d'été. - Lunette de soleil (C'est pour éviter d'avoir mal au yeux tout au long de l'expérience, ce n'est pas une protection totale) - Une bouteille remplie d'eau en cas d'accident <div class="icon-instructions caution-icon"> <div class="icon-instructions-icon"></div> <div class="icon-instructions-text">...Attention, cette expérience est à faire avec un adulte. En effet, tu peux te brûler la main, les yeux ou autres. Dès que l'on sort avec la loupe, il faut que celle-ci soit le plus à l'abri du soleil lorsqu'elle n'est pas utilisée</div> </div> +, Pose ta cible (morceau de bois ou papier) sur une surface qui ne brûle pas, dans un espace dégagé et en l'absence de matériel inflammable à proximité. (Dans une forêt en plein été, c'est par exemple, dangereux pour toi et tu pourrais provoquer un incendie) Puis positionne ta loupe dans l'axe entre le soleil et la cible. +, En faisant varier la distance de la loupe à la cible, tu constateras que le point lumineux s'agrandit ou se rétrécit. Il faut obtenir le point le plus petit. De la fumée peut alors commencer à se dégager!! Si tu enlèves ta loupe et la poses à l'abris, tu constateras que ta cible a brûlé au niveau du point lumineux +

Concurrents ou associés dans le milieu marin +

'''Parmi les espèces suivantes, qui mange qui ? '''Reconstitue, à l’aide des vignettes, 6 petites chaînes alimentaires des récifs coralliens de l’île de la Réunion : #krill, baleine à bosse, phytoplancton #triton conque, oursin, algues #phytoplancton, anémone, krill #oursin, coraux, triton conque #zooplancton, mérou, phytoplancton, poisson-clown #coraux, requin, poisson-papillon, mérou, zooplancton Note tes réponses sur une feuille, elles te serviront à l'étape suivante. +, Tu viens de définir un premier type d'interactions entre les espèces : la relation proie-prédateur (qui mange qui), mais il en existe bien d'autres ! Tu vas en découvrir quelques-unes ci dessous. - Place sur ton réseau trophique '''le rémora rayé''' sous '''le requin''', et '''la lamproie''' sous '''la baleine à bosse'''. '''L’anémone de mer''' et '''le poisson clown''' sont également côte à côte. - '''Identifie les autres types d'interactions (positives (+), négatives (-) ou neutres (0)) qui existent entre ces 6 espèces''', en t'aidant des définitions ci-dessous : *'''Le commensalisme''' (+/0) est une relation dans laquelle une espèce tire profit de l’association des deux espèces (concernant la nourriture, l’abri, le transport...), alors que l’autre n’y trouve ni avantage ni inconvénient. ''(ex : mousse sur les troncs d’arbres).'' *'''Le parasitisme''' (+/-) est une relation dans laquelle un organisme (le parasite) tire profit de l'hôte, parfois entraînant sa mort ''(ex : Plasmodium falciparum, parasite véhiculé par le moustique, qui cause le paludisme chez l’humain).'' *'''Le mutualisme''' (+/+) est une association à bénéfices réciproques entre deux espèces qui peuvent mener une vie indépendante ''(ex : abeilles et et plantes à fleurs associées).'' *'''La symbiose''' (+/+) est une association à bénéfices réciproques entre deux espèces indissociables ''(ex : certaines bactéries dans nos intestins).'' '''Maintenant, à toi de jouer !''' 1- Le rémora rayé se nourrit des déchets non mangés par le requin. Il parcourt également de grandes distances sur son ventre et se protège ainsi contre ses prédateurs, ce qui ne dérange pas le requin. '''De quel type d'interaction s’agit-il ?''' 2- La lamproie s'attaque à la baleine en utilisant sa ventouse buccale pour se coller à sa peau. Ses dents peuvent râper la peau et pénétrer dans la chair pour se nourrir. '''De quel type d'interaction s’agit-il ?''' 3- Le poisson-clown trouve dans l'anémone une protection contre les prédateurs et un lieu de ponte. Il nettoie les tentacules de l'anémone et la défend contre les attaques du poisson-papillon qui veut la dévorer. Il peut même servir d’appât pour attirer des proies vers l'anémone. '''De quel type d'interaction s’agit-il ?''' Vérifie tes réponses à l'aide des schémas de l'étape 6. , - Découpe 16 rectangles dans du papier (tu peux plier une feuille en 4 pour avoir les 16 rectangles) - Ouvre l’annexe “[https://www.wikidebrouillard.org/images/7/7a/Concurrents_ou_associ_s_dans_le_milieu_marin_16_cartes_organismes_marins.pdf 16 cartes organismes marins]” et pour chaque rectangle découpé, écris le nom d’un des organismes marins de l’annexe - Si tu ne connais pas certaines espèces, découvre-les plus en détail dans l’annexe “[https://www.wikidebrouillard.org/images/6/6a/Concurrents_ou_associ_s_dans_le_milieu_marin_Presentation_des_organismes_marins.pdf Présentation des organismes marins]” (Facultatif : si tu as une imprimante couleur, tu peux directement imprimer les cartes de l’annexe) +, …

Concurrents ou associés dans le milieu terrestre ? Les réseaux trophiques et réseaux alimentaires +

'''Parmi les espèces suivantes, qui mange qui ?''' Reconstitue à l’aide des 10 vignettes ci-contre les 4 petites chaînes alimentaires : 1 - Exemple : loup, herbe, chevreuil. ''L'herbe est mangée par le chevreuil qui est lui-même mangé par le loup'' : herbe → chevreuil → loup (la flèche signifie “est mangé par”) 2 - Vipère, mûre, hibou, mulot 3 - Chenille, hibou, mulot, feuille de ronce 4 - Renard, lapin, herbe, loup 5 - Mulot, chenille, loup, feuille de ronce, renard Note tes réponses sur une feuille, elles te serviront à l'étape suivante. Et les végétaux, comment se nourrissent-ils ? Quelle forme ont ces chaînes alimentaires ? +, Pour commencer, rassemble le matériel nécessaire à l'expérience : - annexe “[https://www.wikidebrouillard.org/images/d/d7/Concurrents_ou_associ_s_dans_le_milieu_terrestre_Vignettes_Esp_ces.pdf Vignettes espèces]” - annexe "[https://www.wikidebrouillard.org/images/5/57/Concurrents_ou_associ_s_dans_le_milieu_terrestre_R_seau_trophique_-_compl_ter.pdf Réseau trophique - à compléter]" - annexe "[https://www.wikidebrouillard.org/images/3/3c/Concurrents_ou_associ_s_dans_le_milieu_terrestre_R_seau_trophique_-_Solution.pdf Réseau trophique - solution]" - du papier - un crayon - des ciseaux Si tu as, tu peux utiliser aussi : - une imprimante couleur +, - Si tu as une imprimante couleur, imprime les annexes “[https://www.wikidebrouillard.org/images/d/d7/Concurrents_ou_associ_s_dans_le_milieu_terrestre_Vignettes_Esp_ces.pdf Vignettes espèces]” et “[https://www.wikidebrouillard.org/images/5/57/Concurrents_ou_associ_s_dans_le_milieu_terrestre_R_seau_trophique_-_compl_ter.pdf Réseau trophique - à compléter]”. - Si tu n’as pas d’imprimante couleur, découpe 16 rectangles de papier (tu peux plier une feuille en 4 pour avoir les 16 rectangles). - Ouvre l’annexe “[https://www.wikidebrouillard.org/images/d/d7/Concurrents_ou_associ_s_dans_le_milieu_terrestre_Vignettes_Esp_ces.pdf Vignettes espèces]” et écris sur chaque rectangle le nom d’une espèce de l’annexe. - Réunis des feuilles A4 et des crayons de couleurs et/ou des feutres. +, …

Concurrents ou associés dans le sol +

Le schéma ci-contre présente différents types d'interactions dans un milieu terrestre : relations de prédation, de parasitisme (''vers nématodes/racines des salades'') mais aussi de coopération : commensalisme (''cloportes/fourmis et spores de champignons/vers de terre''), symbiose ''(champignons mycorhizes/racines des arbres'') et mutualisme (''bactéries de l’intestin/hérissons'')). '''Que se passe-t-il si l'on perturbe ce réseau trophique ?''' *Un jardinier supprime un tas de bois mort dans un coin de son jardin (impactant fortement les carabes qui y habitent) ou retourne le sol à la bêche (menaçant les vers de terre). '''Si tu enlèves les cartes “Vers de terre” et “Carabes”''' '''de ton réseau trophique, que se passe-t-il pour les autres espèces en interactions ?''' Si tu veux, tu peux recommencer en retirant une ou deux autres espèces situées à différents endroits du réseau. *'''Selon toi, de quelles manières l’humain peut-il interagir sur ce réseau trophique ? Quelles conséquences cela peut-il avoir ?''' +, Pour commencer, rassemble le matériel nécessaire à l'expérience : - annexe “[https://www.wikidebrouillard.org/images/8/82/Concurrents_ou_associ_s_dans_le_sol_Vignettes_Qui_mange_qui.pdf Vignettes qui mange qui] ” - annexe “[https://www.wikidebrouillard.org/images/8/80/Concurrents_ou_associ_s_dans_le_sol_Vignettes_Concurrents_ou_associ_s.pdf Vignettes concurrents ou associés]” - annexe "[https://www.wikidebrouillard.org/images/f/f9/Concurrents_ou_associ_s_dans_le_sol_R_seau_trophique_-_compl_ter.pdf Réseau trophique - à compléter]" - annexe "[https://www.wikidebrouillard.org/images/0/08/Concurrents_ou_associ_s_dans_le_sol_R_seau_trophique_-_solution.pdf Réseau trophique - solution]" - du papier - un crayon - des ciseaux Si tu as, tu peux utiliser aussi : - une imprimante +, - Si tu as une imprimante , imprime les annexes “[https://www.wikidebrouillard.org/images/8/82/Concurrents_ou_associ_s_dans_le_sol_Vignettes_Qui_mange_qui.pdf Vignettes qui mange qui] ”, “[https://www.wikidebrouillard.org/images/8/80/Concurrents_ou_associ_s_dans_le_sol_Vignettes_Concurrents_ou_associ_s.pdf Vignettes concurrents ou associés] ” et “[https://www.wikidebrouillard.org/images/f/f9/Concurrents_ou_associ_s_dans_le_sol_R_seau_trophique_-_compl_ter.pdf Réseau trophique - à compléter]”. - Découpe les vignettes des annexes “[https://www.wikidebrouillard.org/images/8/82/Concurrents_ou_associ_s_dans_le_sol_Vignettes_Qui_mange_qui.pdf Vignettes qui mange qui] ” et “[https://www.wikidebrouillard.org/images/8/80/Concurrents_ou_associ_s_dans_le_sol_Vignettes_Concurrents_ou_associ_s.pdf Vignettes concurrents ou associés] ”, sans les mélanger. - Si tu n’as pas d’imprimante, découpe 19 petits rectangles de papier (tu peux plier une feuille A4 en 5 pour les avoir). - Ouvre l’annexe “[https://www.wikidebrouillard.org/images/8/82/Concurrents_ou_associ_s_dans_le_sol_Vignettes_Qui_mange_qui.pdf Vignettes qui mange qui]” et écris sur chaque rectangle le nom d’une espèce de l’annexe. - Ouvre l’annexe “[https://www.wikidebrouillard.org/images/8/80/Concurrents_ou_associ_s_dans_le_sol_Vignettes_Concurrents_ou_associ_s.pdf Vignettes concurrents ou associés]” et écris sur chaque rectangle le nom d’une espèce de l’annexe. - Ouvre l’annexe “[https://www.wikidebrouillard.org/images/f/f9/Concurrents_ou_associ_s_dans_le_sol_R_seau_trophique_-_compl_ter.pdf Réseau trophique - à compléter]” et recopie le réseau à l’identique sur une feuille A4. +, …