CodeCell : télécommande Wi-Fi

Dans ce guide, nous découvrirons comment configurer l'ESP32-C3 du CodeCell pour qu'il soit utilisé comme télécommande WiFi, communiquant entre deux appareils.

L'ESP32-C3 de CodeCell est doté d'une fonction Wi-Fi, ce qui lui permet de communiquer sans fil. Grâce à ESP-NOW, nous pouvons établir une communication directe entre appareils avec une configuration minimale. Ce guide vous montrera comment associer deux appareils, en utilisant l'un comme télécommande basée sur un capteur et l'autre pour recevoir et agir sur les données transmises.

Ce que vous apprendrez

Comment configurer deux appareils CodeCell pour la communication à l'aide du WiFi et du protocole ESP-NOW.
Comment utiliser un CodeCell pour contrôler la LED embarquée d'un autre appareil à l'aide de la détection de proximité.
Comment envoyer des lectures angulaires d'un appareil CodeCell à un autre, en ajustant la vitesse du moteur en conséquence.

Aperçu du projet

Dans cet exemple, nous allons associer deux appareils CodeCell . L'appareil 1 collectera les données du capteur et les enverra à l'appareil 2 via le Wi-Fi à l'aide du protocole ESP-NOW. Nous commencerons par une configuration simple où le capteur de proximité de l'appareil 1 contrôle la LED intégrée de l'appareil 2. Dans le deuxième exemple, l'appareil 1 enverra des données angulaires et l'appareil 2 traitera les données pour ajuster les vitesses du moteur.

Obtenir l'adresse MAC du récepteur

Avant de pouvoir établir une communication entre les deux appareils CodeCell , vous devez d'abord obtenir l'adresse MAC du récepteur. Cette adresse MAC sera utilisée dans le code de l'expéditeur pour garantir que le bon appareil reçoit les données.

Suivez ces étapes pour obtenir l’adresse MAC du récepteur :

Tout d'abord, téléchargez le code du récepteur ( Appareil 2 ) sur votre CodeCell. Cela initialise le Wifi et imprime son adresse MAC unique sur le moniteur série.
Après avoir téléchargé le code sur l'appareil 2, ouvrez le moniteur série de l'Arduino. Vous devriez voir l'adresse MAC imprimée une fois l'appareil initialisé.
L'adresse MAC sera imprimée au format XX:XX:XX:XX:XX:XX . Copiez cette adresse, car vous en aurez besoin pour le code de l'expéditeur.
Remplacez l'adresse MAC de l'espace réservé dans le code de l'expéditeur (appareil 1) par l'adresse MAC que vous venez d'obtenir à partir de l'appareil 2. Cela garantira que l'appareil 1 envoie les données au bon récepteur.

Exemple 1 : Contrôle de la LED à distance avec détection de proximité

Cet exemple montre comment envoyer des données de capteur de proximité de l'appareil 1 à l'appareil 2, qui utilisera les données pour allumer ou éteindre sa LED intégrée.

Appareil 1 (émetteur)

 
#include <esp_now.h>
 #include <WiFi.h>
 #include <CodeCell.h>

 CodeCell myCodeCell;
 uint8_t receiverMAC[] = { 0xXX, 0xXX, 0xXX, 0xXX, 0xXX, 0xXX }; // Replace with receiver's MAC address

 void setup() {
 Serial.begin(115200);
 myCodeCell.Init(LIGHT); // Initializes Light Sensing

 // Initialize WiFi in Station mode
 WiFi.mode(WIFI_STA);
 Serial.println(WiFi.macAddress());

 // Initialize ESP-NOW
 if (esp_now_init() != ESP_OK) {
 Serial.println("Error initializing ESP-NOW");
 return;
 }

 // Register peer
 esp_now_peer_info_t peerInfo;
 memcpy(peerInfo.peer_addr, receiverMAC, 6);
 peerInfo.channel = 0;
 peerInfo.encrypt = false;

 if (esp_now_add_peer(&peerInfo) != ESP_OK) {
 Serial.println("Failed to add peer");
 return;
 }
 }

 void loop() { 
si (myCodeCell.Run()) {
 uint16_t ProxRead = (myCodeCell.Light_ProximityRead()) >> 4; // Obtenir la valeur de proximité et diviser par 16
 Série.println(ProxRead);
 résultat esp_err_t = esp_now_send(récepteurMAC, (uint8_t *)&ProxRead, sizeof(ProxRead));

 si (résultat == ESP_OK) {
 Serial.println("Données envoyées avec succès");
 } autre {
 Serial.println("Erreur d'envoi");
 }
 }
 }

Appareil 2 (récepteur)

 
#include <esp_now.h>
 #include <WiFi.h>
 #include <CodeCell.h>

 CodeCell myCodeCell;

 void setup() {
 Serial.begin(115200);
 myCodeCell.Init(LIGHT); // Initializes Light Sensing

 // Initialize WiFi in Station mode
 WiFi.mode(WIFI_STA);
 Serial.println(WiFi.macAddress());

 // Initialize ESP-NOW
 if (esp_now_init() != ESP_OK) {
 Serial.println("Error initializing ESP-NOW");
 return;
 }

 // Register the receive callback
 esp_now_register_recv_cb(onDataRecv);
 }

 // Receive callback function 
