Grove – UART Wifi V2
20 février 2025
1 – Grove – UART Wifi V2
Le module Grove – UART WiFi est un dispositif qui utilise le SoC ESP8285, très populaire dans l’IoT. Il dispose d’une pile de protocoles TCP/IP intégrée, ce qui permet à votre microcontrôleur de se connecter facilement aux réseaux WiFi avec peu de code.
Chaque module ESP8285 est déjà programmé avec un firmware utilisant des commandes AT, ce qui permet de le contrôler en envoyant des commandes simples. Ce SoC inclut des sécurités comme WEP, WPA/WPA2, TKIP, AES et WAPI, et peut agir comme un point d’accès WiFi avec DHCP. Il peut aussi rejoindre un réseau WiFi existant et a des adresses MAC et IP réglables.
2 – ESP8285
L’ESP8285 est un système sur puce (SoC) basé sur un microcontrôleur à faible consommation, développé par Espressif Systems. Il est principalement utilisé dans des applications IoT (Internet des Objets) grâce à ses capacités Wi-Fi intégrées. Voici ses principales caractéristiques :
- Wi-Fi intégré : L’ESP8285 dispose d’une connectivité Wi-Fi intégrée, ce qui permet de se connecter facilement aux réseaux sans fil sans avoir besoin de modules externes.
- Processeur puissant : Il utilise un processeur Tensilica Xtensa LX3, avec une fréquence d’horloge pouvant atteindre 160 MHz, ce qui le rend capable de gérer des applications exigeantes.
- Mémoire : L’ESP8285 dispose de 1 Mo de mémoire flash intégrée pour stocker le firmware et les données, ce qui permet de réduire la taille du matériel et les coûts.
- Protocoles de sécurité : Il prend en charge plusieurs protocoles de sécurité Wi-Fi, tels que WEP, WPA/WPA2, AES et TKIP, ce qui le rend adapté pour des applications nécessitant des connexions sécurisées.
- Mode point d’accès (AP) et station (STA) : Il peut fonctionner en tant que point d’accès pour créer un réseau Wi-Fi ou se connecter à un réseau Wi-Fi existant en tant que station.
- Bas coût et faible consommation d’énergie : Le ESP8285 est très abordable et consomme peu d’énergie, ce qui le rend idéal pour des applications portables ou autonomes qui nécessitent une longue durée de vie sur batterie.
- Facilité de programmation : L’ESP8285 est souvent utilisé avec des environnements de développement comme Arduino ou ESP-IDF (Espressif IoT Development Framework), ce qui facilite sa programmation et son intégration dans divers projets IoT.
En résumé, l’ESP8285 est un SoC puissant et économique, parfait pour des projets connectés nécessitant Wi-Fi et faible consommation d’énergie.
3 – Connexion – Port série (UART)
Le module Grove Wifi doit-être connecté à un des ports séries du microcontrôleur à une vitesse de 115200 bauds.
Si nous utilisons un Arduino Uno, nous sommes limité à un seul port série (via D0 et D1). S’il est utilisé pour afficher des messages au terminal alors il n’y aura pas de connexion possible pour le module Grove Wifi.
Au contraire, si nous utilisons le port série pour y connecter le module Wifi alors celui-ci ne pourra pas être utilisé pour de l’affichage au terminal.
Il est possible d’utiliser la librairie SoftwareSerial pour simuler un port série à partir de deux broches digitals mais sur un Arduino Uno, la communication sera instable à la vitesse de 115200 baud.
3.1 – Solution: Arduino Mega
Arduino Mega – 4 ports UART
4 – Expérimentation
Nous utiliserons la librairie ‘WiFiEsp de bportaluri’ pour piloter le module Grove Wifi V2
4.1 – Dépendance PlatformIO:
lib_deps = bportaluri/WiFiEsp@^2.2.2 monitor_filters = send_on_enter monitor_echo = yes
4.1 – Les commandes <AT>
Contrôle du module WifiESP directement en envoyant des commandes <AT>.
/*
ESP8266 AT Command Tester
Ce programme permet de tester les commandes AT de l'ESP8266
en utilisant un module ESP8266 connecté au port Serial1.
Voici les commandes AT les plus courantes:
- AT : test de communication
- AT+GMR : affiche la version du firmware
- AT+CWLAP : scan des réseaux wifi
- AT+CWJAP="SSID","password" : connexion à un réseau wifi
- AT+CIFSR : affiche l'adresse IP de l'ESP8266 et l'adresse MAC
NOTE: AJOUTER LES LIGNES SUIVANTES DANS LE FICHIER platformio.ini
monitor_filters = send_on_enter
monitor_echo = yes
*/
#include <Arduino.h>
#define VITESSE_MONITEUR 9600
#define VITESSE_ESP8266 115200
#define DELAI_BUFFER 500
void setup()
{
Serial.begin(VITESSE_MONITEUR); // Pour afficher les messages dans le moniteur série
Serial1.begin(VITESSE_ESP8266); // Pour communiquer avec l'ESP8266
Serial.println("\nTester des commandes AT avec un ESP8266");
Serial.println("\nEntrez une commande AT ou un message à envoyer à l'ESP8266");
Serial.println("\nExemple: AT, AT+GMR, AT+CWLAP, AT+CWJAP=\"SSID\",\"password\", AT+CIFSR\n\n: ");
} // Fin de la fonction setup
void loop()
{
if(Serial1.available()) // Vérifie si l'ESP8266 a envoyé des données
{
while(Serial1.available())
{
char c = Serial1.read(); // lit les données de l'ESP8266
Serial.write(c); // affiche les données dans le moniteur série
}
}
if(Serial.available())
{
delay(DELAI_BUFFER); // Attendre DELAI_BUFFER pour recevoir toutes les données
// Lire les données du moniteur série et les stocker dans une chaîne de caractères
String cmd = "";
while(Serial.available())
{
cmd += (char)Serial.read();
}
// Envoyer la commande AT à l'ESP8266
Serial1.println(cmd);
}
} // Fin de la fonction loop
NOTE: Programmer une application Web complète à partir de séquences AT est un processus lourd et complexe. Heureusement, il existe des librairies facilitant la tâche.
4.2 – LIB WifiEsp – Afficher les réseaux disponibles
Contrôle du module WifiESP en utilisant la librairie ‘WiFiEsp’.
/*
WiFiEsp exemple: Recherche des réseaux Wifi disponibles
Auteur: Alain Boudreault
Date: 2025.02.20
----------------------------
Description:
Ce programme recherche et affiche, aux DELAI_RECHERCHE_RESEAUX millisecondes,
l'adresse MAC du module Wifi et recherche les réseaux Wifi disponibles.
Le module ESP8266 est connecté à un Arduino Mega 2560 sur Serial1
platformio.ini:
[env:megaatmega2560]
platform = atmelavr
board = megaatmega2560
framework = arduino
monitor_speed = 115200
lib_deps =
bportaluri/WiFiEsp@^2.2.2
*/
#include <Arduino.h>
#include "WiFiEsp.h"
// Déclaration des constantes
#define VITESSE_SERIE 115200
#define DELAI_RECHERCHE_RESEAUX 10000
#define SECONDE 1000
// Déclaration des fonctions
void afficherAdresseMAC();
void listerReseaux();
void afficherTydeDeCryptage(int thisType);
void setup() {
Serial.begin(VITESSE_SERIE); // Pour les messages de debug
Serial1.begin(VITESSE_SERIE); // Pour les commandes AT du module ESP8266
Serial.println(F("\n\nExemple WiFiEsp: Recherche des réseaux Wifi disponibles\nAuteur: Alain Boudreault\nDate: 2025.02.20\n----------------------------\nDescription:\n\nCe programme recherche et affiche, aux DELAI_RECHERCHE_RESEAUX millisecondes,\nl'adresse MAC du module Wifi et recherche les réseaux Wifi disponibles.\n\nLe module ESP8266 est connecté à un Arduino Mega 2560 sur Serial1\n\n"));
delay(SECONDE);
WiFi.init(&Serial1); // initialisation de la communication avec le module ESP8266
Serial.println(F("\nInitialisation du module ESP8266..."));
// Vérification de la présence du module ESP8266
if (WiFi.status() == WL_NO_SHIELD) {
Serial.println(F("Module ESP8266 non détecté."));
while (true); // Ne pas continuer
}
afficherAdresseMAC(); // Affichage de l'adresse MAC du module ESP8266
} // Fin de la fonction setup()
void loop()
{
// Recherche des réseaux disponibles
Serial.println("\n----------------------------------");
Serial.println("Recherche des réseaux disponibles:");
Serial.println("----------------------------------\n");
listerReseaux();
delay(DELAI_RECHERCHE_RESEAUX);
} // Fin de la fonction loop()
void afficherAdresseMAC()
{
// Obtenir l'adresse MAC du module ESP8266
byte mac[6];
WiFi.macAddress(mac);
// print MAC address
char buf[20];
snprintf(buf, sizeof(buf) ,"%02X:%02X:%02X:%02X:%02X:%02X", mac[5], mac[4], mac[3], mac[2], mac[1], mac[0]);
Serial.print("\nMAC adresse: ");
Serial.println(buf);
} // Fin de la fonction afficherAdresseMAC()
void listerReseaux()
{
// Recherche des réseaux disponibles
int numSsid = WiFi.scanNetworks();
if (numSsid == -1) {
Serial.println("Impossible de scanner les réseaux disponibles");
while (true);
}
// Affichage du nombre de réseaux disponibles
Serial.print("Nombre de réseaux disponibles: ");
Serial.print(numSsid);
Serial.println("\n");
// Affichage des réseaux disponibles et de leur force de signal
for (int reseauCourant = 0; reseauCourant < numSsid; reseauCourant++) {
Serial.print(reseauCourant);
Serial.print(") ");
Serial.print(WiFi.SSID(reseauCourant));
Serial.print("\tSignal: ");
Serial.print(WiFi.RSSI(reseauCourant));
Serial.print(" dBm");
Serial.print("\tCryptage: ");
afficherTydeDeCryptage(WiFi.encryptionType(reseauCourant));
}
} // Fin de la fonction listerReseaux()
void afficherTydeDeCryptage(int thisType) {
// Tester le cryptage et afficher son type
switch (thisType) {
case ENC_TYPE_WEP:
Serial.print("WEP");
break;
case ENC_TYPE_WPA_PSK:
Serial.print("WPA_PSK");
break;
case ENC_TYPE_WPA2_PSK:
Serial.print("WPA2_PSK");
break;
case ENC_TYPE_WPA_WPA2_PSK:
Serial.print("WPA_WPA2_PSK");
break;
case ENC_TYPE_NONE:
Serial.print("None");
break;
}
Serial.println();
} // Fin de la fonction afficherTydeDeCryptage()
// Fin du programme
5 – Utilisation d’une API Web
API = interface de programmation d’application
// Utilisation de l'API http://esh25.ve2cuy.com/apijesuis.php?jesuis=yo_the_man
NOTE: À tester avec Postman
Le résultat est disponible ici
6.1 – Voici le code source pour ajouter à la BD
/*
URLEncode: https://github.com/plageoj/urlencode
WiFiEsp by bportaluri
lib_deps =
bportaluri/WiFiEsp@^2.2.2
plageoj/UrlEncode@^1.0.1
*/
#include "main.h"
char ssid[] = "Le nom du routeur WIFI";
char pass[] = "Le mot de passe";
int status = WL_IDLE_STATUS; // the Wifi radio's status
char buffer[200];
char server[] = "esh25.ve2cuy.com";
const char* messages[] = { "Je suis celui qui est...", // 0
"Rien à ajouter" // 1
};
// Initialize the Ethernet client object
WiFiEspClient client;
void setup()
{
Serial.begin(SERIAL_BAUD_RATE); // initialize serial for debugging
Serial1.begin(WIFI_BAUD_RATE); // initialize serial for ESP module
WiFi.init(&Serial1); // initialize ESP module // initialize ESP module
if (WiFi.status() == WL_NO_SHIELD) {
Serial.println("Module WiFi non détecté!");
// Ne pas continuer
while (true);
}
while ( status != WL_CONNECTED) {
Serial.print("Tentative de connexion au WPA SSID: ");
Serial.println(ssid);
// Connect to WPA/WPA2 network
status = WiFi.begin(ssid, pass);
}
Serial.println("Système connecté au réseau!");
printWifiStatus();
Serial.println();
Serial.println("Connexion au serveur...");
} // setup()
void loop()
{
// Au besoin, afficher la réponse à la requête GET:
while (client.available()) {
char c = client.read();
Serial.write(c);
}
if (!client.connected()) {
Serial.println();
Serial.println("Déconnexion du serveur...");
client.stop();
}
sendInfoTOWebAPI();
delay(DELAI_ENTRE_REQUETES);
while(true); // Ne plus rien faire ...
} // loop()
void sendInfoTOWebAPI(){
// Si la connexion au serveur est établie, envoyer la requête GET
// avec les paramètres nomSys, ipAdr, note et statut
// La requête GET doit avoir la forme suivante:
// http://esh25.ve2cuy.com/apijesuis.php?jesuis=UN_TEXTE
if (client.connect(server, 80)) {
Serial.println("Connecté au serveur, envoi de la requête GET...");
snprintf(buffer, sizeof(buffer),
"GET /apijesuis.php?jesuis=%s HTTP/1.1",
urlEncode(messages[0]).c_str());
Serial.println(buffer);
client.println(buffer);
client.println("Host: esh25.ve2cuy.com");
client.println();
}
} // sendInfoTOWebAPI()
void printWifiStatus()
{
Serial.print("SSID: ");
Serial.println(WiFi.SSID());
IPAddress ip = WiFi.localIP();
Serial.print("Adresse IP:");
Serial.println(ip);
long rssi = WiFi.RSSI();
Serial.print("Force du signal Wifi (RSSI):");
Serial.print(rssi);
Serial.println(" dBm");
}