Tutoriel - STM32_WifiESP

1. Introduction

STM32_WifiESP est une librairie C pour STM32 permettant de piloter un module ESP01 (ESP8266 en mode AT) via USART DMA. Elle gère la connexion WiFi, le serveur web HTTP, le routage des requêtes et propose une API simple pour répondre à des requêtes GET/POST.

2. Architecture détaillée du driver STM32_WifiESP

Le driver STM32_WifiESP est conçu pour offrir une abstraction claire et modulaire de la gestion du module ESP01 (ESP8266 en mode AT) sur STM32. Il se compose de plusieurs modules spécialisés :

• STM32_WifiESP.h/.c : Cœur du driver. Il gère la communication USART (DMA), l’envoi de commandes AT, la gestion du buffer circulaire, le reset matériel/logiciel du module, le débogage, et propose des fonctions utilitaires génériques.
  Utilisation : toujours inclure ce module, il centralise l’initialisation et la gestion bas niveau du module ESP01.
• STM32_WifiESP_WIFI.h/.c : Module dédié aux fonctions WiFi haut niveau : scan des réseaux, connexion/déconnexion, gestion DHCP, récupération de l’adresse IP, du RSSI, du hostname, ping, etc.
  Utilisation : pour toute gestion réseau, connexion à un AP, diagnostic WiFi.
• STM32_WifiESP_HTTP.h/.c : Implémente un serveur web embarqué. Il gère le parsing des requêtes HTTP, le routage multi-pages, la gestion des connexions, et la génération de réponses HTML/JSON.
  Utilisation : pour exposer une interface web, contrôler le STM32 à distance, afficher des pages dynamiques.
• STM32_WifiESP_MQTT.h/.c : Client MQTT complet : connexion à un broker, publication de messages, abonnement à des topics, gestion des callbacks, ping, etc.
  Utilisation : pour l’IoT, la communication temps réel avec des serveurs/brokers MQTT.
• STM32_WifiESP_NTP.h/.c : Gestion de la synchronisation horaire via NTP : configuration du serveur, récupération de la date/heure, gestion du fuseau horaire et du passage à l’heure d’été/hiver (DST).
  Utilisation : pour horodater des données, synchroniser des événements, afficher l’heure exacte.

Organisation et indépendance

Chaque module possède son propre header (.h) et fichier source (.c). Ils sont pensés pour être utilisés indépendamment :
– Vous pouvez n’inclure que les modules nécessaires à votre application (par exemple, uniquement HTTP et WIFI pour un serveur web, ou MQTT pour de l’IoT).
– Le module principal (STM32_WifiESP) reste obligatoire, car il fournit l’initialisation, la gestion USART/DMA et les fonctions de base.

Exemple d’utilisation typique

1. Initialisation : Appel à esp01_init() pour initialiser le driver avec l’USART, le DMA et les buffers.
2. Connexion WiFi : Utilisation des fonctions du module WIFI pour se connecter à un réseau.
3. Serveur web ou MQTT : Démarrage du serveur HTTP ou du client MQTT selon le besoin.
4. Ajout de routes ou de callbacks : Ajout de routes HTTP personnalisées ou de callbacks MQTT pour gérer les interactions.

Points forts du driver

• Modularité : chaque fonctionnalité est isolée dans un module dédié.
• Robustesse : gestion avancée du DMA, des erreurs USART, et du reset du module ESP01.
• Simplicité d’intégration : API claire, exemples fournis, gestion transparente des buffers et des commandes AT.
• Extensible : possibilité d’ajouter facilement de nouveaux handlers HTTP ou des fonctionnalités MQTT/NTP.

3. Prérequis et compatibilité

4. Configuration de la communication avec l'ESP01

Pour utiliser le module ESP01, il faut configurer l'USART et le DMA dans STM32CubeMX (fichier .ioc).

Voici les paramètres recommandés pour l'USART :

Si on souhaite modifier les pins par défaut de l'USART, il faut le faire avant d'activé l'USART dans CubeMX.

On active ensuite l'USART dans CubeMX, on laisse les paramètres par défaut.

• Baudrate : 115200
• Data bits : 8
• Stop bits : 1
• Parity : None
• Flow control : None

Pour le DMA, on configure l'USART1 RX avec les paramètres suivants :

• DMA Request : RX
• Mode : Circular
• Data width : Byte
• Priority : Medium
• Direction : Peripheral to Memory

5. Fichiers de la librairie

• STM32_WifiESP.h/.c : Driver bas niveau (USART, AT, debug, reset, helpers génériques)
• STM32_WifiESP_WIFI.h/.c : Fonctions WiFi haut niveau (scan, connexion, DHCP, IP, etc.)
• STM32_WifiESP_HTTP.h/.c : Serveur web HTTP, parsing, routage, réponses
• STM32_WifiESP_MQTT.h/.c : Client MQTT (connexion, publish, subscribe, callback)
• STM32_WifiESP_NTP.h/.c : Synchronisation NTP, gestion date/heure

N'oubliez pas d'adapter l'inclusion HAL dans STM32_WifiESP.h si besoin (#include "stm32l0xx_hal.h" ou autre selon votre série).

6. Installation et Intégration