void onDataRecv(const esp_now_recv_info *recvInfo, const uint8_t *incomingData, int len) {
 uint16_t Valeur_distante;
 memcpy(&Valeur_à_distance, données_entrantes, sizeof(Valeur_à_distance));
 Serial.println(Valeur_à_distance);
 myCodeCell.LED(0, Remote_Value, 0); // Contrôle la luminosité de la LED intégrée
 }

 boucle vide() {
 // Rien à faire ici
 }

Exemple 2 : Envoi de données angulaires pour contrôler la vitesse du moteur

Dans ce deuxième exemple, nous connectons deux moteurs avec deux DriveCells au récepteur. L'appareil 1 lit les données angulaires de ses capteurs de mouvement et les envoie à l'appareil 2, qui ajuste la vitesse de deux moteurs en fonction des données reçues.

Si vous utilisez des appareils différents pour cet exemple, n'oubliez pas de lire la nouvelle adresse MAC du récepteur et de remplacer l'adresse MAC réservée dans le code de l'expéditeur.

Appareil 1 (émetteur)

 
#include <esp_now.h>
 #include <WiFi.h>
 #include <CodeCell.h>
 
CodeCell monCodeCell;
 uint8_t receiverMAC[] = {0xXX, 0xXX, 0xXX, 0xXX, 0xXX, 0xXX}; // Remplacer par l'adresse MAC du récepteur
 int Roll_Control = 0;

 flotteur Rouleau = 0,0;
 float Pas = 0,0 ;
 flotteur Lacet = 0,0;

 configuration vide() {
 Série.begin(115200);
 myCodeCell.Init(MOTION_ROTATION); // Initialiser la détection de mouvement

 // Initialiser le WiFi en mode Station
 mode.WiFi(WIFI_STA);
 Série.println(WiFi.macAddress());

 // Initialiser ESP-NOW
 si (esp_now_init() != ESP_OK) {
 Serial.println("Erreur lors de l'initialisation d'ESP-NOW");
 retour;
 }

 // Enregistrer un pair
 esp_now_peer_info_t peerInfo;
 memcpy(peerInfo.peer_addr, récepteurMAC, 6);
 peerInfo.channel = 0;
 peerInfo.encrypt = faux;

 si (esp_now_add_peer(&peerInfo) != ESP_OK) {
 Serial.println("Échec de l'ajout d'un homologue");
 retour;
 }
 }

 boucle vide() {
 si (myCodeCell.Run()) {
 myCodeCell.Motion_RotationRead(Roll, Pitch, Yaw);

 Jet = Jet + 180 ;
 Lancer = (lancer * 100) / 180 ;
 Roll = contraindre(Roll, 0, 200) / 2;
 Roll_Control = (uint8_t)Rouler;

 Série.println(Roll_Control); 
esp_now_send(récepteurMAC, (uint8_t *)&Roll_Control, sizeof(Roll_Control));
 }
 }

Appareil 2 (récepteur)

 
#include <esp_now.h>
 #include <WiFi.h>
 #include <CodeCell.h>
 #include <DriveCell.h>

 #define IN1_pin1 2
 #define IN1_pin2 3
 #define IN2_pin1 5
 #define IN2_pin2 6

 CodeCell myCodeCell;
 DriveCell Motor1(IN1_pin1, IN1_pin2);
 DriveCell Motor2(IN2_pin1, IN2_pin2);

 void setup() {
 Serial.begin(115200);
 myCodeCell.Init(LIGHT); // Initialize Light Sensing
 Motor1.Init();
 Motor2.Init();

 // Initialize WiFi in Station mode
 WiFi.mode(WIFI_STA);
 Serial.println(WiFi.macAddress());

 // Initialize ESP-NOW
 if (esp_now_init() != ESP_OK) {
 Serial.println("Error initializing ESP-NOW");
 return;
 }

 // Register the receive callback
 esp_now_register_recv_cb(onDataRecv);
 }

 void onDataRecv(const esp_now_recv_info *recvInfo, const uint8_t *incomingData, int len) {
 int Roll_Speed = 0;
 memcpy(&Roll_Speed, incomingData, sizeof(Roll_Speed));

 if (Roll_Speed > 50) { 
Moteur1.Drive(1, Vitesse_Roll);
 Motor2.Drive(1, Roll_Speed);
 } autre {
 Vitesse_de_roulage = 100 - Vitesse_de_roulage ;
 Motor1.Drive(0, Vitesse_Roll);
 Motor2.Drive(0, Vitesse_Roll);
 }
 Série.println(Roll_Speed);
 }

 boucle vide() {
 si (myCodeCell.Run()) {}
 }

Conclusion

En suivant ces exemples, vous pouvez configurer deux appareils CodeCell pour communiquer via WiFi à l'aide d'ESP-NOW. Les exemples montrent comment envoyer des données de proximité et angulaires entre les appareils et utiliser les données pour le contrôle en temps réel des LED et des moteurs.

N'hésitez pas à développer ces projets en incorporant davantage de capteurs ou de fonctionnalités supplémentaires pour améliorer les fonctionnalités de votre système distant !