CodeCell : Créer une télécommande Wi-Fi

Le moyen le plus simple de connecter CodeCell à une télécommande est d'utiliser notre application Bluetooth MicroLink , qui vous permet d'ajouter rapidement des boutons, des curseurs et un joystick à votre projet. Tout est expliqué ici , mais dans ce guide, nous nous concentrerons sur la configuration de l'ESP32-C3 du CodeCell pour qu'il fonctionne comme une télécommande Wi-Fi, permettant la communication entre deux appareils.

L'ESP32-C3 du CodeCell est doté d'une fonction Wi-Fi, lui permettant de communiquer sans fil. Grâce à ESP-NOW, nous pouvons établir une communication directe entre appareils avec une configuration minimale. Ce guide explique comment appairer deux appareils : l'un comme télécommande à capteurs, l'autre pour recevoir et exploiter les données transmises.

Ce que vous apprendrez

• Comment configurer deux appareils CodeCell pour la communication à l'aide du protocole WiFi et 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 coupler deux appareils CodeCell . L'appareil 1 collectera les données du capteur et les transmettra à l'appareil 2 via Wi-Fi grâce au protocole ESP-NOW. Nous commencerons par une configuration simple où le capteur de proximité de l'appareil 1 contrôlera 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 ces données pour ajuster la vitesse du moteur.

Obtenir l'adresse MAC du récepteur

Avant d'établir la 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 :

1. Tout d'abord, téléchargez le code du récepteur ( Appareil 2 ) sur votre CodeCell. Cela initialise le Wi-Fi et affiche son adresse MAC unique sur le moniteur série.
2. Après avoir téléchargé le code sur l'appareil 2, ouvrez le moniteur série de l'Arduino. L'adresse MAC devrait s'afficher une fois l'appareil initialisé.
3. 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.
4. 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 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 }; // Remplacer par l'adresse MAC du récepteur

 configuration vide() {
 Serial.begin(115200);
 myCodeCell.Init(LIGHT); // Initialise la détection de lumière

 // Initialiser le WiFi en mode Station
 WiFi.mode(WIFI_STA);
 Serial.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, receiverMAC, 6);
 peerInfo.channel = 0;
 peerInfo.encrypt = faux;

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

 boucle vide() {
 si (myCodeCell.Run(10)) {
 uint16_t ProxRead = (myCodeCell.Light_ProximityRead()) >> 4; // Obtenir la valeur de proximité et diviser par 16
 Serial.println(ProxRead);
 résultat esp_err_t = esp_now_send(receiverMAC, (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 Remote_Value;
 memcpy(&Remote_Value, incomingData, sizeof(Remote_Value));
 Serial.println(Remote_Value);
 myCodeCell.LED(0, Remote_Value, 0); // Control onboard LED brightness
 }

 void loop() {
 // Nothing to do here
 }

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

Dans ce deuxième exemple, nous connectons deux moteurs équipés de deux DriveCells au récepteur. L'appareil 1 lit les données angulaires de ses capteurs de mouvement et les transmet à l'appareil 2, qui ajuste la vitesse des 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 de remplacement dans le code de l'expéditeur.

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
 int Roll_Control = 0;

 float Roll = 0.0;
 float Pitch = 0.0;
 float Yaw = 0.0;

 void setup() {
 Serial.begin(115200);
 myCodeCell.Init(MOTION_ROTATION); // Initialize motion sensing

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

 // Initialize 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, receiverMAC, 6);
 peerInfo.channel = 0;
 peerInfo.encrypt = faux;

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

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

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

 Serial.println(Roll_Control);
 esp_now_send(receiverMAC, (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); // Initialiser la détection de lumière
 Moteur1.Init();
 Moteur2.Init();

 // Initialiser le WiFi en mode Station
 WiFi.mode(WIFI_STA);
 Serial.println(WiFi.macAddress());

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

 // Enregistrer le rappel de réception
 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, données entrantes, sizeof(Roll_Speed));

 si (Roll_Speed ​​> 50) {
 Moteur1.Drive(1, Vitesse_Roll);
 Motor2.Drive(1, Roll_Speed);
 } autre {
 Roll_Speed ​​= 100 - Roll_Speed;
 Moteur1.Drive(0, Vitesse_Roll);
 Motor2.Drive(0, Roll_Speed);
 }
 Serial.println(Roll_Speed);
 }

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

En suivant ces exemples, vous pouvez configurer deux appareils CodeCell pour communiquer en Wi-Fi avec ESP-NOW. Ces exemples expliquent comment transmettre des données de proximité et angulaires entre les appareils et exploiter ces données pour contrôler en temps réel les LED et les 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 !