Comment connecter l'ESP32 aux réseaux cellulaires et comprendre les technologies IoT

L'ESP32 est une plateforme de développement extrêmement populaire pour les applications IoT (Internet des objets), principalement en raison de ses capacités de communication sans fil via Wi-Fi et Bluetooth. Cependant, lorsque ces options de connectivité ne sont pas disponibles, par exemple dans des zones reculées ou dans des applications mobiles, l'ESP32 peut se connecter aux réseaux cellulaires comme ceux de 2G, 3G, 4G/LTE et NB-IoT en utilisant des modules cellulaires externes. Cela permet à l'ESP32 d'accéder à Internet et d’échanger des données à travers des réseaux cellulaires, offrant ainsi une solution de communication fiable même dans des environnements où la connectivité Wi-Fi est impraticable.

La communication cellulaire permet à l'ESP32 de se connecter à des services cloud, d’échanger des données avec des serveurs distants et d’assurer une surveillance en temps réel et un contrôle des appareils IoT à distance. L'omniprésence des réseaux cellulaires permet à des appareils basés sur l'ESP32 de rester connectés et opérationnels à travers de vastes régions géographiques, ce qui en fait une technologie clé pour un large éventail d'applications IoT, telles que le suivi d'actifs, l'agriculture intelligente, et les systèmes de surveillance à distance.

Les technologies de réseau cellulaire se sont considérablement améliorées au fil des années, chaque génération apportant des évolutions majeures dans la capacité de transfert de données, la latence et la connectivité.

Les différentes générations des réseaux cellulaires se définissent comme suit :

• 1G : La première génération des réseaux cellulaires était basée sur l'analogique et permettait des communications vocales de base.

• 2G : La deuxième génération a introduit la transmission numérique, permettant l'envoi de SMS et une qualité vocale améliorée.

• 3G : Avec la troisième génération, les vitesses de transfert de données ont été considérablement augmentées, permettant un accès internet basique, la messagerie multimédia, et l’envoi d’e-mails.

• 4G : La quatrième génération, grâce à la technologie LTE, a permis un internet mobile haute vitesse, facilitant le streaming vidéo, les applications mobiles et une expérience Internet améliorée.

• 5G : Enfin, la cinquième génération offre des vitesses ultra-rapides, une latence extrêmement faible, et une connectivité massive pour les appareils. 5G permettra des applications transformantes telles que la réalité augmentée, les villes intelligentes, et les véhicules autonomes.

NB-IoT : Une technologie adaptée aux besoins spécifiques de l'IoT

Parmi les technologies récentes, le NB-IoT (Narrowband Internet of Things) se distingue en offrant une solution dédiée aux besoins uniques des applications IoT. NB-IoT est une technologie de réseau à large couverture et faible consommation d’énergie, optimisée pour les appareils IoT. Cette technologie fonctionne dans le spectre cellulaire autorisé, permettant une communication efficace sur de longues distances avec une faible consommation d’énergie. C’est une technologie de type LPWAN (Low Power Wide Area Network) qui s’intègre parfaitement dans les infrastructures cellulaires existantes et permet une communication avec un nombre massif de dispositifs connectés.

Les caractéristiques clés de NB-IoT incluent :

• Faible consommation d'énergie : NB-IoT est conçu pour des opérations à faible consommation, permettant aux appareils IoT de fonctionner pendant des années sur batterie sans nécessiter de recharges fréquentes.

• Longue portée : NB-IoT offre une couverture étendue, permettant des communications même à travers des obstacles tels que les murs, idéal pour des applications tant urbaines que rurales.

• Transmission étroite : Comme son nom l’indique, NB-IoT utilise une transmission en bande étroite, ce qui optimise la capacité du réseau pour des échanges de petites quantités de données de manière peu fréquente.

• Coût réduit : En utilisant une architecture simplifiée et les infrastructures cellulaires existantes, NB-IoT permet des solutions IoT économiquement accessibles.

• Connectivité massive : NB-IoT peut connecter un grand nombre d'appareils simultanément au sein d’une même cellule, ce qui est un atout pour le développement futur de l'IoT à grande échelle.

