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

{{Tuto Details
|Main_Picture=Code_minimal_des_fonctions_r_seau_WiKi_Reseau1.png
|Licences=Attribution (CC-BY)
|Description=Utilisation des fonction réseau des cartes compatibles Arduino, possédant une puce Wi-Fi 
<br/>===  Episode n° 3 : Mon D1 Mini récupère des données sur Internet (Json) ===
|Disciplines scientifiques=Arduino, Computing
|Difficulty=Technical
|Duration=2
|Duration-type=hour(s)
}}
{{Introduction
|Introduction=Cette expérience fait partie d'une série de '''4 épisodes''', présentant différentes façons de bénéficier des capacités de communication des cartes compatibles Arduino possédant une puce Wi-Fi (Wemos D1 mini, ESP32, ...). On suppose (''Cf.  "Expériences ré-requises" ci-après'') que vous avez déjà manipulé une carte Arduino et son environnement de développement.  Ces 4 épisodes sont les suivants :

<br />

#[https://www.wikidebrouillard.org/wiki/Code_Minimal_R%C3%A9seau_-_(1)_Connecter_le_Wemos_D1_mini_%C3%A0_internet_en_wifi Connecter le Wemos D1 Mini à internet en Wi-Fi].
#[https://www.wikidebrouillard.org/wiki/Code_Minimal_R%C3%A9seau_-_(2)_H%C3%A9berger_un_site_web_sur_mon_Wemos_D1_mini Héberger un site web sur mon Wemos D1 Mini].
#Mon Wemos D1 Mini récupère des données sur Internet  (format Json) --- ''cette page''.
#[https://www.wikidebrouillard.org/wiki/Code_Minimal_R%C3%A9seau_-_(4)_Mes_Wemos_D1_Mini_discutent_sur_Internet_avec_MQTT Mes Wemos D1 Mini discutent sur Internet avec MQTT].


<u>Il est nécessaire de commencer par l'épisode 1</u>, par contre les épisodes suivants peuvent être consultés dans n'importe quel ordre.


Dans la même philosophie que les expériences "[https://www.wikidebrouillard.org/wiki/Code_minimal_des_capteurs_pour_Arduino Code minimal des capteurs pour Arduino]" et "[https://www.wikidebrouillard.org/wiki/Code_minimal_des_actionneurs_pour_Arduino Code minimal des actionneurs pour Arduino]", <u>nous fournirons ici uniquement le code relatif à nos besoins de connexion</u>, sans mettre au point une quelconque application. Donc, ici, pas besoin de connecter une led ou un capteur, donc <u>pas de schéma de montage</u> : vous branchez simplement votre carte en USB sur votre ordinateur, et les résultats seront visibles en mode texte dans le moniteur série de l'environnement de développement Arduino.
}}
{{Materials
|ItemList={{ItemList
|Item=D1 mini
}}{{ItemList
|Item=Logiciel Arduino
}}{{ItemList
|Item=Câble USB - micro-USB
}}
|Prerequisites={{Prerequisites
|Prerequisites=Installer l'environnement Arduino sur votre système
}}{{Prerequisites
|Prerequisites=Premiers pas avec Arduino
}}{{Prerequisites
|Prerequisites=Utiliser le D1 mini avec Arduino
}}
|ExternalAttachmentsLinks={{ExternalAttachmentsLinks
|ExternalAttachmentsLinks=https://cloud.debrouillonet.org/s/netQgbkgG34RnYt
}}
}}
{{Tuto Step
|Step_Title=JSON ? qu'est-ce que c'est ?
|Step_Content=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 ...

<br />
 <nowiki>https://data.rennesmetropole.fr//api/records/1.0/search/?dataset=etat-du-trafic-en-temps-reel&q=rocade</nowiki>
... 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 :

{{#annotatedImageLight:Fichier:Code minimal des fonctions reseau Code JSON.png|0=564px|hash=|jsondata=|mediaClass=Image|type=frameless|alt=Exemple de réponse JSON|align=center|src=https://www.wikidebrouillard.org/images/d/d7/Code_minimal_des_fonctions_reseau_Code_JSON.png|href=./Fichier:Code minimal des fonctions reseau Code JSON.png|resource=./Fichier:Code minimal des fonctions reseau Code JSON.png|caption=Exemple de réponse JSON|size=564px}}

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.
}}
{{Tuto Step
|Step_Title=Récupération de données JSON
|Step_Content=... 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 :<br /> {{#annotatedImageLight:Fichier:Code minimal des fonctions reseau Biblio ArduinoJSON.png|0=752px|hash=|jsondata=|mediaClass=Image|type=frameless|alt=Bibliothèque ArduinoJSON|align=center|src=https://www.wikidebrouillard.org/images/9/92/Code_minimal_des_fonctions_reseau_Biblio_ArduinoJSON.png|href=./Fichier:Code minimal des fonctions reseau Biblio ArduinoJSON.png|resource=./Fichier:Code minimal des fonctions reseau Biblio ArduinoJSON.png|caption=Bibliothèque ArduinoJSON|size=752px}}

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.
<br />{{#annotatedImageLight:Fichier:Code minimal des fonctions reseau Copie tableau mode img cause bug si tableau wiki.png|0=800px|hash=|jsondata=|mediaClass=Image|type=frameless|alt=Fonctions JSON|align=default|src=https://www.wikidebrouillard.org/images/9/94/Code_minimal_des_fonctions_reseau_Copie_tableau_mode_img_cause_bug_si_tableau_wiki.png|href=./Fichier:Code minimal des fonctions reseau Copie tableau mode img cause bug si tableau wiki.png|resource=./Fichier:Code minimal des fonctions reseau Copie tableau mode img cause bug si tableau wiki.png|caption=Fonctions JSON|size=800px}}


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.

<br /><syntaxhighlight lang="arduino" line="1">
/* =========================================================================================================
 * 
 *                              CODE MINIMAL RESEAU - ETAPE 5 : Données JSON
 *          
 * ---------------------------------------------------------------------------------------------------------
 * Les petits Débrouillards - décembre 2022 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
 * ========================================================================================================= */

// Bibliothèques requises
// ATTENTION AUX MAJUSCULES & MINUSCULES ! Sinon d'autres bibliothèques, plus ou moins valides, seraient utilisées.

#include <WiFiManager.h>                          // Gestion de la connexion Wi-Fi (recherche de points d'accès)  
#include <WiFiClientSecure.h>                     // Gestion de la connexion (HTTP) à un serveur de données
#include <ArduinoJson.h>                          // Fonctions de décodage JSON des réponses du serveur. 



// Variables globales

WiFiManager myWiFiManager;                        // Création de mon instance de WiFiManager.
WiFiClientSecure myWiFiClient;                    // Création de mon instance de client WiFi.
const char* mySSID   = "AP_PetitDeb" ;            // Nom de la carte en mode Point d'Accès.
const char* mySecKey = "PSWD1234" ;               // Mot de passe associé, 8 caractères au minimum.

char* Data_HOST = "data.rennesmetropole.fr";      // Serveur web hébergeant les données qui nous intéressent
int   Data_PORT = 443;                            // Port sur lequel envoyer la requête
char* Data_REQUEST =                              // Requête (sur cet exemple : demande de l'état du trafic au point
                                                  // 31553, correspondant à la porte de Saint-Malo de la rocade de Rennes 
      "/api/records/1.0/search/?dataset=etat-du-trafic-en-temps-reel&q=31553";  


const int MAX_RESPONSE_SIZE = 6000 ;              // Taille max de la réponse attendue d'un serveur. A modifier en fonction du besoin.
char Data_Response[MAX_RESPONSE_SIZE] ;           // Buffer qui contiendra la réponse du serveur.
  
#define TEN_SECONDS 10000                         // On appelera le serveur de données toutes les 10000 ms = 10 secondes.
unsigned long myWakeUp ;                          // Timer mis en place pour limiter le nombre d'appels au serveur de données.

/* --------------------------------------------------------------------------------------------------------------
 *  serverRequest() : Envoi requête HTTP au serveur et récupération de la réponse
 *  paramètres : 
 *    - pHost     : nom du serveur ; 
 *    - pPort     : port sur lequel est appelé le serveur ; 
 *    - pRequest  : requête au serveur.
 *    - pResponse : endroit où stocker la réponse
 *    - pRespMax  : nombre max de caractères autorisés pour la réponse
 *  valeur de retour : 
 *      -2 = réponse tronquée (trop de caractères) ;
*       -1 = pas de réponse ;
         0 = pas de connexion au serveur ;
 *       1 = ok.
 *  ------------------------------------------------------------------------------------------------------------- */
int serverRequest(char* pHost, int pPort, char* pRequest, char *pResponse, int pRespMax) {
    
    const int API_TIMEOUT = 15000;      // Pour être sûr de recevoir l'en-tête de la réponse client.

    // Comme la connexion est sécurisée (protocole HTTPS), il faudrait indiquer le certificat du site web.
    // Pour simplifier, on va utiliser l'option magique ".setInsecure()", ce qui n'est pas important dans 
    // notre exemple, où les données échangées ne sont pas confidentielles.

    myWiFiClient.setInsecure();
    myWiFiClient.setTimeout(API_TIMEOUT);

    // Connexion au serveur (on essaie 5 fois, avec un intervalle d'une seconde)

    Serial.print("--- Connexion au serveur [" + String(pHost) + "] "); 
    int nbTries = 1;
    while(!myWiFiClient.connect(pHost, pPort)) {
        Serial.print(".");
        if (++nbTries > 5) {
            Serial.println("--- Connexion impossible :-(");
            myWiFiClient.stop();
            return(0);
        }
        delay(1000);
    }   

    // Connecté à notre serveur ! --> Envoi de la requête URL. Il faut envoyer en fait une suite de lignes : 
    //        "GET <notre requête> HTTP/1.1"
    //        "Host: <nom du serveur>"
    //        "Connection: close"
    //        <ligne vide>
    // Cet envoi se fait simplement grâce à la fonction println du client WiFi, similaire à celle que 
    // l'on utilise pour envoyer des données au moniteur série pour nos traces.

    String myURL = String(pRequest);
    Serial.println() ; 
    Serial.println("--- Connexion OK ! --> Envoi requête URL - " + myURL);
    myWiFiClient.println("GET " + myURL + " HTTP/1.1") ;
    myWiFiClient.println("Host: " + String(pHost)) ;
    myWiFiClient.println("Connection: close") ;
    myWiFiClient.println() ;
    
    // Attente de la réponse ....(on essaie 50 fois, avec un intervalle de 100ms, donc 5 secondes en tout)
     
    nbTries = 1;
    while(!myWiFiClient.available()){
        if (++nbTries > 50) {
            Serial.println("--- Pas de réponse :-(");
            myWiFiClient.stop();
            return(-1);
        }
        delay(100);
    }

    // Récupération de l'en-tête de la réponse (dont on ne fera rien)
    // Cette entête est une suite de caractères, composant un certain nombre de lignes (ie se terminant par '\n'), 
    // la dernière ligne de l'entête n'est composée que du caractère "\r" (suivie du '\n') ;
     
    Serial.println("--- Réponse OK --> Récupération de l'en-tête ...");
    String myLine ;
    while (myWiFiClient.connected()) {
        myLine = myWiFiClient.readStringUntil('\n');
        if (myLine == "\r") {
            break;
        }
    }

    // Entête reçue ! On va alors recopier dans pResponse tous les caractères qui suivent 
    // en faisant attention à ne pas dépasser la taille du buffer.

    Serial.println("--- Entête ok --> Récupération des données ...");
    int myIndex = 0 ;
    while(myWiFiClient.available() && myWiFiClient.connected() ){

        char myResp = myWiFiClient.read();
        pResponse[myIndex] = myResp;     
        if (myIndex++ >= pRespMax) {
             Serial.println("*** Réponse trop longue : " + String(pRespMax) + "caractères, et ne peut pas être traitée") ;
             myWiFiClient.stop();
             return(-2);
        }
        pResponse[myIndex] = '\0';            // Vu sur forums : conseillé d'ajouté 'fin de chaîne' systématiquement
        delay(1) ;                            // Et également d'ajouter ce tout petit délai pour éviter des plantages.
        
    }

    // Tout s'est bien passé ! On arrête notre client WiFi

    Serial.println("--- Récupération des données ok (" + String(myIndex) + " caractères).") ;
    myWiFiClient.stop();
    return(1) ;

}

/* --------------------------------------------------------------------------------------------------------
 *  showJSONAnswer : Décodage de la structure de données JSON
 *  Paramètres :
 *    - pResponse : endroit se trouve la réponse (au format JSON) du serveur
 *    - pRespMax  : nombre max de caractères autorisés pour la réponse
 * -------------------------------------------------------------------------------------------------------- */
void showJSONAnswer(char *pResponse, int pRespMax) {

    // Création de notre structure JSON
    // Le besoin en mémoire (capacity) doit être vérifié sur l'assistant https://arduinojson.org/v6/assistant/
    // 1) dans la première page de l'assistant, sélectionnez le processeur (par exemple "ESP8266"), le mode
    //    "Deserialize", et le type d'entrée "char*", puis cliquez sur le bouton "Netx:JSON"
    // 2) Lancez votre requête depuis un navigateur. Dans notre exemple, tapez dans la barre d'adresse :
    //      "https://data.rennesmetropole.fr/api/records/1.0/search/?dataset=etat-du-trafic-en-temps-reel&q=31553"
    // 3) Recopiez la réponse obtenue - sous sa forme "Données Brutes" du navigateur vers l'assistant
    // 4) L'assistant va alors préconiser le bon objet à créer (StaticJsonDocument ou DynamicJsonDocument),
    //    ainsi que la taille à réserver. L'assistant va même proposer un exemple de programme exploitant toutes 
    //    les informations de la structure JSON. 
    // Pour notre exemple, l'assistant a proposé la définition qui suit.
    
    StaticJsonDocument<768> doc;

    // Décodage de la réponse JSON.
    // La fonction deserializeJson va transformer la réponse "texte" du serveur, en une structure de données recopiée
    // dans la variable 'doc', où il sera ensuite facile d'aller chercher les informations souhaitées.
     
    DeserializationError error = deserializeJson(doc, pResponse, pRespMax);
    if (error) {
        Serial.println("--- Décodage réponse JSON KO, code " + String(error.f_str())) ;
        return;
    }
    Serial.println("--- Décodage réponse JSON OK !") ;

    // Nous pouvons maintenant extraire facilement les informations qui nous intéressent,
    // en n'oubliant pas le niveau de profondeur de la donnée au sein de la structure JSON. 
    // Ce niveau de profondeur est incrémenté par le nombre de '{' ou '[' rencontrés, et 
    // décrémenté lors de la rencontre des ']' et '}'. Sur notre exemple 'rocade de Rennes',
    // cela donne ceci :
    //       +-----------------------------------------------------------------+
    //       |   {                                                             | ... Entrée niveau 1
    //       |      "nhits": 1,                                                |
    //       |      "parameters": {                                            | ... Entrée niveau 2
    //       |          "dataset": "etat-du-trafic-en-temps-reel",             |
    //       |          (...)                                                  |
    //       |      },                                                         | ... Retour niveau 1
    //       |      "records": [                                               | ... Début d'un tableau : niveau 2
    //       |          {                                                      | ... Entrée niveau 3
    //       |              (...)                                              |                                                           |
    //       |              "fields": {                                        | ... Entrée niveau 4
    //       |                   (...)                                         |
    //       |                   "averagevehiclespeed": 88,                    |
    //       |                   (...)                                         |
    //       |                   "datetime": "2022-11-30T11:57:00+01:00",      |
    //       +-----------------------------------------------------------------+
    // ... et donc :
    //  - (1er niveau) --------- doc["nhits"] donnera la valeur 1,
    //  - (2ème niveau) -------- doc["parameters"]["dataset"] donnera la valeur "etat-du-trafic-en-temps-reel"
    //  - (4ème niveau) -------- doc["records"][0]["fields"]["averagevehiclespeed"] donnera la valeur 88

    // Extraction et affichage sur le port série de trois  valeurs

    String myLocRef = String(doc["records"][0]["fields"]["predefinedlocationreference"]) ;
    String myTime = String(doc["records"][0]["fields"]["datetime"]) ;
    int mySpeed    = doc["records"][0]["fields"]["averagevehiclespeed"] ;
    
    Serial.print("Vitesse au point " + myLocRef + " ") ;
    Serial.print("le " +  myTime.substring(8,10) + "/" + myTime.substring(5,7) + "/" + myTime.substring(0,4) + " ") ;
    Serial.print("à " +  myTime.substring(11,13) + "h" + myTime.substring(14,16) + " ") ;
    Serial.println(" : " + String(mySpeed) + " km/h.") ; 

}

/* --------------------------------------------------------------------------------------------------------
 *  SETUP : Initialisation
 * -------------------------------------------------------------------------------------------------------- */
void setup() {

    // Initialisation de la liaison série, affichage 1er message

    Serial.begin(115200);
    delay(100) ;
    Serial.println(); 
    Serial.println("-----------------------") ;
    Serial.println("Exemple extraction JSON") ;
    Serial.println("-----------------------") ;

    // Tentative de connexion au Wi-Fi. Si la carte n'a pas réussi  se connecter au dernier Point d'Accès connu,
    // alors elle va se positionner en mode Point d'Accès, demandera sur l'adresse 192.168.4.1 quel nouveau
    // Point d'Accès choisir. Par défaut, on restera bloqué tant que l'utilisateur n'aura pas fait de choix.
    
    Serial.println("Connexion au Wi-Fi ...");
    if (myWiFiManager.autoConnect(mySSID, mySecKey)) {
        Serial.println(); Serial.print("Connecté ! Adresse IP : ");
        Serial.println(WiFi.localIP());
    }
    else {
        Serial.println("Connexion Wi-Fi KO :-(");     
    }

    // Initialisation du timer qui sera testé dans loop() - pour faire appel au serveur seulement toutes les 10 secondes 
    // millis() est une fonction système donnant le nombre de ms depuis le lancement ou la réinitialisation de la carte.

    unsigned long myWakeUp = millis() + TEN_SECONDS ;

}

/* --------------------------------------------------------------------------------------------------------------
 *  LOOP : fonction appelée régulièrement par le système
 *  ------------------------------------------------------------------------------------------------------------- */
void loop() { 

    unsigned long myNow = millis() ;
    if (myNow >= myWakeUp) {
        Serial.println("Wake Up ! Nouvelle demande au serveur ...") ;
        if (serverRequest(Data_HOST, Data_PORT, Data_REQUEST, Data_Response, MAX_RESPONSE_SIZE) == 1) {
            Serial.println("Réponse reçue du serveur, lancement analyse JSON ...") ;
            showJSONAnswer(Data_Response, MAX_RESPONSE_SIZE) ;
        }
        myWakeUp = myNow + TEN_SECONDS ;         
    }

}
</syntaxhighlight>

<br />
}}
{{Tuto Step
|Step_Title=La suite, la suite ! ... :-)
|Step_Content=*'''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.]
}}
{{Notes}}
{{Tuto Status
|Complete=Published
}}