1. Créez un dossier nommé STM32_WifiESP dans le répertoire Drivers de votre projet STM32 et copiez-y les fichiers STM32_WifiESP.h et STM32_WifiESP.c.
2. Ajoutez les chemins d'inclusion : dans les propriétés de votre projet STM32CubeIDE, dans C/C++ General, > Paths and Symbols > Onglet Includes, dans GNU ajoutez le chemin vers le dossier STM32_WifiESP.

N'oublier pas d'activer le float dans les propriétés du projet pour afficher le nombres flottants dans le printf et scanf si besoin.

7. Fonctionnalités par module

• Bas niveau : Initialisation, reset, logs, gestion du buffer DMA, envoi de commandes AT, helpers de parsing et conversion.
• WiFi : Scan réseaux, connexion/déconnexion, DHCP, IP, MAC, RSSI, hostname, ping, état TCP/IP.
• HTTP : Serveur web multi-route, parsing requêtes, routage, réponses HTML/JSON, statistiques, gestion des connexions.
• MQTT : Connexion broker, publication, abonnement, ping, callback messages, gestion du client MQTT.
• NTP : Configuration serveur NTP, synchronisation automatique, parsing date/heure, gestion DST.

8. Debug et bonnes pratiques

• Activez #define ESP01_DEBUG 1 dans STM32_WifiESP.h pour les logs USART
• Libérez toujours les buffers alloués par esp01_send_raw_command_dma (sauf si la fonction s’en occupe déjà)
• Utilisez les fonctions de parsing fournies pour éviter les erreurs de formatage
• Testez les fonctions de base avant d’intégrer des fonctionnalités avancées

9. Exemples et tests fournis

• Test_Driver.c : Test des fonctions bas niveau (AT, reset, logs, RAM, etc.).
• Test_Module_WIFI.c : Test complet des fonctions WiFi.
• Test_Serveur_WEB.c : Démonstration serveur web multi-route.
• Test_Send_MQTT.c : Publication MQTT.
• Test_Receive_MQTT.c : Réception MQTT (abonnement/callback).
• Test_NTP.c : Synchronisation NTP.
• Test_Terminal AT.c : Terminal AT interactif.

10. Liste des fonctions utilisateurs du cœur du driver

10.1. Fonctions principales (initialisation, gestion du module, buffer, etc.)

                            
/**
 * @brief  Initialise le driver ESP01 (UART, DMA, buffers, test communication).
 * @param  huart_esp   UART utilisé pour l'ESP01
 * @param  huart_debug UART pour debug (logs)
 * @param  dma_rx_buf  Buffer DMA RX
 * @param  dma_buf_size Taille du buffer DMA
 * @retval ESP01_Status_t Code de statut (OK, erreur, etc.)
 */
esp01_init(UART_HandleTypeDef *huart_esp, UART_HandleTypeDef *huart_debug, uint8_t *dma_rx_buf, uint16_t dma_buf_size);
                            
                        

/**
 * @brief  Vide le buffer RX UART (DMA).
 * @param  timeout_ms Timeout en ms
 * @retval ESP01_Status_t
 */
esp01_flush_rx_buffer(uint32_t timeout_ms);

/**
 * @brief  Envoie une commande AT brute via DMA et attend un motif.
 * @param  cmd         Commande AT à envoyer
 * @param  resp        Buffer de réponse
 * @param  resp_size   Taille du buffer réponse
 * @param  wait_pattern Motif à attendre dans la réponse
 * @param  timeout_ms  Timeout en ms
 * @retval ESP01_Status_t
 */
esp01_send_raw_command_dma(const char *cmd, char *resp, size_t resp_size, const char *wait_pattern, uint32_t timeout_ms);

10.2. Wrappers exposant une commande AT à l’utilisateur (et helpers associés)

10.3. Terminal / console AT

• void esp01_terminal_begin(UART_HandleTypeDef *huart_debug);
• void esp01_console_rx_callback(UART_HandleTypeDef *huart);
• void esp01_console_task(void);

10.4. Helpers (conversion, affichage, formatage humain)

• char *esp01_format_size(size_t bytes, char *output, size_t size);

10.5. Outils de parsing

• ESP01_Status_t esp01_parse_int_after(const char *text, const char *pattern, int32_t *result);
• ESP01_Status_t esp01_parse_string_after(const char *text, const char *pattern, char *output, size_t size);
• bool esp01_extract_quoted_value(const char *src, const char *motif, char *out, size_t out_len);
• ESP01_Status_t esp01_parse_bool_after(const char *resp, const char *tag, bool *out);
• uint8_t esp01_split_response_lines(const char *input_str, char *lines[], uint8_t max_lines, char *lines_buffer, size_t buffer_size, bool skip_empty);

10.6. Outils utilitaires (buffer, inline, validation)

• const char *esp01_get_error_string(ESP01_Status_t status);
• ESP01_Status_t esp01_wait_for_pattern(const char *pattern, uint32_t timeout_ms);
• void _esp_trim_string(char *str);
• static inline ESP01_Status_t esp01_safe_strcpy(char *dst, size_t dst_size, const char *src);
• static inline ESP01_Status_t esp01_check_buffer_size(size_t needed, size_t avail);
• static inline bool esp01_is_valid_ptr(const void *ptr);
• static inline ESP01_Status_t esp01_safe_strcat(char *dst, size_t dst_size, const char *src);