Cette technologie est particulièrement adaptée aux applications telles que la surveillance à distance, la gestion des compteurs intelligents, le suivi d'actifs et les applications agricoles, où des dispositifs doivent être déployés sur de vastes zones avec une consommation d’énergie minimale. Grâce à sa compatibilité avec des réseaux cellulaires existants tels que 2G, 3G et 4G/LTE, NB-IoT se présente comme une solution flexible et évolutive pour les déploiements IoT à travers le monde.

Connexion de l'ESP32 à un réseau cellulaire

Prenons l'exemple du module Quectel BG95, un module avancé permettant de connecter l'ESP32 à des réseaux cellulaires 2G, 3G, 4G et LTE-M/NB-IoT. Ce module offre une compatibilité avec la carte ESP32 HUZZAH, permettant une intégration facile en fixant le module directement sur l'ESP32. Un SIM card activée pour 4G est ensuite nécessaire pour accéder au réseau 4G.

Une fois le module connecté, il est nécessaire d’utiliser des commandes AT pour communiquer avec le module BG95. Les commandes AT sont des instructions spécifiques utilisées pour interagir avec les modems et les modules cellulaires. Ces commandes commencent par "AT" et permettent de configurer le module, d’envoyer des signaux et de recevoir des réponses. Par exemple, la commande AT+CGATT=1 permet de connecter le module au service GPRS.

Voici un exemple de code pour envoyer des commandes AT à un module BG95 en utilisant l'IDE Arduino :

cpp
Copy code
#include <SoftwareSerial.h>

SoftwareSerial BG95Serial(2, 3); // RX, TX pins pour le module BG95
const int baudRate = 9600;
void setup() {
  Serial.begin(115200);
  BG95Serial.begin(baudRate);
  delay(1000);
  Serial.println("Initialisation du BG95...");
  sendATCommand("AT");
  sendATCommand("AT+CPIN?");
}
void loop() {
  // Code supplémentaire
}
void sendATCommand(String command) {
  BG95Serial.println(command);
  delay(500);
  while (BG95Serial.available()) {
    Serial.write(BG95Serial.read());
  }
}

Ce code établit une connexion série entre l'ESP32 et le module BG95. Il envoie des commandes AT pour initialiser la connexion au réseau 4G et recevoir des réponses pour vérifier le bon fonctionnement du module.

Points importants à considérer

Lors de l’intégration de la connectivité cellulaire avec l'ESP32, il est crucial de bien comprendre les spécifications et les limitations des différentes technologies cellulaires. Bien que les modules comme NB-IoT offrent des avantages indéniables en termes de faible consommation d’énergie et de couverture étendue, ils peuvent être moins adaptés aux applications nécessitant un large débit de données ou une faible latence, comme les vidéos en temps réel ou les interactions intensives. Il est donc essentiel de choisir la technologie de réseau en fonction des besoins spécifiques de l’application IoT.

Comment connecter les capteurs à l'ESP32 pour un système de location de places de parking

Dans ce projet, nous explorons l’intégration de plusieurs capteurs et actionneurs avec la carte microcontrôleur ESP32. L'objectif est de créer un système de location de places de parking intelligent, capable de mesurer la disponibilité des places, d'interagir avec les utilisateurs via une interface visuelle et de gérer les paiements en ligne de manière sécurisée. La coordination de ces composants doit être parfaite pour assurer une expérience utilisateur fluide et efficace.

Schéma de connexion

Dans ce système, le schéma de connexion est essentiel pour assurer une communication harmonieuse entre tous les composants. L’écran OLED SSD1306 est relié aux broches I2C pour la transmission des données, et alimenté via les broches VCC et GND de l’ESP32, garantissant une stabilité électrique. Le bouton, servant d'élément d'interface utilisateur, est connecté à la broche D5 de l'ESP32 en configuration pull-up. L'LED RGB, de type cathode commune, est connectée aux broches D4 (rouge), D2 (vert) et D15 (bleu), ce qui permet de créer une gamme de signaux visuels pour guider l'utilisateur. Le servomoteur, qui contrôle le mouvement de la barrière, est alimenté par VCC et GND, et contrôlé via la broche D14. Enfin, le capteur ultrason, utilisé pour la mesure de distance, est connecté aux broches D13 (pour le déclencheur) et D12 (pour l’écho), ce qui permet de mesurer les distances avec une grande précision.

Interaction avec le système via le code

Une fois les connexions établies, il est nécessaire de coder l’ESP32 pour lire les distances grâce au capteur ultrason. Le code, qui peut être téléchargé depuis GitHub, utilise la bibliothèque Arduino IDE pour contrôler l’ESP32. Le programme commence par définir les broches pour les différents capteurs et actionneurs. Ensuite, dans la fonction setup(), les broches sont initialisées comme entrées ou sorties selon leur fonction. La boucle loop() exécute en continu la logique principale, en appelant la fonction getdistance() pour mesurer la distance à l'aide du capteur ultrason. Si la distance mesurée est inférieure à une certaine valeur, une LED rouge s'allume pour indiquer qu'une place est occupée, tandis qu'une LED verte s'allume pour signaler une place libre. Ce processus permet de fournir un retour instantané aux utilisateurs et d’assurer la gestion de l’occupation des places.

Code exemple pour lire la distance avec un capteur ultrason

Voici un exemple de code qui lit la distance via le capteur ultrason et modifie la couleur de l'LED RGB en fonction de l'occupation de la place de parking :

cpp
Copy code
const int trigPin = 13;

const int echoPin = 12;
const int redPin = 4;
const int greenPin = 2;
const int bluePin = 15;
int distanceRange = 50;
void setup() {
  Serial.begin(115200);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}
void loop() {
  int distance = getdistance();
  delay(1000);
}
int getdistance() {
  long duration;
  int distance;
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = (duration / 2) / 29.1;
  Serial.println("Distance: " + String(distance));
  if (distance > distanceRange) {
    digitalWrite(redPin, LOW);
    digitalWrite(greenPin, HIGH);
  } else {
    digitalWrite(greenPin, LOW);
    digitalWrite(redPin, HIGH);
  }
  return distance;
}

Éléments supplémentaires à prendre en compte

Le système de location de places de parking nécessite non seulement une intégration technique parfaite, mais aussi une interface utilisateur fluide et sécurisée. Le retour visuel des LED RGB et de l'écran OLED doit être intuitif et rapide pour que l'utilisateur puisse comprendre immédiatement si la place de parking est libre ou occupée. De plus, il est crucial de bien gérer les délais de lecture du capteur ultrason afin de garantir des mesures précises et de réagir rapidement aux changements d'état des places.

Un autre aspect à ne pas négliger est la sécurité des transactions. Bien que l’interface physique soit essentielle pour l'interaction locale avec le système, la gestion des paiements via la plateforme PayPal doit être implémentée de manière sécurisée et fiable. Assurez-vous que les données de paiement soient bien protégées et que le système soit résilient face aux erreurs de communication ou aux tentatives de fraude.

Comment passer de l'IDE Arduino à un développement avancé de l'IoT avec ESP32 ?

La puissance de l'ESP-IDF

Dans les premiers chapitres de ce livre, nous avons mentionné les deux principaux outils de développement pour l’ESP32 : le cœur Arduino ESP32 et l’ESP-IDF. Le cœur Arduino, bien qu’étant plus accessible pour les débutants, ne permet pas de tirer parti de l'ensemble des fonctionnalités de l’ESP32. Pour exploiter pleinement les capacités de cette puce, il est préférable de se tourner vers l'ESP-IDF, un cadre de développement beaucoup plus puissant.

L'ESP-IDF (Espressif IoT Development Framework) est le framework officiel pour le développement sur ESP32. Il fournit une vaste collection de bibliothèques, d'outils et d'API, tous spécifiquement conçus pour faciliter le développement d'applications IoT robustes. Ce framework offre de nombreux avantages par rapport au cœur Arduino, en particulier dans la prise en charge de la connectivité avancée, la gestion des périphériques et l'optimisation des performances.

L'un des atouts majeurs de l'ESP-IDF est sa compatibilité native avec les langages de programmation C et C++. Grâce à cela, le développement d'applications IoT peut être plus performant et plus flexible. Contrairement à l’IDE Arduino, qui limite certaines fonctionnalités de C/C++, l’ESP-IDF permet une gestion fine des ressources, un accès direct au matériel et des mises à jour de firmware plus rapides. L’ESP-IDF offre aussi un meilleur support pour les mises à jour OTA (over-the-air) et la sécurité, essentielles pour le développement de dispositifs IoT connectés et évolutifs.

ESP-IDF vs cœur Arduino ESP32

Lorsque vous choisissez entre l’ESP-IDF et le cœur Arduino ESP32, il est important de considérer plusieurs éléments. D’un côté, l’IDE Arduino est extrêmement populaire et facile à utiliser, surtout pour les débutants. Cependant, il n'offre pas la profondeur de contrôle ou la flexibilité qu’offre l’ESP-IDF. Par exemple, l’ESP-IDF gère mieux les processeurs multicœurs, offre un support natif pour FreeRTOS et permet une gestion plus précise de la mémoire et du débogage.

L’ESP-IDF prend en charge toutes les dernières versions du matériel ESP32, assurant une compatibilité optimale avec les nouvelles fonctionnalités des puces. Par ailleurs, l'ESP-IDF propose une gestion plus efficace des mises à jour OTA, rendant l'intégration de nouvelles versions logicielles plus fluide et plus rapide.

L’utilisation des systèmes d’exploitation temps réel (RTOS)

Un aspect fondamental du développement avancé avec l’ESP32 est l’utilisation des systèmes d’exploitation temps réel (RTOS), dont FreeRTOS est un exemple couramment utilisé dans l’ESP-IDF. Un RTOS est essentiel pour gérer des tâches avec des contraintes de temps strictes, ce qui est crucial dans des applications comme la robotique, les systèmes de contrôle industriel ou toute autre application nécessitant une exécution précise et prévisible des tâches.

Dans un cadre traditionnel comme celui de la boucle principale (super loop) que nous avons abordée dans ce livre, les tâches sont exécutées de manière séquentielle, ce qui limite les possibilités de gestion concurrente. En revanche, avec un RTOS, il est possible d’exécuter plusieurs tâches en parallèle, permettant une meilleure gestion du temps et des ressources, surtout sur des processeurs multicœurs comme l’ESP32.

FreeRTOS et ses applications dans l'ESP32

FreeRTOS est un noyau RTOS open source, très léger et adapté à l’ESP32. Il est conçu pour optimiser l’exécution de tâches indépendantes et garantir un comportement prévisible dans des systèmes embarqués. L'intégration de FreeRTOS dans l'ESP-IDF permet de tirer parti du multitâche symétrique sur des architectures multicœurs. Cela signifie que, dans le cas d’un ESP32, vous pouvez distribuer les tâches entre les deux cœurs du processeur pour maximiser l'efficacité de votre application IoT.

L’utilisation de FreeRTOS avec l'IDE Arduino est également possible, bien que son support y soit limité. Il est donc recommandé de se tourner vers l’ESP-IDF pour profiter pleinement des capacités de FreeRTOS. FreeRTOS permet ainsi de gérer des processus tels que la gestion de la communication série, les capteurs, ou encore les interfaces réseau, de manière entièrement parallèle, offrant un contrôle total sur la gestion des ressources et la synchronisation des tâches.

PlatformIO : une alternative à l’IDE Arduino

En plus de l’IDE Arduino, PlatformIO représente une alternative puissante pour les développeurs qui souhaitent utiliser l’ESP32 dans un environnement plus flexible et riche en fonctionnalités. PlatformIO est un environnement de développement intégré (IDE) qui prend en charge plusieurs plates-formes et langages de programmation, et est particulièrement apprécié pour sa gestion avancée des bibliothèques et sa compatibilité avec divers frameworks comme l’ESP-IDF.

PlatformIO permet d'intégrer facilement des fonctionnalités avancées, comme la gestion des versions, les tests unitaires, la gestion des dépendances, et même le déploiement sur des systèmes de production. Son utilisation peut simplifier de nombreux aspects du développement, tout en offrant plus de contrôle sur les processus de construction et de déploiement.

Conclusion

L'ESP32, bien que largement utilisé avec l'IDE Arduino pour des applications simples, trouve sa véritable puissance dans l’utilisation d’ESP-IDF et de FreeRTOS. Ces outils offrent des possibilités avancées pour développer des systèmes IoT complexes, optimisés et fiables. Le passage à l’ESP-IDF et à FreeRTOS représente un investissement en temps pour apprendre à gérer les systèmes embarqués à un niveau plus profond, mais il offre des avantages considérables en termes de flexibilité, de contrôle et de performance.

Il est important de noter que l’adoption d’une plateforme comme ESP-IDF nécessite une meilleure compréhension des concepts de programmation bas niveau et de gestion de la mémoire. La connaissance de FreeRTOS et de la gestion des tâches est cruciale pour le développement de systèmes réactifs et performants. En parallèle, l’utilisation de PlatformIO peut offrir une interface plus moderne et flexible pour gérer des projets plus complexes.

Comment maîtriser l'interface ESP32 et ses diverses applications dans les systèmes embarqués ?

Le ESP32 est un microcontrôleur extrêmement polyvalent et puissant qui offre une large gamme de fonctionnalités adaptées à des projets variés. Pour exploiter pleinement ce potentiel, il est essentiel de bien comprendre comment interagir avec ses broches GPIO (General Purpose Input/Output), ainsi que les différentes techniques permettant de manipuler des capteurs, des actionneurs et de gérer des communications série efficaces.

Cet exemple de contrôle d'entrée-sortie est fondamental pour comprendre les bases de l'interaction avec les périphériques externes via les GPIO. En utilisant la configuration de résistance de tirage interne (pull-up), nous évitons les lectures erronées dues à des entrées flottantes, un problème courant dans les circuits numériques.

Une fois que l’on maîtrise cette technique, il est intéressant de passer à une méthode plus avancée : la modulation de largeur d'impulsion (PWM). Le PWM permet de contrôler l'intensité moyenne d'un signal, ce qui est particulièrement utile pour la gestion de la luminosité des LEDs ou la vitesse de rotation des moteurs. En ajustant le rapport cyclique du signal, on modifie la durée pendant laquelle le signal est actif par rapport à sa période totale, ce qui donne l'effet de variation d'intensité ou de vitesse.

Dans l'exemple de la LED PWM, on commence par connecter l'anode de la LED à une broche GPIO et l'autre extrémité à la masse via une résistance pour protéger la LED d'un courant excessif. En utilisant un programme Arduino pour générer un signal PWM, le rapport cyclique de la LED varie progressivement, créant ainsi un effet de fondu, allant de l'extinction totale à l'intensité maximale de la LED. Cela peut être implémenté avec une simple boucle qui augmente progressivement la valeur du rapport cyclique de 0 à 255, où 0 représente un signal éteint et 255 représente un signal complètement allumé.

Une autre caractéristique fondamentale du ESP32 est la communication série asynchrone via UART (Universal Asynchronous Receiver-Transmitter). UART est un protocole simple et largement utilisé dans les systèmes embarqués pour la communication entre dispositifs. Il fonctionne sans signal d'horloge, ce qui simplifie la conception du matériel et réduit la consommation d'énergie. Cependant, cela peut engendrer des problèmes de synchronisation entre l'émetteur et le récepteur, ce qui nécessite l'ajout de bits de début et de fin pour délimiter les données. Malgré cette limitation, UART reste un choix privilégié pour les applications nécessitant des débits de données modérés et des distances de communication relativement courtes.

Il est essentiel de maîtriser UART pour assurer une communication fluide et efficace entre les microcontrôleurs, notamment dans des applications telles que l'échange de données entre le ESP32 et d'autres périphériques ou systèmes.

En complément des bases de l'ESP32 et de la gestion des entrées/sorties, il est crucial de comprendre la manière dont ces composants s'intègrent dans des systèmes plus complexes, notamment en ce qui concerne la gestion des interruptions, la synchronisation des tâches, et l'optimisation de la consommation d'énergie. L'ESP32, avec sa puissance de calcul et ses capacités de communication, offre de nombreuses possibilités pour la création de dispositifs embarqués connectés, mais il est important de bien comprendre le fonctionnement interne du système pour éviter des erreurs de conception.

Comment fonctionne le protocole UART et comment l'utiliser avec l'ESP32

Fonctionnement du protocole UART

Dans un système utilisant le protocole UART, deux fils principaux sont utilisés pour la transmission et la réception des données : le fil Rx (réception) et le fil Tx (transmission). Lorsque des données sont envoyées via UART, elles sont organisées dans un format bien défini. Ce format inclut un bit de départ, les bits de données (généralement 8 bits), un bit de parité facultatif pour la détection d’erreurs, et un ou plusieurs bits d'arrêt.

Le bit de départ, toujours à l'état bas (0), marque le début de la trame de données. Ensuite, les bits de données représentent l'information à transmettre. Le bit de parité, lorsqu'il est utilisé, permet d’effectuer une vérification d'erreur en ajoutant un bit supplémentaire (pair ou impair) afin que le nombre total de bits (y compris la parité) soit soit pair, soit impair. Si le bit de parité ne correspond pas à la valeur attendue, une erreur est détectée, ce qui permet une détection basique des erreurs dans la transmission.

Les bits d'arrêt, habituellement à l'état haut (1), signalent la fin de la trame de données. Le taux de transmission des données, appelé débit en bauds (baud rate), détermine la vitesse à laquelle les données sont envoyées, généralement mesurée en bits par seconde (bps). Les vitesses courantes incluent 9600, 115200 et 921600 bps.

Communication UART entre deux modules ESP32

Pour établir une communication UART entre deux modules ESP32, il suffit de connecter les broches Tx et Rx des deux dispositifs. Le Rx du premier ESP32 doit être relié au Tx du second ESP32, et inversement, afin de permettre l'échange bidirectionnel des données. Une connexion à la masse (GND) des deux ESP32 est également nécessaire pour compléter le circuit.

Exemple de code pour l'envoi de données via UART

cpp
Copy code
void setup() {
  // Initialiser la communication série à 9600 bauds
  Serial.begin(9600);
}
void loop() {
  // Envoyer la chaîne "IoT" sur le port série
  Serial.println("IoT");
  // Attendre 1 seconde avant d'envoyer à nouveau
  delay(1000);
}

Une fois ce code téléchargé dans le premier ESP32, vous pourrez observer la sortie sur le moniteur série en sélectionnant le port COM correspondant et en définissant le débit en bauds sur 9600.

De l'autre côté, le second ESP32 doit être programmé pour recevoir et afficher les données envoyées. Le code pour cela est le suivant :

cpp
Copy code
void setup() {

  // Initialiser la communication série à 9600 bauds
  Serial.begin(9600);
}
void loop() {
  if (Serial.available() > 0) {
    // Si des données sont disponibles, les lire
    String receivedData = Serial.readString();
    // Afficher les données reçues
    Serial.print("Données reçues : ");
    Serial.println(receivedData);
  }
}

En téléchargeant ce programme dans le second ESP32 et en le connectant correctement selon le schéma de câblage, vous pourrez voir les données reçues ("IoT") apparaître dans le moniteur série du second module.

Capteurs utilisant le protocole UART

De nombreux capteurs et modules peuvent être facilement intégrés avec l'ESP32 grâce à la communication UART. Voici quelques exemples de capteurs qui utilisent ce protocole :

• Modules GPS : De nombreux modules GPS, comme le ublox NEO 6m ou le NEO 7m, utilisent UART pour envoyer des données de localisation à l'ESP32. Ces modules sont particulièrement utiles dans les applications de navigation ou de suivi en temps réel.

• Lecteurs RFID : Des modules comme le MFRC522 ou le PN532 utilisent UART pour communiquer avec des microcontrôleurs, permettant de lire des cartes RFID. L’ESP32 peut être utilisé pour intégrer cette fonctionnalité de manière efficace.

• Modules Bluetooth : Certains modules Bluetooth classiques, tels que les HC-05 et HC-06, utilisent UART pour établir une connexion sans fil. Toutefois, il est important de noter que l'ESP32 dispose déjà de capacités Bluetooth natives, ce qui en fait une solution encore plus puissante pour les applications sans fil.

Conclusion

Le protocole UART est une méthode de communication simple et efficace qui permet aux modules ESP32 d’échanger des données de manière fiable et rapide. L’utilisation de ce protocole avec Arduino IDE facilite grandement la gestion des trames de données, en automatisant la conversion des chaînes de caractères en format UART et en simplifiant ainsi la communication entre deux dispositifs. De plus, le fait que de nombreux capteurs populaires, tels que les modules GPS et RFID, utilisent UART, fait de l'ESP32 une plateforme idéale pour une grande variété d'applications IoT.