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.

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 :

1. 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.
2. 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é.
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 à 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 !

Dans cette version, nous allons découvrir comment configurer l'ESP32-C3 du CodeCell pour utiliser l'IA Gemini de Google pour les interactions basées sur des invites Arduino. Vous apprendrez comment envoyer une invite via le moniteur série et, dans un deuxième exemple, comment le CodeCell peut déclencher automatiquement une blague en fonction de la détection de proximité. Ce projet est idéal pour tous ceux qui cherchent à ajouter des capacités d'IA à leurs projets IoT.

Ce que vous apprendrez

• Comment configurer le CodeCell pour les interactions basées sur des invites d'IA via l'ESP32-C3.
• Comment envoyer des invites à Gemini AI à l'aide de l'IDE Arduino et du moniteur série.
• Comment utiliser le capteur de proximité de CodeCell pour déclencher une blague automatiquement.

À propos de CodeCell et de Google Gemini

Dans cet exemple, nous utilisons le modèle Gemini de Google pour générer du contenu en fonction des entrées utilisateur ou des données de capteur. Tout au long de ce tutoriel, nous utiliserons et modifierons l' exemple de code créé par « techiesms » - Regardez le tutoriel complet ici.

Grâce aux capacités Wi-Fi de l'ESP32-C3, vous pouvez effectuer des requêtes HTTP vers l'API Gemini de Google, ce qui permet une interaction en temps réel avec l'IA. Que vous demandiez des réponses textuelles ou que vous génériez des résultats créatifs comme des blagues, cette intégration est simple à mettre en œuvre.

Aperçu du projet

Dans le premier exemple, vous enverrez des invites directement via le moniteur série, et le CodeCell enverra cette entrée à l'IA Google Gemini pour traitement. La réponse de l'IA est imprimée sur le moniteur série, limitée par 100 jetons. Dans le deuxième exemple, le capteur de proximité du CodeCell déclenchera une invite à l'IA, lui demandant de générer une blague lorsqu'il détectera un objet. Cette configuration peut être utilisée pour des projets interactifs amusants où l'appareil répond à son environnement à l'aide de contenu basé sur l'IA.

Comment obtenir la clé API Gemini

Avant d'intégrer l'IA Gemini dans notre configuration ESP32-C3, nous devons d'abord générer une clé API et la tester. Suivez les étapes ci-dessous pour créer votre clé API, puis vous pouvez également la tester à l'aide d'un logiciel comme Postman.

Étape 1 : Génération de la clé API pour Google Gemini

1. Ouvrez votre navigateur et recherchez l' API Gemini
2. Cliquez sur le premier résultat qui apparaît. Cela vous amènera à la page de documentation de l'API de Google.
3. Ensuite, cliquez sur le bouton « Obtenir la clé API dans Google AI Studio », puis cliquez sur « Créer une clé API ».
4. Une fois la clé API générée, copiez-la dans un endroit sûr. Vous en aurez besoin pour les étapes suivantes.

Étape 2 : tester l'API avec Postman

Maintenant que nous avons la clé API, nous pouvons la tester à l'aide de l' application Postman . Postman est un outil gratuit qui vous permet de faire des requêtes HTTP et de voir les réponses.

1. Tout d'abord, téléchargez et installez Postman depuis le site officiel. Vous pouvez trouver le lien de téléchargement ici .
2. Après l'installation, ouvrez Postman et créez un nouveau compte si nécessaire.
3. Une fois connecté, cliquez sur l' icône + pour créer une nouvelle demande.
4. Sélectionnez POST comme type de demande, car nous enverrons une invite à l’IA Gemini.
5. Pour l'URL, modifiez cette URL avec votre clé API, que vous avez générée à l'étape 1 : https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=YOUR_API_KEY

Étape 3 : Configuration des en-têtes et du corps dans Postman

Une fois l'URL entrée, nous devons configurer les en-têtes et le corps de la demande.

1. Accédez à la section En-têtes dans Postman et ajoutez un nouvel en-tête.
2. Définissez la clé d'en-tête sur Content-Type et la valeur sur application/json .
3. Maintenant, cliquez sur l’onglet Corps et sélectionnez brut et définissez le format sur JSON .
4. Dans le corps, collez le code JSON suivant :

 
{
 "contents": [
 {
 "parts": [
 {
 "text": "Who are you?"
 }
 ]
 }
 ],
 "generationConfig": {
 "maxOutputTokens": 100
 }
 }

Dans cet exemple, nous posons une question simple à l'IA : « Qui êtes-vous ? » et nous définissons le nombre maximal de jetons à 100. Les jetons contrôlent la longueur de la réponse générée par l'IA. Si vous réduisez la limite de jetons (par exemple, 20 jetons), la réponse sera plus courte. Vous pouvez tester différentes valeurs pour maxOutputTokens pour voir comment cela affecte la longueur de la réponse.

Étape 4 : Envoi de la demande

1. Une fois que tout est configuré, cliquez sur le bouton Envoyer .
2. Le facteur enverra la demande à l'IA Gemini, et après quelques secondes, vous devriez voir une réponse.
3. Si tout s'est bien passé, vous verrez un statut de 200 OK , indiquant que la demande a été traitée sans erreur.
4. Le corps de la réponse contiendra la réponse générée par l'IA. Dans ce cas, vous devriez voir quelque chose comme : "I am a large language model trained by Google."

Comment demander avec CodeCell ?

Une fois que vous avez généré et vérifié que l'API fonctionne, vous pouvez passer à l'étape suivante : intégrer cette API dans votre projet CodeCell.

Exemple 1 : invite AI via le moniteur série

Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Dans cet exemple, l'IA répondra aux invites de texte que vous envoyez via le moniteur série. N'oubliez pas de remplacer les espaces réservés par vos identifiants Wi-Fi et votre jeton API Gemini.

 
#include <Arduino.h>
 #include <WiFi.h>
 #include <HTTPClient.h>
 #include <ArduinoJson.h>
 #include <CodeCell.h>

 CodeCell myCodeCell;

 const char* ssid = "SSID"; //Enter your SSID
 const char* password = "PASSWORD"; //Enter your password
 const char* Gemini_Token = ""; //Enter your Gemini token
 const char* Gemini_Max_Tokens = "100";
 String res = "";

 void setup() {
 Serial.begin(115200);

 WiFi.mode(WIFI_STA);
 WiFi.disconnect();

 while (!Serial);

 // Wait for WiFi connection
 WiFi.begin(ssid, password);
 Serial.print("Connecting to ");
 Serial.println(ssid); 
tandis que (WiFi.status() != WL_CONNECTED) {
 délai(1000);
 Série.print(".");
 }
 Serial.println("connecté");
 Serial.print("Adresse IP : ");
 Série.println(WiFi.localIP());
 }

 boucle vide() {
 tandis que (!Serial.available());

 tandis que (Serial.available()) {
 char add = Serial.lire();
 res += ajouter;
 retard(1);
 }

 int len ​​= res.length();
 res = res.substring(0, len - 1);
 res = "\"" + res + "\"";

 Client HTTP https;

 si (https.begin("https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=" + String(Gemini_Token))) {
 https.addHeader("Type de contenu", "application/json");
 Chaîne de charge utile = "{\"contenu\": [{\"parties\":[{\"texte\": " + res + "}]}],\"generationConfig\": {\"maxOutputTokens\": " + String(Gemini_Max_Tokens) + "}} ";

 int httpCode = https.POST(charge utile);

 si (httpCode == HTTP_CODE_OK) {
 Réponse de chaîne = https.getString();
 Document dynamiqueJsonDocument doc(1024);
 deserializeJson(doc, réponse); 
Chaîne de réponse = doc["candidats"][0]["contenu"]["parties"][0]["texte"];
 réponse.trim();

 Serial.println(réponse);
 } autre {
 Serial.printf("[HTTPS] Échec du POST, erreur : %s\n", https.errorToString(httpCode).c_str());
 }
 https.end();
 } autre {
 Serial.printf("[HTTPS] Impossible de se connecter\n");
 }

 res = "";
 }

Exemple 2 : déclencher une invite AI via un capteur de proximité

Cet exemple utilise le capteur de proximité de CodeCell pour déclencher une invite lorsqu'un objet est détecté à proximité. L'IA répondra avec une blague.

 
#include <Arduino.h>
 #include <WiFi.h>
 #include <HTTPClient.h>
 #include <ArduinoJson.h>
 #include <CodeCell.h>

 CodeCell myCodeCell;

 const char* ssid = "SSID"; //Enter your SSID
 const char* password = "PASSWORD"; //Enter your password
 const char* Gemini_Token = ""; //Enter your Gemini token
 const char* Gemini_Max_Tokens = "100";
 String res = "";

 void setup() {
 Serial.begin(115200);

 myCodeCell.Init(LIGHT); // Initializes proximity sensing
 
mode.WiFi(WIFI_STA);
 WiFi.déconnecter();

 tandis que (!Série);

 WiFi.begin(ssid, mot de passe);
 Serial.print("Connexion à ");
 Série.println(ssid);
 tandis que (WiFi.status() != WL_CONNECTED) {
 délai(1000);
 Série.print(".");
 }
 Serial.println("connecté");
 Serial.print("Adresse IP : ");
 Série.println(WiFi.localIP());
 }

 boucle vide() {
 si (myCodeCell.Run()) {
 uint16_t proximité = myCodeCell.Light_ProximityRead();

 si (proximité > 100) {
 Serial.println("Voici une nouvelle blague...");
 myCodeCell.LED(0, 0xFF, 0); // Réglez la LED sur Vert lorsque la proximité est détectée

 res = "\"Raconte-moi une blague unique\"";

 Client HTTP https;

 si (https.begin("https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=" + String(Gemini_Token))) {
 https.addHeader("Type de contenu", "application/json");
 Chaîne de charge utile = "{\"contenu\": [{\"parties\":[{\"texte\": " + res + "}]}],\"generationConfig\": {\"maxOutputTokens\": " + String(Gemini_Max_Tokens) + "}} ";
 
int httpCode = https.POST(charge utile);

 si (httpCode == HTTP_CODE_OK) {
 Réponse de chaîne = https.getString();
 Document dynamiqueJsonDocument doc(1024);
 deserializeJson(doc, réponse);
 Chaîne de réponse = doc["candidats"][0]["contenu"]["parties"][0]["texte"];
 réponse.trim();

 Serial.println(réponse);
 } autre {
 Serial.printf("[HTTPS] Échec du POST, erreur : %s\n", https.errorToString(httpCode).c_str());
 }
 https.end();
 } autre {
 Serial.printf("[HTTPS] Impossible de se connecter\n");
 }

 res = "";
 }
 }
 }

Conseils de personnalisation

• Différentes invites : essayez de personnaliser les invites pour poser différentes questions à l'IA ou donner des commandes pour des résultats créatifs.
• Expérimentez avec d'autres capteurs : vous pouvez déclencher différentes réponses d'IA en fonction des entrées provenant d'autres capteurs CodeCell, comme la détection de mouvement ou de lumière.

Conclusion

Ce projet montre comment intégrer les réponses de l'IA dans vos projets CodeCell à l'aide de l'API Gemini de Google. En exploitant les capacités Wi-Fi de l'ESP32-C3, vous pouvez créer des appareils interactifs qui réagissent aux entrées de l'utilisateur ou aux facteurs environnementaux, rendant ainsi vos créations IoT plus intelligentes et plus attrayantes.

Expérimentez avec le code et personnalisez les invites en fonction de vos projets !

Dans cette version, nous allons découvrir comment configurer l'éclairage LED intégré du CodeCell à l'aide de la bibliothèque Espalexa , qui permet à Alexa de contrôler des appareils tels que des éclairages intelligents. Nous vous guiderons tout au long du processus de connexion du CodeCell à votre Wi-Fi, de configuration de la bibliothèque Espalexa et d'activation du contrôle vocal de la LED intégrée via Alexa.

Ce que vous apprendrez

• Comment configurer le CodeCell pour se connecter au Wi-Fi.
• Comment utiliser la bibliothèque Espalexa pour contrôler la LED embarquée via Alexa.
• Comment configurer Alexa pour reconnaître le CodeCell comme une lumière intelligente.

À propos de la bibliothèque Espalexa

La bibliothèque Espalexa simplifie l'intégration d'Alexa pour les projets ESP32. Elle crée une lumière intelligente virtuelle, qu'Alexa peut contrôler via des commandes vocales, sans nécessiter de configuration complexe ni de services cloud. En utilisant cette bibliothèque, votre CodeCell peut fonctionner comme un appareil intelligent, comme une ampoule, qu'Alexa peut allumer, éteindre ou atténuer.

Aperçu du projet

Dans ce projet, le CodeCell est configuré pour se connecter à votre réseau Wi-Fi. Une fois connecté, Alexa peut contrôler la lumière LED embarquée à l'aide de commandes vocales, qu'elle soit complètement allumée (verte) ou éteinte (aucune couleur).

Exemple:

Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Mettez à jour les informations d'identification Wi-Fi avec les détails de votre réseau et suivez les commentaires dans le code pour comprendre chaque étape.

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

 CodeCell myCodeCell;

 // WiFi credentials
 const char* ssid = "SSID"; //Change to your SSID
 const char* password = "PASSWORD"; // Change to your password

 // Alexa object
 Espalexa espalexa;

 // Function to handle Alexa commands
 void alexaCallback(uint8_t brightness) {
 // Handle brightness (or ON/OFF) commands here
 if (brightness == 255) {
 myCodeCell.LED(0, 0xFF, 0); // Full brightness, green light
 } else if (brightness == 0) {
 myCodeCell.LED(0, 0, 0); // Turn off the LED
 }
 }
 
vide configuration() {
 // Initialiser la série pour le débogage
 Série.begin(115200);
 myCodeCell.Init(LIGHT); /*Initialise la détection de lumière*/

 // Se connecter au WiFi
 WiFi.begin(ssid, mot de passe);
 tandis que (WiFi.status() != WL_CONNECTED) {
 délai(500);
 Série.print(".");
 }
 Serial.println("WiFi connecté");

 // Ajouter un appareil à Alexa
 espalexa.addDevice("MyLED", alexaCallback);

 // Démarrer Espalexa
 espalexa.begin();
 }

 boucle vide() {
 espalexa.loop(); // Gérer les requêtes Alexa
 }

Comment ajouter votre appareil dans l'application Alexa

Après avoir téléchargé le code et connecté le CodeCell au Wi-Fi, l'étape suivante consiste à ajouter l'appareil à votre application Alexa. Suivez ces étapes pour l'associer à Alexa :

1. Ouvrez l’application Alexa : Sur votre smartphone, ouvrez l’application Alexa.
2. Accédez à Appareils : appuyez sur l’onglet « Appareils » en bas de l’écran.
3. Ajouter un nouvel appareil : appuyez sur l'icône « + » dans le coin supérieur droit et sélectionnez « Ajouter un appareil ».
4. Sélectionner la lumière : Étant donné que le CodeCell apparaîtra comme une lumière intelligente, choisissez « Lumière » comme type d'appareil.
5. Rechercher des appareils : Alexa va maintenant rechercher de nouveaux appareils sur votre réseau. Attendez qu'il détecte « MyLED » (ou le nom que vous avez utilisé dans votre code).
6. Configuration complète : une fois détecté, appuyez sur votre appareil CodeCell et suivez les instructions pour terminer la configuration.
7. Testez l'appareil : une fois la configuration terminée, essayez de donner une commande telle que « Alexa, allume MyLED » ou « Alexa, éteins mon MyLED » pour contrôler la LED intégrée !

Grâce à ces étapes, la LED embarquée de votre CodeCell est désormais entièrement intégrée à votre configuration de maison intelligente et vous pouvez la contrôler avec les commandes vocales Alexa ou l'application Alexa !

Conseils de personnalisation

• Expérimentez avec les couleurs : modifiez la sortie de couleur LED dans la fonction alexaCallback() pour utiliser différentes couleurs en fonction du niveau de luminosité d'Alexa. Vous pouvez utiliser les valeurs RVB pour créer divers effets.
• Ajoutez plus de LED : contrôlez les bandes lumineuses RVB ou les NeoPixels via les GPIO du CodeCell .
• Contrôles supplémentaires : développez le projet en ajoutant plusieurs points de contrôle LED ou en les combinant avec d'autres fonctionnalités CodeCell telles que la détection de mouvement ou la surveillance de la lumière.

Conclusion

Ce projet montre comment intégrer CodeCell à Alexa en utilisant la bibliothèque Espalexa pour contrôler l'éclairage LED embarqué. En suivant cet exemple, vous pouvez facilement créer des projets à commande vocale avec CodeCell, mettant ainsi les capacités IoT entre vos mains !

Soyez créatif avec les options de personnalisation et donnez vie à davantage de vos projets grâce à l'intégration d'Alexa !

Si vous venez de mettre la main sur le CodeCell , vous allez vous régaler. Ce petit module est conçu pour simplifier vos projets de bricolage avec de multiples fonctionnalités regroupées dans une carte de la taille d'un centime. Dans ce guide, nous vous expliquerons :

• Qu'est-ce qu'un CodeCell ? Et comment fonctionne son circuit ?
• Comment configurer et utiliser votre CodeCell
• Commencer avec des exemples
• Expliquez toutes les fonctions de la bibliothèque disponibles et comment vous pouvez les utiliser dans votre projet

Qu'est-ce qui fait un CodeCell ?

CodeCell est un module compact et polyvalent doté de l'ESP32-C3, de plusieurs options d'alimentation et de capteurs intégrés, le tout dans un format minuscule de 1,85 cm de large. Ces caractéristiques en font un outil puissant pour une large gamme d'applications.

Dans cette première section, nous commencerons par nous familiariser avec les circuits qui composent le CodeCell . Ensuite, nous passerons en revue les étapes simples pour configurer votre CodeCell .

Module ESP32C3

Au cœur du CodeCell se trouve le module ESP32C3, un microcontrôleur compact connu pour être facile à utiliser dans le domaine de l'IoT. Il combine une architecture compatible Arduino avec des fonctionnalités Wi-Fi et Bluetooth Low Energy (BLE) intégrées. Cette intégration offre les options de connectivité les plus populaires tout en conservant un format compact.

L'antenne PCB du module ESP32C3 est positionnée sur un côté, à l'écart des autres composants, pour minimiser les interférences et améliorer la transmission et la réception du signal. Ce placement permet de réduire l'impact des plans de masse ou d'autres surfaces conductrices qui pourraient dégrader les performances de l'antenne. Les composants situés sur la face inférieure sont maintenus dans la distance recommandée pour l'antenne. D'après les tests, nous avons constaté que les performances de l'antenne ne sont pas affectées par l'interférence minimale d'un câble USB-C, car ces câbles sont généralement blindés.

L'ESP32-C3 offre une mémoire importante, avec 4 Mo de Flash et 400 Ko de SRAM, ce qui lui permet d'exécuter la plupart des applications courantes. Son processeur monocœur RISC-V 32 bits, fonctionnant jusqu'à 160 MHz, gère efficacement diverses tâches. Cette combinaison de mémoire et de puissance de traitement rend l'ESP32-C3 adapté à une large gamme d'utilisations.

Le module ESP32C3 prend également en charge un contrôleur USB série/JTAG, nous permettant de rendre le CodeCell reflashable via le port USB-C et d'envoyer des données série pour la communication et le débogage.

Gestion de l'alimentation

Le CodeCell offre une grande flexibilité en termes d'options d'alimentation. Il peut être alimenté via le connecteur de batterie LiPo, un câble USB-C ou les deux.

Le connecteur de batterie LiPo permet de connecter la batterie en toute sécurité plus facilement que jamais, sans avoir besoin de souder ni de risquer de la court-circuiter accidentellement.

Le port USB-C a une double fonction : il sert à la fois à alimenter l'appareil et/ou à le reprogrammer. Cette option multi-alimentation est activée grâce à la puce de gestion de batterie BQ24232, qui dispose d'une gestion dynamique du chemin d'alimentation (DPPM) qui peut alimenter le système tout en chargeant simultanément et indépendamment la batterie. Le processus de charge de la batterie est géré en trois phases : précharge de conditionnement, courant constant et tension constante. Pour protéger la batterie, la tension de sortie (Vo) est régulée via la puce BQ24232. Cette sortie prend en charge un courant de sortie maximal de 1 500 mA lorsqu'elle est alimentée par la batterie LiPo et de 450 mA lorsqu'elle est alimentée via USB.

Par défaut, le courant de charge de la batterie LiPo est réglé à 90 mA, ce qui garantit un taux de charge équilibré et sûr pour la batterie LiPo optionnelle de 170 mAh. De plus, pour ceux qui souhaitent ajuster le taux de charge, la résistance 0402 R12 doit être dessoudée et remplacée par une nouvelle résistance basée sur la formule (R = 870/Ichrg). Ceci est uniquement recommandé pour les professionnels de la soudure, qui n'ont pas peur de se battre avec de minuscules composants 0402 ! Consultez la fiche technique du BQ24232 pour plus d’informations sur la charge de la batterie.

La bibliothèque CodeCell peut fournir un retour visuel sur l'état de la batterie/de l'alimentation USB via la LED RVB adressable intégrée :

• Avertissement de batterie faible : lorsque la tension de la batterie descend en dessous de 3,3 V, le voyant LED clignote en rouge dix fois et l'appareil passe en mode veille. Cela permet d'économiser l'énergie jusqu'à ce que l'appareil soit reconnecté à un chargeur USB.
• Processus de charge : pendant la charge, le CodeCell suspend les processus d'application, allume la LED en bleu et attend que la batterie soit complètement chargée. Une fois complètement chargée, la LED effectue une animation lumineuse, indiquant la distance de proximité détectée par les capteurs.
• Alimenté par batterie : lorsque l'USBC est déconnecté et fonctionne sur batterie, le CodeCell s'allume à nouveau en vert et effectue une animation lumineuse respiratoire, indiquant la distance de proximité détectée par les capteurs.

La régulation de puissance est également prise en charge par plusieurs condensateurs de découplage, dont jusqu'à deux condensateurs de masse de 100 µF chacun, placés à côté du connecteur de batterie. Ces condensateurs sont connectés aux broches 3,3 V et de sortie Vo pour assurer une alimentation stable. De plus, la carte est équipée de deux diodes TVS de protection ; l'une protège la tension d'entrée USB 5 V (Vin) et l'autre protège la tension de sortie (Vo). Ces diodes TVS offrent une protection contre les décharges électrostatiques (ESD), capables d'absorber en toute sécurité les décharges électrostatiques répétitives au-dessus du niveau maximal spécifié dans la norme internationale IEC 61000-4-2 sans dégradation des performances.

La carte comprend également un régulateur LDO (Low Dropout) de 3,3 V intégré, qui fournit une alimentation stable à ses composants basse tension. Cette minuscule puce LDO NCP177 peut produire jusqu'à 500 mA de courant de sortie avec une tension de chute généralement faible de 200 mV à 500 mA.

Broches GPIO et d'alimentation

Étant donné la conception compacte, le principal défi était de maximiser l'utilisation des broches GPIO. Nous avons abordé ce problème en divisant chacun des trois côtés disponibles du CodeCell en différentes sections d'E/S en fonction de leurs applications. Nous avons également placé des broches d'alimentation le long des bords du module pour une connexion facile à diverses sources d'alimentation, vous permettant ainsi de connecter d'autres modules, capteurs et actionneurs à différents côtés.

Sur la face inférieure, 3 des 5 broches sont utilisées pour l'alimentation : une broche de masse (GD), une broche d'alimentation de niveau logique 3,3 V (3V3) et une broche de charge d'entrée 5 V (5V0). Cette broche 5V0 est connectée à la tension d'entrée USB. Cela signifie que vous pouvez l'utiliser pour obtenir une alimentation de 5 V lorsque l'USB est connecté, ou vous pouvez l'utiliser comme entrée d'alimentation pour charger au lieu d'utiliser l'USB. Les 2 autres broches sont les broches I2C SDA et SCL pour ajouter des capteurs numériques externes. Si vous n'utilisez pas de capteurs externes et de lumière/mouvement, ces broches I2C peuvent être configurées comme GPIO.

Les deux autres côtés ont chacun une broche de masse (GD) et une broche de sortie de tension (VO). Chaque côté comporte également 3 broches GPIO programmables (IO1, IO2, IO3, IO5, IO6, IO7), qui peuvent toutes être configurées comme broches PWM ( idéales pour connecter directement un pont en H pour le contrôle de l'actionneur/moteur ). IO1, IO2 et IO3 peuvent également être utilisées comme broches ADC.

Capacités de détection

Les fonctionnalités remarquables du CodeCell incluent ses capteurs intégrés. Chaque unité est équipée d'un capteur de lumière intégré et un capteur de mouvement en option est également disponible pour améliorer la détection de mouvement de votre projet, ce qui est particulièrement utile pour la robotique et les objets connectés !

• Capteur de lumière VCNL4040 : Ce capteur mesure à la fois les niveaux de luminosité et la proximité jusqu'à 20 cm. Il présente une conception haute résolution 16 bits qui combine un capteur de proximité, un capteur de lumière ambiante et un IRED haute puissance dans un boîtier compact. En intégrant des photodiodes, des amplificateurs et un convertisseur analogique-numérique sur une seule puce, il offre des fonctionnalités améliorées. La configuration I2C est directement intégrée dans la bibliothèque CodeCell , ce qui garantit que le capteur est automatiquement initialisé pour optimiser sa résolution de détection.
• Capteur de mouvement 9 axes BNO085 en option : Ce capteur IMU avancé est une mise à niveau coûteuse, mais nous pensons que l'investissement en vaut la peine ! Il met à niveau les capacités du CodeCell avec un accéléromètre à 3 axes intégré, un gyroscope à 3 axes et un magnétomètre à 3 axes + les algorithmes avancés de fusion de capteurs du BNO085 combinent les données de ces capteurs pour déterminer avec précision les données de mouvement du capteur, comme : Lecture de rotation angulaire (roulis, tangage, lacet), État de mouvement (par exemple, sur table, stationnaire, mouvement), Activité de mouvement (par exemple, conduite, marche, course), Lectures d'accéléromètre, Lecture de gyroscope, Lecture de magnétomètre, Lecture de gravité, Lecture d'accélération linéaire, Détection de tapotement, Compteur de pas. 

Nous verrons ensuite comment la bibliothèque CodeCell simplifie à la fois la configuration de ces capteurs et la lecture de leurs données.

Pour rendre la programmation encore plus facile, le CodeCell La bibliothèque fournit un large éventail de fonctions pour l'initialisation, la lecture et la gestion des capteurs et de l'alimentation. Dans cette section, nous allons vous expliquer tout ce que vous devez savoir sur la configuration de votre appareil et de sa bibliothèque.

Déballage de votre CodeCell

Commençons par ce que vous trouverez à l'intérieur de la boîte. Selon les options que vous avez sélectionnées lors du paiement, vous trouverez dans la boîte :

1. CodeCell : la star du spectacle, votre petite mais puissante carte dotée du module ESP32-C3, de broches GPIO programmables et de capteurs.
2. Vis : Quatre vis M1,2 x 6 mm pour monter le CodeCell en toute sécurité dans vos projets.
3. Embases : Trois jeux d'embases femelles qui peuvent être livrées non soudées ou soudées, selon votre choix.
4. Batterie/câble : selon votre sélection lors du paiement, vous recevrez soit un câble de batterie gratuit pour connecter votre propre batterie au connecteur intégré du CodeCell , soit une batterie LiPo 170 mAh 20 C avec un câble pré-soudé. Cette batterie optionnelle mesure 23 x 17,5 x 8,7 mm et ne pèse que 4,6 grammes. Cliquez ici si vous souhaitez accéder à la fiche technique de la batterie.

Mettre votre CodeCell sous tension pour la première fois

Commençons par brancher un câble USB-C ! Une fois que votre CodeCell est alimenté, il devrait :

• Initialisation : elle configure les périphériques internes et les capteurs embarqués. Une fois cette opération terminée, elle affiche un message Hello World sur le moniteur série.
• Vérification de l'alimentation : il surveille l'état de l'alimentation, vérifie si la batterie est connectée et si elle est en charge. Si aucune batterie n'est connectée pour la charge, il exécutera une animation lumineuse respiratoire avec la LED RVB intégrée. La vitesse de l'animation change en fonction de la proximité du capteur de lumière ~ Rapprochez votre main pour ralentir. Éloignez votre main pour accélérer à nouveau ! La LED clignote en bleu ou en vert selon que la carte est alimentée par USB ou par batterie. Si la batterie est en charge, la LED reste bleue statique jusqu'à ce qu'elle soit complètement chargée.

Configuration de votre CodeCell

L'étape suivante consiste à connecter le CodeCell à l'IDE Arduino et à exécuter un croquis :

1. Connexion USB : connectez votre CodeCell à votre PC à l'aide d'un câble USB-C standard. Ce câble permet non seulement d'alimenter la carte, mais également de la reprogrammer.
2. Installez l'IDE Arduino : Si vous êtes nouveau dans le monde Arduino, ne vous inquiétez pas, téléchargez et installez simplement la dernière version gratuite du logiciel IDE Arduino à partir du site officiel d'Arduino .
3. Ajouter l'URL du gestionnaire de cartes ESP32 : si vous n'avez jamais utilisé d'ESP32, ouvrez l'IDE Arduino et accédez à « Fichier > Préférences ». Dans le champ « URL supplémentaires du gestionnaire de cartes », saisissez : ` https://dl.espressif.com/dl/package_esp32_index.json ` puis cliquez sur OK. Accédez ensuite à « Outils > Carte > Gestionnaire de cartes ». Recherchez « ESP32 » et cliquez sur « Installer ».
4. Sélectionnez la carte : L'étape suivante consiste à sélectionner notre carte. Allez dans « Outils > Carte » et choisissez « ESP32C3 Dev Module ». Dans quelques semaines, vous pourrez rechercher directement « CodeCell », mais pour l'instant, sélectionner « ESP32C3 Dev Module » fonctionne parfaitement, car il s'agit du microcontrôleur utilisé à bord du CodeCell .
5. Sélectionnez le port : allez dans « Outils > Port » et sélectionnez le port COM correspondant à votre CodeCell .
6. Autres paramètres : accédez à « Outils > USB_CDC_On_Boot » et assurez-vous qu'il est activé si vous prévoyez d'utiliser le moniteur série. Réglez également la vitesse d'horloge sur 160 MHz.

Une fois votre IDE configuré, nous pouvons maintenant procéder à l'installation de la bibliothèque « CodeCell ». Pour ce faire, accédez à « Sketch > Inclure la bibliothèque > Gérer les bibliothèques » - le « Gestionnaire de bibliothèques » devrait s'ouvrir. Tapez simplement « CodeCell » et cliquez sur « Installer » pour télécharger la dernière version de CodeCell .

Nous mettons continuellement à jour et ajoutons de nouvelles fonctionnalités à cette bibliothèque, alors assurez-vous d'utiliser la dernière version.

Pour vous familiariser rapidement avec cette bibliothèque, accédez à « Fichier > Exemples > CodeCell », où vous trouverez plusieurs exemples que vous pouvez utiliser et modifier pour vos projets. Nous vous recommandons de commencer par l'exemple « GettingStarted », qui ne contient que quelques lignes de code mais explique toutes les fonctionnalités de détection disponibles avec CodeCell .

Une fois que vous avez sélectionné un exemple de croquis, cliquez sur le bouton « Télécharger » pour flasher le code sur votre CodeCell. Après le téléchargement, ouvrez le moniteur série « Outils > Moniteur série » pour voir les données série de votre CodeCell.

Voici quelques tutoriels CodeCell supplémentaires pour vous aider à démarrer avec diverses applications :

• Gestes de profondeur
• Détection de tapotement
• Proximité
• Gradation automatique
• Compteur de pas
• Contrôle d'angle
• Activité personnelle de devinettes
• Télécommande sans fil
• Invite d'IA
• Contrôle de la lumière Alexa

Fonctions de la bibliothèque CodeCell

Pour explorer davantage le code, décomposons toutes les fonctions et expliquons ce que fait chacune d'elles :

Initialisation de CodeCell

La première étape de l'utilisation du CodeCell consiste à l'initialiser. Cela se fait à l'aide de la fonction `myCodeCell.Init()`, qui vous permet de spécifier les capteurs que vous souhaitez activer.

Macros de détection disponibles :

• LUMIÈRE - Active la détection de lumière.
• MOTION_ACCELEROMETRE - Active la détection par accéléromètre.
• MOUVEMENT_GYRO - Active la détection du gyroscope.
• MOTION_MAGNETOMETRE - Permet la détection du magnétomètre.
• MOUVEMENT_LINÉAIRE_ACC - Permet la détection d'accélération linéaire.
• MOUVEMENT_GRAVITÉ - Active la détection de la gravité.
• MOUVEMENT_ROTATION - Active la détection de rotation.
• MOUVEMENT_ROTATION_SANS_MAG - Permet la détection de rotation sans magnétomètre.
• COMPTEUR_DE_PAS_MOUVEMENT - Active le compteur de pas de marche.
• ETAT_MOUVEMENT - Active la détection de l'état de mouvement.
• DÉTECTEUR DE MOUVEMENT_TAP - Active le détecteur de tapotement.
• MOTION_ACTIVITY - Active la reconnaissance de l'activité de mouvement.

Vous pouvez combiner plusieurs macros à l'aide de l'opérateur « + » pour initialiser plusieurs capteurs à la fois.

Gestion du pouvoir

La fonction `myCodeCell.Run()` est essentielle pour la gestion de l'alimentation. Cette fonction doit être appelée dans la fonction `loop()` pour gérer l'état de la batterie et garantir une utilisation optimale de l'énergie.

Fonction Comportement:

• La fonction renvoie « true » toutes les 100 ms, ce qui peut être utilisé pour des opérations basées sur le temps.
• Il contrôle la LED embarquée pour indiquer différents états d'alimentation :
• Clignotement rouge (clignotement 10 fois) - Tension de la batterie inférieure à 3,3 V, entrée en mode veille.
• LED verte (animation de respiration) - Alimenté par batterie
• LED bleue (statique) – La batterie est en charge
• LED bleue (animation de respiration) - Entièrement chargé et prêt à fonctionner.

Lecture des données du capteur

Après avoir initialisé les capteurs, vous pouvez lire leurs données à l'aide de diverses fonctions fournies par la bibliothèque. Voici un bref aperçu des fonctions disponibles :

Fonctions du capteur de lumière :

• Light_ProximityRead() - Lit la valeur de proximité du capteur de lumière.
• Light_WhiteRead() - Lit l'intensité de la lumière blanche à partir du capteur de lumière.
• Light_AmbientRead() - Lit l'intensité lumineuse ambiante à partir du capteur de lumière.

Fonctions du capteur de mouvement :

• Motion_AccelerometerRead(float &x, float &y, float &z) - Lit les données d'accélération le long des axes x, y et z.
• Motion_GyroRead(float &x, float &y, float &z) - Lit les données de vitesse de rotation le long des axes x, y et z.
• Motion_MagnetometerRead(float &x, float &y, float &z) - Lit les données d'intensité du champ magnétique le long des axes x, y et z.
• Motion_GravityRead(float &x, float &y, float &z) - Lit les données du vecteur de gravité le long des axes x, y et z.
• Motion_LinearAccRead(float &x, float &y, float &z) - Lit les données d'accélération linéaire le long des axes x, y et z.
• Motion_TapRead(uint16_t &x) - Lit le nombre de taps détectés.
• Motion_StepCounterRead(uint16_t &x) - Lit le nombre de pas comptés.
• Motion_RotationRead(float &roll, float &pitch, float &yaw) - Lit les données de rotation angulaire (roulis, tangage, lacet).
• Motion_RotationNoMagRead(float &roll, float &pitch, float &yaw) - Lit les données de rotation angulaire sans utiliser le magnétomètre.
• Motion_StateRead(uint16_t &x) - Lit l'état actuel (par exemple, Sur table, Stationnaire, Mouvement).
• Motion_ActivityRead(uint16_t &x) - Lit l'activité en cours (par exemple, conduite, marche, course).

Exemple d'utilisation :

Fonctions veille, économie d'énergie, diagnostic et LED

Le CodeCell comprend plusieurs fonctions pour gérer les modes veille et économie d'énergie :

• WakeUpCheck() - Vérifie la raison du réveil de l'appareil. Si l'appareil se réveille suite à un événement de minuterie, il renvoie « true » ; sinon, il renvoie « false »
• Sleep(uint16_t sleep_sec) - Met l'appareil en mode veille prolongée pendant une durée spécifiée en secondes. Il configure les broches et les capteurs nécessaires pour une faible consommation d'énergie avant de passer en mode veille.
• USBSleep(bool cable_polarity) - Gère le mode veille de l'appareil lorsque le niveau de la batterie est faible ou lorsque l'appareil se charge via l'alimentation USB. Il arrête l'application et prépare l'appareil à la mise en veille pour permettre une reprogrammation si nécessaire.
• PrintSensors() - Imprime les relevés actuels de tous les capteurs initialisés sur le moniteur série. Cette fonction est particulièrement utile pour le débogage et l'enregistrement des données.
• BatteryRead() - Cette fonction lit et renvoie la tension de la batterie lorsque le port USB-C est déconnecté.
• LED_Breathing(uint32_t rgb_color_24bit) - Cette fonction est utilisée dans le gestionnaire Run() pour contrôler la LED intégrée et créer un effet de respiration avec une couleur spécifique. Le paramètre `rgb_color_24bit` est une valeur de couleur 24 bits représentant la couleur RVB. Lorsque vous utilisez cette fonction, soyez prudent car la fonction 'Run' peut écraser la couleur de votre LED.
• LED(uint8_t r, uint8_t g, uint8_t b) - Cette fonction définit la couleur de la LED adressable intégrée à l'aide du modèle RVB où « r », « g » et « b » sont des valeurs 8 bits représentant les composants rouge, vert et bleu de la couleur. Chaque composant est compris entre 0 et 255. Lorsque vous utilisez cette fonction, soyez prudent car la fonction « Exécuter » peut écraser la couleur de votre LED.

Félicitations!

Vous avez maintenant fait vos premiers pas avec CodeCell . Plongez plus profondément dans les exemples de la bibliothèque, explorez les intégrations de capteurs et commencez à donner vie à vos projets innovants avec CodeCell !

Dans cette version, nous allons découvrir comment utiliser le capteur de proximité intégré du CodeCell pour détecter les mouvements de profondeur et contrôler deux FlatFlaps , en faisant varier leurs angles en fonction des valeurs de proximité. Ce projet démontre une manière unique de créer des robots, des actionneurs, des moteurs ou de la lumière interactifs qui répondent aux mouvements de la main.

Ce que vous apprendrez

• Comment configurer le CodeCell pour la reconnaissance des gestes de profondeur à l'aide de son capteur de proximité.
• Comment contrôler deux FlatFlaps en utilisant les données de proximité du CodeCell .
• Une compréhension de la façon d'intégrer le petit DriveCell pour contrôler les FlatFlaps .

À propos du capteur de proximité de CodeCell

Le CodeCell est équipé d'un capteur de proximité VCNL4040 capable de mesurer des distances allant jusqu'à 20 cm. En utilisant une lumière infrarouge, le capteur détecte les objets à sa portée, mesurant la réflexion de la lumière IR émise pour estimer la distance. Cela vous permet de créer des comportements réactifs en fonction de la proximité d'un objet, ce qui le rend idéal pour les gestes interactifs.

Les gestes de profondeur sont basés sur les données de proximité du capteur embarqué du CodeCell . En rapprochant ou en éloignant votre main ou d'autres objets du capteur, vous pouvez créer des entrées dynamiques qui entraînent diverses actions. Dans ce projet, les données de proximité sont utilisées pour contrôler l'angle de deux FlatFlaps , qui sont connectés à deux DriveCell (pilotes en pont en H).

Aperçu du projet

Dans cet exemple, le CodeCell lit en continu les données de proximité et ajuste l'angle de deux FlatFlaps en fonction de la proximité de l'objet. Lorsque l'objet se rapproche ou s'éloigne, l'angle des FlatFlaps change, démontrant ainsi une méthode simple mais efficace de contrôle de la profondeur par gestes.

Les deux FlatFlaps sont soudés à deux DriveCell (drivers en pont H), qui sont compatibles broche à broche avec le CodeCell. Ces composants sont ensuite connectés sur un support imprimé en 3D, pour créer un mignon petit Flappy-Bot ! N'oubliez pas d'ajouter un œil globuleux pour lui donner plus de personnalité !

Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Assurez-vous que votre CodeCell est correctement connecté via USB-C et que les FlatFlaps sont connectés aux deux DriveCell . Suivez les commentaires dans le code pour comprendre chaque étape.

Exemple

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

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

 DriveCell FlatFlap1(IN1_pin1, IN1_pin2);
 DriveCell FlatFlap2(IN2_pin1, IN2_pin2);

 CodeCell myCodeCell;

 void setup() { 
Serial.begin(115200); // Définissez le débit en bauds série sur 115 200. Assurez-vous que Tools/USB_CDC_On_Boot est activé si vous utilisez Serial.

 myCodeCell.Init(LIGHT); // Initialise la détection de lumière

 FlatFlap1.Init();
 FlatFlap2.Init();

 FlatFlap1.Tone();
 FlatFlap2.Tone();
 }

 boucle vide() {
 si (myCodeCell.Run()) {
 // S'exécute toutes les 100 ms
 uint16_t proximité = myCodeCell.Light_ProximityRead();
 Serial.println(proximité);
 si (proximité < 100) {
 // Si une proximité est détectée, le rabat FlatFlaps
 FlatFlap1.Run(1, 100, 400);
 FlatFlap2.Run(1, 100, 400);
 } autre {
 // Ajuster l'angle de FlatFlap en fonction de la proximité
 proximité = proximité - 100 ;
 proximité = proximité / 10 ;
 si (proximité > 100) {
 proximité = 100;
 }
 FlatFlap1.Drive(0, proximité);
 FlatFlap2.Drive(0, proximité);
 }
 }
 }

Conseils de personnalisation

• Ajuster les seuils : modifiez les seuils de proximité et les facteurs d’échelle dans le code pour affiner la réactivité des FlatFlaps en fonction de vos préférences.
• Développez les fonctionnalités : envisagez d'ajouter davantage de fonctions de détection CodeCell , comme la détection de mouvement ou la détection de lumière pour ajouter plus de fonctionnalités à votre Flap-Bot !
• Créez des conceptions personnalisées : utilisez l’impression 3D pour créer un robot plus unique, le rendant ainsi plus personnalisé.

Conclusion

Ce projet montre comment utiliser le capteur de proximité du CodeCell pour les gestes de profondeur, en pilotant les angles des FlatFlaps en fonction de la distance de l'objet. Expérimentez avec le code, personnalisez les paramètres et donnez vie à votre propre robot Flappy !

Dans cette version, nous allons découvrir comment configurer le capteur de mouvement intégré du CodeCell pour essayer de deviner l'activité personnelle que vous effectuez et l'afficher sur un écran OLED. Il est conçu pour suivre différents états tels que la marche, la course, le vélo, la montée des escaliers et la conduite !

Ce que vous apprendrez

• Comment configurer le CodeCell pour la détection d'activité personnelle à l'aide de son capteur de mouvement.
• Comment connecter un écran OLED au CodeCell .
• Comprendre comment le capteur de mouvement du CodeCell catégorise différentes activités.

À propos de la détection d'activité personnelle de CodeCell

Le capteur de mouvement du CodeCell est capable de catégoriser diverses activités personnelles en fonction des schémas de mouvement. En fonction de ces schémas, le capteur BNO085 essaiera de deviner quelle activité est en cours d'exécution. Ces activités comprennent la marche, la course, le vélo, la conduite et bien plus encore.

La bibliothèque CodeCell vous permet de lire directement l'activité sans aucun code complexe.

Aperçu du projet

Dans cet exemple, le CodeCell surveille en permanence l'activité personnelle estimée du BNO085. L'activité ayant la plus grande chance d'être détectée est ensuite affichée sur un écran OLED à l'aide de la bibliothèque Adafruit SSD1306. Cette configuration est idéale pour créer des moniteurs d'activité portables ou des trackers de fitness qui fournissent un retour d'information en temps réel sur les activités physiques.

Notez que certaines activités peuvent prendre entre 10 et 30 secondes pour commencer à être reconnues, car cela dépendra principalement de l'orientation du CodeCell et de l'endroit où il est monté.

Exemple:

Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Assurez-vous que votre CodeCell est connecté via USB-C et que votre écran OLED est correctement câblé sur le côté inférieur du CodeCell , à l'aide de ses broches de masse, 3V3 et I2C (SDA et SCL).

Suivez les commentaires dans le code pour comprendre chaque étape.

 
#include <CodeCell.h>
 #include <Wire.h>
 #include <Adafruit_GFX.h>
 #include <Adafruit_SSD1306.h>

 CodeCell myCodeCell;

 /* Configure the OLED Display */
 #define SCREEN_WIDTH 128 // OLED display width, in pixels
 #define SCREEN_HEIGHT 32 // OLED display height, in pixels

 #define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin) 
#define SCREEN_ADDRESS 0x3C // Adresse de l'écran OLED
 Affichage Adafruit_SSD1306 (LARGEUR_ÉCRAN, HAUTEUR_ÉCRAN, &Câble, RÉINITIALISATION_OLED) ;

 int read_timer = 0;

 configuration vide() {
 Serial.begin(115200); // Définissez le débit en bauds série sur 115 200. Assurez-vous que Tools/USB_CDC_On_Boot est activé si vous utilisez Serial.

 myCodeCell.Init(MOTION_ACTIVITY); // Initialise la détection d'activité.

 si (!display.begin(SSD1306_SWITCHCAPVCC, ADRESSE_ECRAN)) {
 Serial.println(F("Échec de l'allocation SSD1306"));
 }

 affichage.clearDisplay();
 affichage.setTextSize(1);
 affichage.setTextColor(SSD1306_WHITE);
 affichage.display();
 retard (2000);
 }

 boucle vide() {
 si (myCodeCell.Run()) {
 si (read_timer < 10) {
 lire_timer++;
 } autre {
 // Mise à jour toutes les 1 seconde
 minuteur_de_lecture = 0;
 affichage.clearDisplay();
 affichage.setCursor(32, 16);
 display.print(F("Activité : "));
 affichage.setCursor(32, 24);
 commutateur (myCodeCell.Motion_ActivityRead()) {
 cas 1: 
display.print("Conduite");
 casser;
 cas 2:
 display.print("Cyclisme");
 casser;
 cas 3:
 cas 6:
 display.print("Marche");
 casser;
 cas 4:
 display.print("Toujours");
 casser;
 cas 5:
 display.print("Inclinaison");
 casser;
 cas 7:
 display.print("En cours d'exécution");
 casser;
 cas 8:
 display.print("Escalier");
 casser;
 défaut:
 display.print("Lecture..");
 casser;
 }
 affichage.display();
 }
 }
 }

Conseils de personnalisation

• Combinez avec d'autres capteurs : intégrez des capteurs supplémentaires disponibles à l'intérieur du CodeCell , comme le comptage des pas pour une surveillance de la condition physique plus complète.

Conclusion

Ce projet montre comment utiliser le capteur de mouvement du CodeCell pour surveiller les activités personnelles et afficher les résultats sur un écran OLED. Cette configuration de base fournit une base pour le développement de systèmes de surveillance d'activité plus avancés.

Expérimentez avec le code et les paramètres pour créer votre propre objet portable personnalisé !

Dans cette version, nous allons découvrir comment utiliser le capteur de mouvement intégré du CodeCell pour mesurer le nombre de pas et afficher ces nombres sur un écran OLED. Ce projet montre comment créer un compteur de pas, idéal pour les trackers de fitness, les podomètres ou tout autre projet de bricolage nécessitant une surveillance de l'activité.

Ce que vous apprendrez

• Comment configurer le CodeCell pour le comptage des pas à l'aide de son capteur de mouvement.
• Comment connecter l'écran OLED au CodeCell
• Comprenez comment fonctionne le capteur de mouvement du CodeCell pour le comptage des pas.

À propos du comptage des pas de CodeCell

Le CodeCell est équipé d'un capteur de mouvement qui peut suivre le nombre de pas en utilisant ses capteurs intégrés pour détecter des modèles de mouvement spécifiques. Cet algorithme est exécuté à l'intérieur du capteur BNO085 et la bibliothèque CodeCell vous aide à lire facilement ces nombres de pas.

Aperçu du projet

Dans cet exemple, le CodeCell surveille en permanence les pas et met à jour le nombre. Ce nombre est ensuite affiché sur un écran OLED à l'aide de la bibliothèque Adafruit SSD1306.

Exemple:

Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Assurez-vous que votre CodeCell est correctement connecté via USB-C et que votre écran OLED est correctement câblé sur le côté inférieur du CodeCell . Vous pouvez y utiliser ses broches de masse, 3V3 et I2C (SDA et SCL).

Suivez les commentaires dans le code pour comprendre chaque étape.

 
#include <CodeCell.h> 
#include <Wire.h>
 #include <Adafruit_GFX.h>
 #include <Adafruit_SSD1306.h>

 CodeCell monCodeCell;

 /* Configurer l'écran OLED */
 #define SCREEN_WIDTH 64 // Largeur de l'écran OLED, en pixels
 #define SCREEN_HEIGHT 32 // Hauteur de l'écran OLED, en pixels

 #define OLED_RESET -1 // Réinitialiser la broche # (ou -1 si vous partagez la broche de réinitialisation Arduino)
 #define SCREEN_ADDRESS 0x3C // Adresse de l'écran OLED
 Affichage Adafruit_SSD1306 (LARGEUR_ÉCRAN, HAUTEUR_ÉCRAN, &Câble, RÉINITIALISATION_OLED) ;

 uint16_t compteur_pas = 0;

 vide configuration() {
 Serial.begin(115200); // Définissez le débit en bauds série sur 115 200. Assurez-vous que Tools/USB_CDC_On_Boot est activé si vous utilisez Serial.

 myCodeCell.Init(MOTION_STEP_COUNTER); // Initialise le comptage des pas et la détection d'activité.

 si (!display.begin(SSD1306_SWITCHCAPVCC, ADRESSE_ECRAN)) {
 Serial.println("Erreur d'affichage");
 }

 affichage.clearDisplay();
 affichage.setTextSize(1);
 affichage.setTextColor(SSD1306_WHITE);
 affichage.display();
 retard (2000);
 }

 boucle vide() {
 si (myCodeCell.Run()) { 
// Lire le nombre de pas à partir du capteur de mouvement CodeCell.
 myCodeCell.Motion_StepCounterRead(compteur_de_pas);

 // Effacer l'affichage et afficher le nombre de pas.
 affichage.clearDisplay();
 display.setCursor(32, 16); // Commence dans le coin supérieur gauche
 display.print(F("Étapes : "));
 affichage.print(compteur_de_pas);
 affichage.display();
 }
 }

Conseils de personnalisation

• Développez les fonctionnalités : intégrez des fonctionnalités supplémentaires telles que des objectifs de pas, des approximations de distance ou le suivi des activités au fil du temps.
• Combinez avec d'autres capteurs : ajoutez d'autres fonctions de détection comme la détection d'activité personnelle de mouvement de CodeCell , pour créer un tracker de fitness plus complet.

Conclusion

Ce projet montre comment utiliser le capteur de mouvement du CodeCell pour compter les pas et afficher le nombre sur un écran OLED. Expérimentez avec le code pour créer votre propre appareil de fitness portable !

Dans cette version, nous allons découvrir comment utiliser le capteur de mouvement à 9 axes intégré du CodeCell pour lire les angles de roulis, de tangage et de lacet, et utiliser ces angles pour contrôler un servomoteur. Ce projet montre comment créer des commandes interactives basées sur le mouvement, parfaites pour la robotique, les cardans ou tout projet nécessitant un contrôle de rotation réactif.

Ce que vous apprendrez

• Comment configurer le CodeCell pour lire les angles de mouvement (roulis, tangage et lacet).
• Comment écrire du code pour contrôler un servomoteur en fonction de l'angle de pas du capteur de mouvement.
• Comprendre le fonctionnement du capteur de mouvement BNO085 de CodeCell pour la détection de rotation.

À propos de la détection de rotation du CodeCell

Le CodeCell est équipé d'un capteur de mouvement BNO085, qui fournit des capacités de détection de mouvement précises, notamment les angles de roulis, de tangage et de lacet. En lisant ces angles, vous pouvez créer des commandes de mouvement interactives pour diverses applications, telles que la stabilisation de plates-formes ou la création d'une réponse à l'orientation de l'appareil.

Comment fonctionne la détection de rotation

Le capteur de mouvement BNO085 lit les valeurs de l'accéléromètre, du gyroscope et du magnétomètre et calcule les vecteurs de rotation. Ces vecteurs sont envoyés au CodeCell qui les transforme ensuite en données angulaires pour obtenir le roulis, le tangage et le lacet en fonction de l'orientation de l'appareil dans l'espace. Ces angles représentent la rotation de l'appareil selon trois axes. Dans cet exemple, nous utiliserons l'angle de tangage pour contrôler la position d'un servomoteur, lui permettant de réagir de manière dynamique aux changements d'orientation.

Aperçu du projet

Dans cet exemple, le CodeCell surveille en permanence l'angle d'inclinaison. La valeur d'inclinaison est utilisée pour définir la position du servomoteur, lui permettant de tourner en fonction de l'inclinaison de l'appareil. Cette fonctionnalité de base peut être étendue pour créer des interactions plus complexes, telles que le contrôle de plusieurs servos, la stabilisation d'une plate-forme ou l'ajout de mouvements réactifs à un robot.

Exemple de code : servocommande avec angle de pas

Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Assurez-vous que votre CodeCell est correctement connecté via USB-C. Assurez-vous également que votre servomoteur peut être alimenté via USB-C et ajoutez ses limites angulaires au code.

Pour cet exemple, vous devez télécharger la bibliothèque ESp32Servo pour contrôler le servomoteur avec votre CodeCell . Suivez les commentaires dans le code pour comprendre chaque étape.

 
#include <CodeCell.h>
 #include <ESP32Servo.h>

 CodeCell myCodeCell;
 Servo myservo;

 float Roll = 0.0;
 float Pitch = 0.0;
 float Yaw = 0.0;
 int servo_angle = 0;

 void setup() {
 Serial.begin(115200); // Set Serial baud rate to 115200. Ensure Tools/USB_CDC_On_Boot is enabled if using Serial
 myCodeCell.Init(MOTION_ROTATION); // Initializes rotation sensing
 myservo.attach(1); // Attaches the servo on pin 1 to the servo object
 }

 void loop() {
 if (myCodeCell.Run()) {
 // Read rotation angles from the BNO085 sensor
 myCodeCell.Motion_RotationRead(Roll, Pitch, Yaw);

 // Convert the pitch angle to a servo angle 
servo_angle = abs((int)Pas);
 servo_angle = (180 - servo_angle);

 // Limitez l'angle du servo à la plage de 0 à 60 degrés
 si (servo_angle > 60) {
 servo_angle = 60;
 } sinon si (servo_angle < 0) {
 servo_angle = 0;
 }

 Serial.println(servo_angle); // Imprimer l'angle du servo pour le débogage
 myservo.write(servo_angle); // Définir la position du servo
 }
 }

Conseils de personnalisation

• Ajuster la plage : modifiez la plage de mouvement du servomoteur en fonction de votre servomoteur spécifique en ajustant les limites définies pour servo_angle dans le code. Dans cet exemple, nous utilisons un micro-servomoteur à plage de 60 degrés. Notez que certains servomoteurs ne sont pas mécaniquement linéaires, vous devrez donc peut-être également compenser son erreur angulaire-mécanique.
• Combinez avec d'autres capteurs : utilisez des capteurs supplémentaires, comme la détection de proximité et de lumière de CodeCell , pour ajouter des actions plus réactives à votre projet.
• Utiliser pour la stabilisation : implémentez cette configuration pour stabiliser les plates-formes, comme les cardans, afin de maintenir les appareils à niveau pendant le mouvement.

Conclusion

Ce projet présente les bases de l'utilisation de la détection de rotation avec CodeCell pour contrôler un servomoteur, ouvrant de nombreuses possibilités pour des projets sensibles au mouvement. Expérimentez avec le code, modifiez les paramètres et créez vos propres builds dynamiques !

Dans cette version, nous allons découvrir comment utiliser le capteur de mouvement à 9 axes intégré du CodeCell pour détecter les appuis. Ce projet montre comment utiliser la détection d'appui pour les commandes interactives, ce qui la rend parfaite pour créer des actions réactives avec un simple appui sur l'appareil.

Ce que vous apprendrez

• Comment configurer le CodeCell pour la détection de tapotement.
• Comment écrire du code pour détecter les robinets et contrôler les composants externes.
• Comprendre comment fonctionne le capteur de mouvement BNO085 de CodeCell pour la détection de tapotement.

À propos de la détection de contact de CodeCell

Le CodeCell est équipé d'un capteur de mouvement BNO085, qui offre une variété de capacités de détection, notamment la détection des appuis. Cette fonction utilise les données de l'accéléromètre pour détecter les appuis, ce qui la rend idéale pour les commandes interactives telles que l'activation et la désactivation de lumières, le déclenchement d'effets sonores ou d'autres actions basées sur un simple geste d'appui.

Comment fonctionne la détection de tapotement

Le capteur de mouvement BNO085 détecte les appuis en surveillant les accélérations soudaines le long de ses axes. Lorsqu'un appui est détecté, le capteur enregistre l'événement, ce qui vous permet de déclencher des actions telles que l'allumage d'une LED ou le basculement d'autres appareils. Cette fonctionnalité est particulièrement utile pour créer des interactions tactiles sans avoir recours à des boutons mécaniques.

Aperçu du projet

Dans cet exemple, le CodeCell surveille en permanence les appuis. Lorsqu'un appui est détecté, la LED intégrée s'allume en jaune pendant une seconde. Vous pouvez étendre cette fonctionnalité de base pour créer des interactions plus complexes, telles que le contrôle de plusieurs LED, moteurs ou autres appareils connectés en fonction des entrées d'appui.

Exemple 1 : Détection de tapotement de base

Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Assurez-vous que votre CodeCell est correctement connecté via USB-C et suivez les commentaires dans le code pour comprendre chaque étape.

 
#include <CodeCell.h>

 CodeCell myCodeCell;

 void setup() { 
Serial.begin(115200); // Définissez le débit en bauds série sur 115200. Assurez-vous que Tools/USB_CDC_On_Boot est activé si vous utilisez Serial
 myCodeCell.Init(MOTION_TAP_DETECTOR); // Initialise la détection de pression
 }

 boucle vide() {
 si (myCodeCell.Run()) {
 // S'exécute toutes les 100 ms pour vérifier les robinets
 si (myCodeCell.Motion_TapRead()) {
 // Si un tapotement est détecté, la LED s'allume en jaune pendant 1 seconde
 myCodeCell.LED(0xA0, 0x60, 0x00); // Définir la LED sur jaune
 delay(1000); // Gardez la LED allumée pendant 1 seconde
 }
 }
 }

Exemple de code 2 : Détection de prise + CoilCell

Dans l'exemple suivant, nous utilisons une CoilCell pour inverser sa polarité et actionner un point de retournement. Cela étend l'interactivité en utilisant la détection de tapotement pour contrôler les appareils externes, créant ainsi une réponse plus dynamique.

 
#include <CoilCell.h>
 #include <CodeCell.h>

 #define IN1_pin1 5
 #define IN1_pin2 6

 CoilCell myCoilCell(IN1_pin1, IN1_pin2);
 CodeCell myCodeCell;

 void setup() { 
Serial.begin(115200); // Définissez le débit en bauds série sur 115 200. Assurez-vous que Tools/USB_CDC_On_Boot est activé si vous utilisez Serial.
 myCodeCell.Init(MOTION_TAP_DETECTOR); // Initialise la détection de pression.
 myCoilCell.Init(); // Initialise le CoilCell.
 myCoilCell.Tone(); // Joue une tonalité pour confirmer l'initialisation.
 }

 boucle vide() {
 si (myCodeCell.Run()) {
 // S'exécute toutes les 100 ms pour vérifier les robinets.
 si (myCodeCell.Motion_TapRead()) {
 // Si un tapotement est détecté, faites briller la LED en jaune et inversez la polarité de la CoilCell.
 myCodeCell.LED(0xA0, 0x60, 0x00); // Définir la LED sur jaune.
 myCoilCell.Toggle(100); // Basculer la polarité de la CoilCell.
 delay(1000); // Délai pour maintenir la LED allumée et la polarité inversée pendant 1 seconde.
 }
 }
 }

Conseils de personnalisation

• Changer les couleurs des LED : expérimentez différentes couleurs de LED et utilisez les robinets pour augmenter la luminosité de la LED.
• Développer les actions : utilisez la détection de toucher pour déclencher d'autres appareils, tels que des buzzers, des moteurs ou des écrans, afin d'ajouter davantage de couches d'interactivité.
• Combinez avec d'autres capteurs : intégrez la détection de tapotement avec d'autres capteurs, comme la proximité ou la lumière, pour créer des projets réactifs multi-capteurs.

Conclusion

Ce projet présente les bases de l'utilisation de la détection de tapotement avec CodeCell . Expérimentez avec le code, personnalisez les réponses et explorez le potentiel de la détection de tapotement dans votre prochain projet !

Dans cette version, nous explorerons comment utiliser le capteur de proximité intégré du CodeCell pour détecter des objets.

Ce que vous apprendrez

• Comment configurer le CodeCell
• Comment écrire du code pour lire les données de proximité et contrôler la LED embarquée.
• Comprendre le fonctionnement du capteur de proximité VCNL4040 de CodeCell .

À propos du capteur de proximité de CodeCell

Le CodeCell est équipé d'un capteur VCNL4040 capable de mesurer la proximité jusqu'à 20 cm. Ce capteur utilise la communication I2C et est automatiquement initialisé via la bibliothèque CodeCell , ce qui permet une intégration transparente dans vos projets. Que vous cherchiez à ajouter un simple contrôle de la profondeur par gestes ou à détecter des objets à proximité, le VCNL4040 facilite l'ajout de la détection de proximité dans vos constructions.

Comment fonctionne la détection de proximité

Le capteur de proximité VCNL4040 utilise la lumière infrarouge pour détecter les objets à sa portée. Il mesure la réflexion de la lumière infrarouge émise pour évaluer la proximité d'un objet, ce qui vous permet de créer des comportements réactifs en fonction de la proximité. Cette fonctionnalité est particulièrement utile pour créer un éclairage interactif, des robots, des interrupteurs sans contact ou d'autres actions basées sur la proximité.

Aperçu du projet

Dans cet exemple, le CodeCell surveille en permanence les données de proximité et allume une LED rouge lorsqu'un objet est détecté. Vous pouvez étendre cette fonctionnalité de base pour créer des interactions plus complexes, telles que la variation de la couleur ou de la luminosité de la LED en fonction de la distance, ou le déclenchement de différentes actions en fonction de la proximité.

Exemple de code

Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Assurez-vous que votre CodeCell est correctement connecté via USB-C et suivez les commentaires dans le code pour comprendre chaque étape.

 
#include <CodeCell.h>

 CodeCell myCodeCell;

 void setup() {
 Serial.begin(115200); // Set Serial baud rate to 115200. Ensure Tools/USB_CDC_On_Boot is enabled if using Serial
 myCodeCell.Init(LIGHT); // Initializes light sensing, including proximity
 }

 void loop() {
 if (myCodeCell.Run()) {
 // Runs every 100ms to check proximity
 uint16_t proximity = myCodeCell.Light_ProximityRead();

 // Check if an object is within range
 if (proximity > 100) {
 myCodeCell.LED(0xFF, 0, 0); // Set LED to Red when proximity is detected
 delay(1000); // Keep the LED on for 1 second
 } else { 
// Aucune action si l'objet est hors de portée
 }
 }
 }

Conseils de personnalisation

• Ajuster le seuil de proximité : modifiez la valeur de seuil ( 100 dans l'exemple) pour ajuster la sensibilité de la détection de proximité en fonction de votre application.
• Changer les couleurs des LED : expérimentez différentes couleurs de LED à l'aide de la fonction myCodeCell.LED() pour créer des réponses multicolores à la proximité.
• Ajouter plus : envisagez d'ajouter un buzzer ou un moteur pour fournir un retour audio ou de mouvement lorsque des objets sont détectés à portée.
• Utilisez la proximité avec la détection de lumière : combinez la proximité et la détection de lumière pour créer des comportements plus complexes, tels que le réglage des lumières en fonction de la distance et des niveaux de lumière ambiante.

Conclusion

Ce projet présente les bases de l'utilisation de la détection de proximité avec CodeCell , ouvrant ainsi une gamme de possibilités interactives. Expérimentez avec le code, modifiez les paramètres et personnalisez-le !

Cliquez ici pour l’exemple suivant, où nous allons expérimenter l’utilisation de ce capteur de proximité pour les gestes de profondeur.

Dans cette version, nous allons découvrir comment utiliser le CodeCell pour détecter la lumière blanche et ajuster automatiquement la luminosité des LED. Ce projet présente le capteur de lumière intégré du CodeCell , qui vous aide à créer des effets d'éclairage réactifs qui s'adaptent aux conditions d'éclairage changeantes.

Ce que vous apprendrez

• Comment configurer le CodeCell
• Comment écrire le code pour lire les niveaux de lumière et contrôler la luminosité des LED.
• Comprendre le fonctionnement du capteur de lumière VCNL4040 de CodeCell .

À propos du capteur de lumière du CodeCell

Le CodeCell est doté d'un capteur VCNL4040 intégré qui peut mesurer à la fois les niveaux de lumière et la proximité jusqu'à 20 cm. Ce capteur utilise la communication I2C et communique avec l'ESP32 de la bibliothèque CodeCell , où le capteur est automatiquement initialisé pour optimiser sa résolution de détection. Cela simplifie la configuration, vous pouvez donc vous concentrer sur la construction de votre projet.

Détection de la lumière ambiante et détection de la lumière blanche

Le capteur VCNL4040 du CodeCell est capable de détecter à la fois la lumière ambiante et la lumière blanche, chacune servant à des fins distinctes :

• Détection de la lumière ambiante : ce mode mesure l'intensité lumineuse globale de toutes les sources de l'environnement, y compris la lumière naturelle et artificielle. Il est idéal pour les applications qui nécessitent une compréhension générale des niveaux de lumière dans un espace, comme le réglage de la luminosité de l'écran ou l'activation du mode nuit sur les appareils.
• Détection de lumière blanche : ce mode mesure spécifiquement l'intensité de la lumière blanche, ce qui est particulièrement utile lorsque l'objectif est d'évaluer des sources lumineuses qui ressemblent à la lumière du jour ou à l'éclairage LED. La détection de lumière blanche est utile dans les scénarios où vous souhaitez faire la distinction entre différentes conditions d'éclairage, par exemple pour séparer la lumière blanche des autres lumières colorées ou dans les situations où une température de couleur précise est importante.

Dans ce projet, nous utilisons la fonction de détection de lumière blanche pour influencer directement la luminosité des LED en fonction des niveaux de lumière blanche détectés, créant ainsi une réponse plus ciblée par rapport à la détection de lumière ambiante générale.

Aperçu du projet

Dans cet exemple, le CodeCell mesure en continu la lumière blanche ambiante et ajuste la luminosité d'une LED intégrée en fonction du niveau de lumière détecté. À mesure que la pièce s'assombrit, la LED s'atténue, offrant une transition en douceur que vous pouvez modifier et personnaliser pour vos propres projets d'éclairage.

Exemple de code

Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Assurez-vous que votre CodeCell est correctement connecté et suivez les commentaires dans le code pour comprendre chaque étape.

 
#include <CodeCell.h>

 CodeCell myCodeCell;

 void setup() {
 Serial.begin(115200); // Set Serial baud rate to 115200. Ensure Tools/USB_CDC_On_Boot is enabled if using Serial. 
myCodeCell.Init(LIGHT); // Initialise la détection de lumière.
 }

 boucle vide() {
 delay(100); // Petit délai - Vous pouvez l'ajuster en conséquence

 // Lisez la lumière blanche du capteur et ajustez la luminosité pour 8 bits
 uint16_t luminosité = (myCodeCell.Light_WhiteRead()) >> 3;
 Serial.println(brightness); // Imprime la valeur de luminosité sur le moniteur série pour le débogage.

 // Limiter les valeurs du capteur à la plage de luminosité de la LED (1 à 254)
 si (luminosité == 0U) {
 luminosité = 1U; // Définir une luminosité minimale pour éviter d'éteindre complètement la LED
 } sinon si (luminosité > 254U) {
 luminosité = 254U; // Limitez la luminosité au niveau maximum de la LED
 }

 luminosité = 255U - luminosité ; // Inverser la luminosité pour que la LED diminue à mesure qu'elle devient plus lumineuse
 myCodeCell.LED(0, 0, luminosité); // Faites briller la LED RVB bleue intégrée avec la nouvelle luminosité ajustée
 }

Conseils de personnalisation

• Ajuster la sensibilité de la luminosité : ajustez les limites de luminosité en fonction des niveaux de lumière de votre pièce.
• Modifier les couleurs des LED : la fonction myCodeCell.LED() vous permet de spécifier des valeurs RVB. Essayez d'expérimenter différentes couleurs en fonction des niveaux de lumière.
• Ajoutez plus de LED : connectez plus de LED ou même des NeoPixels pour plus d'effets d'éclairage et ajustez leur luminosité avec la même technique.
• Ajouter un contrôle de proximité : ajoutez le capteur de proximité pour ajouter des effets plus interactifs, comme des gestes de profondeur pour agir comme une commutation.

Conclusion

Ce projet n'est que le point de départ pour exploiter les capacités de détection de lumière du CodeCell . Plongez dans le code, faites-en votre propre et illuminez votre prochain projet !

Le CoilPad est un actionneur incroyablement fin et innovant qui apporte du mouvement à vos projets dans un format compact. Pour comprendre son fonctionnement, plongeons-nous dans sa conception unique et les principes qui sous-tendent son fonctionnement.

Dans ce tutoriel, nous expliquerons :

• Qu'est-ce qu'un CoilPad et comment ça marche ?
• Comment contrôler sa polarité, sa position et sa vitesse
• Fabrication du CoilPad plus interactif avec les capteurs CodeCell

Qu'est-ce qu'un CoilPad ?

Le CoilPad est un actionneur constitué d'une bobine plane flexible qui adhère parfaitement à toute surface lisse. En ajoutant un aimant, il se transforme en un appareil capable de mouvement magnétique, de bourdonnement ou même de chauffage. Il est conçu pour convertir facilement l'énergie électrique en mouvement mécanique.

Comment ça marche ?

Le CoilPad est doté d'une bobine plate et ultra-mince qui interagit avec des aimants externes. Lorsqu'un courant électrique traverse la bobine, il génère un champ magnétique qui attire ou repousse l'aimant, provoquant ainsi un mouvement. En alternant la direction du courant, vous pouvez contrôler le mouvement du CoilPad. L'application d'un signal d'onde carrée fait osciller le CoilPad en continu, avec une vitesse et une intensité réglables. Pour des mouvements organiques fluides, nous explorerons la bibliothèque DriveCell PWM.

Installation de CoilPad

La conception du CoilPad facilite son installation. Il est doté d'un dos adhésif pelable, garantissant qu'il reste fermement fixé sur toute surface lisse.

Faire bouger votre CoilPad

Vous pouvez commencer à le tester en tirant l'une de ses broches sur 5 V et l'autre sur la terre, puis en les intervertissant. Dans un cas, l'aimant sera repoussé et dans l'autre, il sera attiré. Vous pouvez le connecter à vos propres transistors ou à votre module de pont en H pour commuter ces broches automatiquement. Cependant, pour le rendre encore plus facile, vous pouvez acheter notre petit module DriveCell . Le DriveCell est un pilote de pont en H compact, compatible broche à broche, qui simplifie le processus de contrôle des actionneurs comme le CoilPad . Sa bibliothèque logicielle Arduino open source facilite le contrôle des actionneurs, en particulier pour les débutants, en fournissant des fonctions logicielles simples et des exemples faciles à suivre.

Pour un guide détaillé sur la bibliothèque logicielle DriveCell , consultez cet article . Mais voici un bref récapitulatif de la façon dont vous pouvez utiliser ses fonctions pour améliorer l'actionnement du CoilPad . Ne vous inquiétez pas, c'est assez simple ! Commencez par télécharger la bibliothèque « DriveCell » à partir du gestionnaire de bibliothèques d'Arduino. Une fois installée, vous serez prêt à contrôler votre appareil. Avant de commencer, assurez-vous de connecter le DriveCell à votre microcontrôleur. Nous vous recommandons d'utiliser un CodeCell, qui est compatible broche à broche, prend en charge toutes les fonctions de la bibliothèque et peut ajouter un contrôle sans fil et une détection interactive à votre CoilPad .

1. Init()

Tout d’abord, nous avons besoin d’un code de configuration de base pour vous permettre de démarrer :

 #include <DriveCell.h> // This line includes the DriveCell library

 DriveCell myCoilPad(IN1, IN2); // Replace IN1 and IN2 with your specific pins

 void setup() {
 myCoilPad.Init(); // Initializes your DriveCell connected to a CoilPad
 }

Ce code donne le nom « myCoilPad » à votre DriveCell et lui indique de démarrer et d'initialiser tous les périphériques nécessaires.

2. Impulsion (bool direction, uint8_t ms_duration)

Cette fonction envoie une brève décharge de puissance au CoilPad selon une polarité spécifiée. Cette mise sous tension et hors tension rapide peut provoquer un mouvement bref et brusque du CoilPad , selon la polarité.

myCoilPad.Pulse(1, 10); // Sends a short burst for 10 milliseconds in the specified direction

3. Buzz (uint16_t us_buzz)

Cette fonction fait vibrer le CoilPad comme un buzzer, ce qui est utile pour créer un retour sonore.

 myCoilPad.Buzz(100); // Makes the CoilPad buzz with a 100 microsecond pulses

4. Tonalité()

La fonction Tone permet au CoilPad de jouer un son. Elle peut être utilisée pour un retour sonore ou pour des applications créatives où le son fait partie de l'interaction.

 myCoilPad.Tone(); // Plays a tone by varying the frequency

5. Basculer(uint8_t power_percent)

Cette fonction bascule la polarité du CoilPad , ce qui peut être utile pour créer un mouvement de battement rapide ou inverser rapidement la direction dans votre code.

 myCoilPad.Toggle(100); // Toggles direction at 100% power

6. Exécuter(bool smooth, uint8_t power_percent, uint16_t flip_speed_ms)

Cette fonction vous permet d'inverser en continu la polarité du CoilPad et de contrôler sa vitesse de mouvement et sa fluidité. Si smooth est définie sur true , l'actionnement sera moins brusque et lissé, ce qui est idéal pour les mouvements plus lents et contrôlés.

 myCoilPad.Run(true, 50, 1000); // Runs the CoilPad smoothly at 50% power, flipping every 1000 milliseconds

7. Drive(bool direction, uint8_t power_percent)

Cette fonction vous permet de contrôler la polarité du CoilPad et l'intensité de son champ magnétique en ajustant le niveau de puissance.

 myCoilPad.Drive(true, 75); // Moves the CoilPad forward at 75% power

Exemples :

Voici un exemple où nous configurons deux CoilPads et les actionnons à deux vitesses différentes :

 #include <DriveCell.h>

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

 DriveCell CoilPad1(IN1_pin1, IN1_pin2);
 DriveCell CoilPad2(IN2_pin1, IN2_pin2);

 uint16_t c_counter = 0;

 void setup() {
 CoilPad1.Init();
 CoilPad2.Init();

 CoilPad1.Tone();
 CoilPad2.Tone();
 }

 void loop() {
 delay(1);
 c_counter++;
 if (c_counter < 2000U) {
 CoilPad1.Run(0, 100, 100);
 CoilPad2.Run(0, 100, 100);
 }
 else if (c_counter < 8000U) { 
CoilPad1.Run(1, 100, 1000);
 CoilPad2.Run(1, 100, 1000);
 } autre {
 c_counter = 0U;
 }
 }

Combinaison avec les capteurs CodeCell

Pour rendre le projet encore plus interactif, vous pouvez combiner le CoilPad et le DriveCell avec le minuscule module de capteur CodeCell. CodeCell est compatible broche à broche avec DriveCell , prend en charge toutes les fonctions de la bibliothèque et peut ajouter un contrôle sans fil et une détection interactive à votre projet. Cela vous permet de créer des éléments plus avancés et plus réactifs avec vos actionneurs CoilPad .

Avec cet exemple, le CodeCell contrôle deux CoilPad qui arrêtent de battre des ailes lorsqu'une proximité est détectée. Leur champ magnétique est ajusté de manière dynamique en fonction de la proximité de vos mains. Si aucune main n'est détectée, il inverse la polarité du CoilPad toutes les 400 millisecondes.

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

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

 DriveCell CoilPad1(IN1_pin1, IN1_pin2);
 DriveCell CoilPad2(IN2_pin1, IN2_pin2);

 CodeCell myCodeCell;

 void setup() {
 Serial.begin(115200);

 /* Set Serial baud rate to 115200. Ensure Tools/USB_CDC_On_Boot is enabled if using Serial. */
 
myCodeCell.Init(LIGHT); /*Initialise la détection de lumière*/

 CoilPad1.Init();
 CoilPad2.Init();

 CoilPad1.Tone();
 CoilPad2.Tone();
 }

 boucle vide() {
 si (myCodeCell.Run()) {
 /*S'exécute toutes les 100 ms*/
 uint16_t proximité = myCodeCell.Light_ProximityRead();
 Serial.println(proximité);
 si (proximité < 100) {
 CoilPad1.Run(1, 100, 400);
 CoilPad2.Run(1, 100, 400);
 } autre {
 proximité = proximité - 100 ;
 proximité = proximité / 10 ;
 si (proximité > 100) {
 proximité = 100;
 }
 CoilPad1.Drive(0, (proximité));
 CoilPad2.Drive(0, (proximité));
 }
 }
 }

N'hésitez pas à modifier le code avec vos propres idées créatives ou à ajouter une détection de mouvement pour une nouvelle réaction ! Commencez dès aujourd'hui avec nos bibliothèques Arduino ! Si vous avez d'autres questions sur le CoilPad, n'hésitez pas à nous envoyer un e-mail et nous serons heureux de vous aider !

Le FlatFlap est un actionneur incroyablement fin et innovant qui apporte du mouvement à vos projets dans un format compact. Pour comprendre son fonctionnement, plongeons-nous dans sa conception unique et les principes qui sous-tendent son fonctionnement.

Dans ce tutoriel, nous expliquerons :

• Qu'est-ce qu'un FlatFlap et comment ça marche ?
• Comment contrôler sa polarité, sa position et sa vitesse
• Fabriquer le FlatFlap plus interactif avec les capteurs CodeCell

Qu'est-ce qu'un FlatFlap ?

C'est plat et c'est un volet ~ le FlatFlap est un actionneur fabriqué à partir d'un circuit imprimé flexible et de raidisseurs en aluminium, pliés ensemble pour créer un mouvement de battement à faible force. Son système magnétique convertit l'énergie électrique en mouvement mécanique.

Comment ça marche ?

Le FlatFlap est doté d'un aimant en néodyme N52 fin de 10 mm à l'arrière, qui interagit avec la bobine de cuivre plane intégrée dans le PCB flexible. Lorsqu'un courant électrique traverse la bobine, il génère un petit champ magnétique qui attire ou repousse l'aimant, provoquant le mouvement du volet. En alternant la direction du courant, vous pouvez contrôler le mouvement de battement de l'actionneur. L'application d'un signal d'onde carrée permet au FlatFlap de se rabattre en continu, avec des vitesses allant jusqu'à 25 Hz. Pour des mouvements organiques fluides, nous explorerons la bibliothèque DriveCell PWM.

Installation de FlatFlap

La conception FlatFlap facilite l'installation. Il est doté d'un dos adhésif pelable et de vis M1.2 en option (incluses) pour plus de sécurité, garantissant qu'il reste fermement fixé à n'importe quelle surface, qu'elle soit lisse ou texturée. L'adhésif est 3M467, qui offre une forte adhérence mais peut être retiré avec une pince à épiler si nécessaire.

Faire bouger votre FlatFlap

Si vous avez acheté le FlatFlap en tant qu'actionneur autonome, vous pouvez commencer par tirer l'une de ses broches sur 5 V et l'autre sur la terre, puis les inverser. Dans un cas, le volet sera repoussé et dans l'autre, il sera attiré. Vous pouvez le connecter à vos propres transistors ou à votre module de pont en H pour commuter ces broches automatiquement. Cependant, pour rendre les choses encore plus faciles, vous pouvez acheter le FlatFlap directement soudé à notre petit module DriveCell . Le DriveCell est un pilote de pont en H compact, compatible broche à broche, qui simplifie le processus de contrôle des actionneurs comme le FlatFlap . Sa bibliothèque logicielle Arduino open source facilite le contrôle des actionneurs, en particulier pour les débutants, en fournissant des fonctions logicielles simples et des exemples faciles à suivre.

Pour un guide détaillé sur la bibliothèque logicielle DriveCell , consultez cet article . Mais voici un bref récapitulatif de la façon dont vous pouvez utiliser ses fonctions pour améliorer l'actionnement du FlatFlap . Ne vous inquiétez pas, c'est assez simple ! Commencez par télécharger la bibliothèque « DriveCell » à partir du gestionnaire de bibliothèques d'Arduino. Une fois installée, vous serez prêt à contrôler votre appareil. Avant de commencer, assurez-vous de connecter le DriveCell à votre microcontrôleur. Nous vous recommandons d'utiliser un CodeCell, qui est compatible broche à broche, prend en charge toutes les fonctions de la bibliothèque et peut ajouter un contrôle sans fil et une détection interactive à votre FlatFlap .

1. Init()

Nous avons d’abord besoin d’un code de configuration de base pour vous permettre de démarrer :

 #include <DriveCell.h> // This line includes the DriveCell library

 DriveCell myFlatFlap(IN1, IN2); // Replace IN1 and IN2 with your specific pins

 void setup() {
 myFlatFlap.Init(); // Initializes your DriveCell connected to a FlatFlap
 }

Ce code donne le nom « myFlatFlap » à votre DriveCell et lui indique de démarrer et d'initialiser tous les périphériques nécessaires.

2. Impulsion (bool direction, uint8_t ms_duration)

Cette fonction envoie une brève décharge de courant au FlatFlap selon une polarité spécifiée. Cette mise sous tension et hors tension rapide peut provoquer un mouvement bref et brusque du FlatFlap , selon la polarité.

 myFlatFlap.Pulse(1, 10); // Sends a short burst for 10 milliseconds in the specified direction

2. Buzz (uint16_t us_buzz)

Cette fonction fait vibrer le FlatFlap comme un buzzer, ce qui est utile pour créer un retour sonore.

 myFlatFlap.Buzz(100); // Makes the FlatFlap buzz with a 100 microsecond pulses

3. Tonalité()

La fonction Tone permet au FlatFlap de jouer un son. Elle peut être utilisée pour un retour sonore ou pour des applications créatives où le son fait partie de l'interaction.

 myFlatFlap.Tone(); // Plays a tone by varying the frequency

4. Basculer (uint8_t power_percent)

Cette fonction change la direction de FlatFlap , ce qui peut être utile pour créer un mouvement de battement rapide ou inverser rapidement la direction dans votre code.

 myFlatFlap.Toggle(100); // Toggles direction at 100% power

5. Exécuter(bool smooth, uint8_t power_percent, uint16_t flip_speed_ms)

Cette fonction vous permet d'inverser en continu la polarité du FlatFlap et de contrôler sa vitesse de mouvement et sa fluidité. Si smooth est défini sur true , le battement sera moins net et lissé, ce qui est idéal pour des mouvements plus lents et contrôlés.

 myFlatFlap.Run(true, 50, 1000); // Runs the FlatFlap smoothly at 50% power, flipping every 1000 milliseconds

6. Drive(bool direction, uint8_t power_percent)

Cette fonction vous permet de contrôler la polarité et la position angulaire du FlatFlap en ajustant le niveau de puissance, en ajustant essentiellement la force de l'attraction ou de la poussée magnétique.

myFlatFlap.Drive(true, 75); // Moves the FlatFlap forward at 75% power

Exemples :

Voici un exemple dans lequel nous configurons deux FlatFlaps et les faisons voleter à des vitesses différentes :

 #include <DriveCell.h>

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

 DriveCell FlatFlap1(IN1_pin1, IN1_pin2);
 DriveCell FlatFlap2(IN2_pin1, IN2_pin2);

 uint16_t flap_counter = 0;

 void setup() {
 FlatFlap1.Init();
 FlatFlap2.Init();

 FlatFlap1.Tone();
 FlatFlap2.Tone();
 }

 void loop() {
 delay(1);
 flap_counter++;
 if (flap_counter < 2000U) {
 FlatFlap1.Run(0, 100, 100);
 FlatFlap2.Run(0, 100, 100);
 }
 else if (flap_counter < 8000U) {
 FlatFlap1.Run(1, 100, 1000);
 FlatFlap2.Run(1, 100, 1000);
 } else {
 flap_counter = 0U;
 FlatFlap1.Drive(0, 100);
 FlatFlap2.Drive(1, 100);
 delay(500);
 FlatFlap1.Drive(1, 100);
 FlatFlap2.Drive(1, 100);
 delay(500);
 FlatFlap1.Drive(1, 100);
 FlatFlap2.Drive(0, 100);
 delay(500); 
FlatFlap1.Drive(1, 100);
 FlatFlap2.Drive(1, 100);
 délai(500);
 FlatFlap1.Drive(0, 100);
 FlatFlap2.Drive(0, 100);
 délai(500);
 FlatFlap1.Drive(1, 100);
 FlatFlap2.Drive(1, 100);
 délai(500);
 FlatFlap1.Tone();
 FlatFlap2.Tone();
 }
 } 

Combinaison avec les capteurs CodeCell

Pour rendre le projet encore plus interactif, vous pouvez combiner le FlatFlap et le DriveCell avec le minuscule module de capteur CodeCell. CodeCell est compatible broche à broche avec DriveCell , prend en charge toutes les fonctions de la bibliothèque et ajoute un contrôle sans fil et une détection interactive à votre projet. Cela vous permet de créer des éléments plus avancés et plus réactifs avec vos actionneurs FlatFlap .

Avec cet exemple, le CodeCell contrôle deux FlatFlap qui arrêtent de battre des ailes lorsqu'une proximité est détectée. Leur angle est ajusté de manière dynamique en fonction de la proximité de vos mains.

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

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

 DriveCell FlatFlap1(IN1_pin1, IN1_pin2);
 DriveCell FlatFlap2(IN2_pin1, IN2_pin2);

 CodeCell myCodeCell;

 void setup() {
 Serial.begin(115200); /* Set Serial baud rate to 115200. Ensure Tools/USB_CDC_On_Boot is enabled if using Serial. */

 myCodeCell.Init(LIGHT); /*Initializes Light Sensing*/

 FlatFlap1.Init();
 FlatFlap2.Init();

 FlatFlap1.Tone();
 FlatFlap2.Tone();
 }

 void loop() {
 if (myCodeCell.Run()) {
 /*Runs every 100ms*/
 uint16_t proximity = myCodeCell.Light_ProximityRead(); 
Serial.println(proximité);
 si (proximité < 100) {
 FlatFlap1.Run(1, 100, 400);
 FlatFlap2.Run(1, 100, 400);
 } autre {
 proximité = proximité - 100 ;
 proximité = proximité / 10 ;
 si (proximité > 100) {
 proximité = 100;
 }
 FlatFlap1.Drive(0, (proximité));
 FlatFlap2.Drive(0, (proximité));
 }
 }
 }

N'hésitez pas à modifier le code avec vos propres idées créatives ou à ajouter une détection de mouvement pour une nouvelle réaction ! Avec FlatFlap , vous pouvez donner vie à vos projets créatifs avec du mouvement dans un format compact et élégant. Que vous ajoutiez des éléments dynamiques à l'art, que vous expérimentiez la robotique ou que vous développiez des affichages mécaniques interactifs, le FlatFlap offre une solution polyvalente et facile à utiliser. Commencez dès aujourd'hui avec nos bibliothèques Arduino ! Si vous avez d'autres questions sur le FlatFlap, n'hésitez pas à nous envoyer un e-mail et nous serons heureux de vous aider !

CoilCell est une bobine planaire compacte conçue pour divers projets DIY. Que vous débutiez ou que vous soyez un maker expérimenté, CoilCell offre une intégration facile pour simplifier vos créations. Dans ce tutoriel, nous vous expliquerons :

• Qu'est-ce qu'un CoilCell et comment fonctionne-t-il ?
• Démarrer avec sa bibliothèque de logiciels Arduino
• Programmez une boule aimantée pour qu'elle rebondisse toutes les quelques millisecondes
• Rendre le CoilCell plus interactif avec les capteurs CodeCell

Qu'est-ce que CoilCell ?
CoilCell est une bobine mince et plane construite sur un PCB multicouche, avec un pilote intégré qui simplifie le contrôle de la polarité et de la force magnétiques. Elle est disponible en deux configurations :

• Bobine 1 WCell : 70 tours, avec un champ magnétique maximal de 2,3 mT.
• Bobine 2,5 W : 200 tours, avec un champ magnétique maximal de 10 mT, qui peut être mis à niveau jusqu'à 17 mT à l'aide d'une plaque arrière en fer.

Applications magnétiques

• Aimants N52 : utilisez des aimants à billes ou à disques N52 légers pour des interactions dynamiques telles que faire rebondir ou secouer des objets en trouvant leur fréquence de résonance.
• FlipDot : créez un pixel mécanique interactif en faisant pivoter un aimant pour le retourner. Construisez votre propre pixel FlipDot magnétique imprimé en 3D et ajoutez-en d'autres pour un mini affichage. Vos oreilles et vos yeux vont l'adorer !
• Plaque arrière en fer : améliorez la CoilCell de 2,5 W pour augmenter sa puissance maximale à 17 mT, la transformant en un électro-aimant faible adapté pour attirer de petits objets métalliques comme des trombones.
• Dés magnétiques : réalisez des tours amusants avec nos dés spéciaux contenant un aimant caché à l'intérieur, vous permettant de créer des secousses automatiques ou d'influencer le résultat du lancer avec le CoilCell de 2,5 W.

Conseils de sécurité
Lors de l'utilisation du CoilCell 2,5 W 200 tours, il peut potentiellement chauffer jusqu'à 110 °C, en particulier lorsqu'il est combiné avec la plaque arrière en fer. Suivez ces précautions :

• Gardez les mains éloignées des surfaces chaudes et éteignez la bobine lorsqu’elle n’est pas utilisée.
• Assurez-vous que les pièces et matériaux imprimés en 3D peuvent résister à des températures élevées.
• Utilisez également une protection des yeux lorsque vous travaillez avec de petits aimants qui peuvent être repoussés à grande vitesse.

Comment fonctionne CoilCell ?
CoilCell utilise une puce de pont en H DRV8837 intégrée pour contrôler le flux de courant à travers la bobine, lui permettant de changer de polarité magnétique :

• Nord : IN1 = VCC/PWM, IN2 = GND
• Sud : IN1 = GND, IN2 = VCC/PWM
• Désactivé : IN1 = GND, IN2 = GND

La puce DRV8837 offre une protection contre les surintensités, un verrouillage en cas de sous-tension et des fonctions d'arrêt thermique, garantissant un fonctionnement sûr.

Premiers pas avec CoilCell
Le câblage d'une des broches d'entrée sur VCC activera instantanément la CoilCell . Mais pour le rendre plus intelligent, nous avons également développé une bibliothèque de logiciels Arduino pour vous faciliter la mise en route.

Vous devrez écrire un code de base pour indiquer à CoilCell ce qu'il doit faire. Ne vous inquiétez pas, c'est assez simple ! Commencez par télécharger la bibliothèque « CoilCell » à partir du gestionnaire de bibliothèques de l'Arduino. Une fois celle-ci installée, nous sommes prêts à contrôler votre appareil. Il existe plusieurs exemples qui peuvent vous aider à démarrer, mais nous allons maintenant décomposer et comprendre toutes les fonctions :

Avant de commencer, assurez-vous de connecter le CoilCell à votre microcontrôleur. Nous vous recommandons d'utiliser un CodeCell compatible broche à broche, de la même taille, prenant en charge toutes les fonctions de la bibliothèque et pouvant ajouter un contrôle sans fil + une détection interactive.

1. Initialiser CoilCell

 #include <CoilCell.h>
 
CoilCell myCoilCell(IN1, IN2); // Remplacez IN1 et IN2 par vos broches spécifiques

 vide configuration() {
 myCoilCell.Init(); // Initialise la CoilCell
 }

Ce code configure le CoilCell , le configurant pour le contrôle magnétique en fonction de vos broches et de votre microcontrôleur sélectionnés.

La fonction Bounce() fait rebondir un aimant de haut en bas. Le premier paramètre définit la polarité de la CoilCell et le delay_ms définit la durée pendant laquelle l'aimant est repoussé.

 myCoilCell.Bounce(true, 20); //Bounce the magnet up for 20ms

3. Buzz (uint16_t us_buzz)
Créez un bourdonnement en alternant rapidement la polarité de la bobine. Ajustez « us_buzz » pour contrôler la fréquence du bourdonnement.

 myCoilCell.Buzz(80); // Generates a buzzing effect at 80 microseconds intervals

4. Tonalité()
Cette fonction joue une tonalité par défaut en faisant vibrer la CoilCell à différentes fréquences enregistrées.

 myCoilCell.Tone(); // Plays varying tones

5. Drive(bool direction, uint8_t power_percent)
En utilisant le CodeCell ou tout autre microcontrôleur ESP32, cette fonction permet de contrôler la polarité et la force magnétique de la bobine. La force magnétique est ajustée par le « power_percent », qui contrôle la distance à laquelle l'aimant est poussé par rapport à la bobine.

 myCoilCell.Drive(true, 75); // Drive the coil north with 75% strength

6. Basculer(uint8_t power_percent)
En utilisant le CodeCell ou tout autre microcontrôleur ESP32, cette fonction bascule la polarité de la bobine à un niveau de puissance défini, utile pour des actions de retournement magnétique simples.

 myCoilCell.Toggle(60); // Toggle polarity at 60% power

Pour les autres appareils Arduino, cette commande fait que la bobine inverse sa direction à pleine puissance.

 myCoilCell.Toggle(); // Toggle polarity at 100% power

7. Vibrer (bool lisse, uint8_t power_percent, uint16_t vib_speed_ms)

Cette fonction inverse la polarité de la bobine à une vitesse et une puissance spécifiées. Le réglage « smooth » sur true crée des mouvements plus fluides, idéaux pour les fréquences lentes inférieures à 2 Hz.

 myCoilCell.Vibrate(true, 50, 1000); // Smooth vibration at 50% power every 1000 ms

Pour les autres appareils Arduino, cette commande fait que la bobine inverse sa polarité à pleine puissance.

 myCoilCell.Vibrate(100); // Vibrate at 100% power every 100 ms

Voici un exemple où nous initialisons une CoilCell pour faire rebondir un aimant à bille de 5 mm de diamètre. Dans cet exemple, la CoilCell est initialisée avec les broches 5 et 6. La fonction setup() appelle myCoilCell.Init() pour configurer la CoilCell . Dans la fonction loop() , la fonction Bounce() est utilisée pour faire rebondir l'aimant vers le haut pendant 20 millisecondes, suivi d'un délai de 600 millisecondes qui attire l'aimant vers le bas.

#include <CoilCell.h>

 #define IN1_pin1 5
 #define IN1_pin2 6

 CoilCell myCoilCell(IN1_pin1, IN1_pin2);

 void setup() {
 myCoilCell.Init(); /*Initialize the CoilCell*/
 }

 void loop() {
 myCoilCell.Bounce(0, 20); /*Bounce the magnet up for 20ms*/
 delay(600); /*Attract the magnet back down for 600ms*/
 }

Dans l'exemple suivant, nous utilisons le capteur de mouvement du CodeCell pour détecter les tapotements. Lorsqu'un nouveau tapotement est détecté, le CoilCell inverse sa polarité magnétique et définit un délai d'une seconde pour faire clignoter la LED intégrée en jaune.

 #include <CodeCell.h>
 #include <CoilCell.h>

 #define IN1_pin1 5
 #define IN1_pin2 6

 CoilCell myCoilCell(IN1_pin1, IN1_pin2);
 CodeCell myCodeCell;
 
vide configuration() {
 Serial.begin(115200); /* Définissez le débit en bauds série sur 115 200. Assurez-vous que Tools/USB_CDC_On_Boot est activé si vous utilisez Serial. */

 myCodeCell.Init(MOTION_TAP_DETECTOR); /*Initialise la détection de pression*/
 maCoilCell.Init();
 maCelluleCoil.Tone();
 }

 boucle vide() {
 si (myCodeCell.Run()) {
 /*S'exécute toutes les 100 ms*/
 si (myCodeCell.Motion_TapRead()) {
 /*Si Tap est détecté, la LED s'allume en jaune pendant 1 seconde et inverse la polarité de la CoilCell*/
 monCodeCell.LED(0XA0, 0x60, 0x00U);
 maCoilCell.Toggle(100);
 délai(1000);
 }
 }
 }

Grâce à ces fonctions de base, vous pouvez commencer à expérimenter CoilCell dans vos projets. Que vous contrôliez des aimants, créiez des affichages interactifs ou expérimentiez des forces magnétiques, CoilCell offre une solution simple et efficace.

Si vous avez d'autres questions sur le CoilCell, n'hésitez pas à nous envoyer un e-mail et nous serons heureux de vous aider !

DriveCell est un appareil petit mais puissant qui vous permet de contrôler facilement les moteurs, les actionneurs et les lumières LED haute puissance pour vos projets de bricolage. DriveCell facilite le contrôle de ces composants, même si vous débutez en programmation ou en électronique.

Dans ce tutoriel, nous expliquerons :

• Qu'est-ce qu'un DriveCell et comment fonctionne-t-il ?
• Démarrer avec sa bibliothèque de logiciels Arduino
• Contrôlez deux moteurs à courant continu et entraînez-les à des vitesses différentes
• Fabriquer le DriveCell plus interactif avec les capteurs CodeCell

Qu'est-ce que DriveCell ?
Imaginez que vous vouliez fabriquer un petit robot et contrôler la vitesse et la direction de son moteur. Cela peut être complexe pour les débutants et nécessite généralement des modules volumineux. DriveCell simplifie ce processus car :

• C'est un pilote super petit (à peu près de la taille du bout de votre doigt)
• Peut être facilement soudé avec des broches en forme de C
• Fonctionne avec les microcontrôleurs Arduino et dispose de fonctions faciles à utiliser qui vous permettent de contrôler directement les moteurs, les actionneurs et les LED sans plonger dans une programmation compliquée.

Comment fonctionne DriveCell ?
DriveCell utilise une puce de pont en H DRV8837 intégrée pour contrôler le flux de courant à travers les broches de sortie, contrôlé par l'état des broches d'entrée :

• Courant direct : IN1 = VCC/PWM, IN2 = GND
• Courant inverse : IN1 = GND, IN2 = VCC/PWM
• Désactivé: IN1 = MASSE, IN2 = MASSE

La puce DRV8837 offre une protection contre les surintensités, un verrouillage en cas de sous-tension et des fonctions d'arrêt thermique, garantissant un fonctionnement sûr.

Premiers pas avec DriveCell
Avant de pouvoir commencer à utiliser DriveCell , vous devez le configurer et le connecter à votre projet. Voici un guide simple pour vous aider à démarrer :

• Connexion de DriveCell :

• Codage DriveCell :

1. Init()

Nous avons d’abord besoin d’un code de configuration de base pour vous permettre de démarrer :

 #include <DriveCell.h> // This line includes the DriveCell library

 DriveCell myDriveCell(IN1, IN2); // Replace IN1 and IN2 with your specific pins

 void setup() {
 myDriveCell.Init(); // Initializes the DriveCell
 }

Ce code indique au DriveCell de démarrer et de se préparer à contrôler votre moteur ou votre actionneur. La fonction Init s'assure que tous les périphériques nécessaires sont configurés.

2. Impulsion (bool direction, uint8_t ms_duration)

Cette commande envoie une courte rafale de puissance dans une polarité spécifiée, pour dynamiser rapidement l'actionneur et le réteindre.

 myDriveCell.Pulse(true, 10); // Short burst for 10 milliseconds

3. Buzz (uint16_t us_buzz)
Cela fait vibrer l'actionneur comme un buzzer. C'est idéal pour créer des sons de retour.

 myDriveCell.Buzz(100); // Creates a 100us buzzing sound

4. Tonalité()
Cette fonction émet une tonalité par défaut en faisant vibrer l'actionneur à différentes fréquences enregistrées.

 myDriveCell.Tone(); // Plays varying tones

5. Basculer(uint8_t power_percent)
Cette fonction change simplement le sens de rotation à 100 % de puissance, ce qui peut être utile pour inverser le sens de rotation d'un moteur à balais ou créer de simples mouvements de battement.

 myDriveCell.Toggle(); // Switches direction

En utilisant le CodeCell ou tout autre microcontrôleur ESP32, vous pouvez également ajuster le rapport cyclique « power_percent ». Pour les actionneurs magnétiques, le « power_percent » contrôle la force magnétique, tandis que pour les moteurs à balais, il ajuste la vitesse.

6. Exécuter(bool smooth, uint8_t power_percent, uint16_t flip_speed_ms)

En utilisant le CodeCell ou tout autre microcontrôleur ESP32, cette fonction vous permet d'inverser la polarité d'un actionneur ou d'inverser un moteur toutes les « flip_speed_ms » au cycle de service « power_percent ». Le réglage de « smooth » sur 1 adoucit le mouvement, ce qui est idéal pour piloter le FlatFlap ou le CoilPad avec des mouvements lents (moins de 2 Hz).

 myDriveCell.Run(true, 50, 1000); // Smooth drive at 50% power every 1000 ms

Pour les autres appareils Arduino, cette commande permet au moteur/actionneur d'inverser sa direction (vers l'avant et vers l'arrière) à pleine vitesse. Par exemple :

 myDriveCell.Run(500); // Motor changes direction every 500 milliseconds

7. Drive(bool direction, uint8_t power_percent)
En utilisant le CodeCell ou tout autre microcontrôleur ESP32, cette fonction vous permet de contrôler la vitesse et la direction de votre moteur. Vous pouvez faire avancer ou reculer le moteur et ajuster sa vitesse.

 myDriveCell.Drive(true, 75); // Moves forward at 75% power

Exemples :

En utilisant l'une de ces fonctions dans une boucle, vous pouvez créer la séquence souhaitée pour votre moteur, votre actionneur ou vos LED haute puissance. Voici un exemple où nous initialisons deux moteurs à courant continu et les pilotons à des vitesses différentes :

 #include <DriveCell.h>

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

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

 uint8_t mode = 0;
 uint8_t speed_percentage = 0;

 void setup() {
 Motor1.Init();
 Motor2.Init(); 
speed_percentage = 80; /* Régler le moteur à 80 % de puissance */
 }

 boucle vide() {
 délai(3000);
 mode++;
 commutateur (mode) {
 cas 1:
 /* Avancer */
 Motor1.Drive(1, pourcentage_vitesse);
 Motor2.Drive(1, pourcentage_vitesse);
 casser;
 cas 2:
 /* Déplacer vers l'arrière */
 Motor1.Drive(0, pourcentage_vitesse);
 Motor2.Drive(0, pourcentage_vitesse);
 casser;
 cas 3:
 /* Tourner à gauche */
 Motor1.Drive(1, pourcentage_vitesse);
 Motor2.Drive(0, pourcentage_vitesse);
 casser;
 cas 4:
 /* Tournez à droite */
 Motor1.Drive(0, pourcentage_vitesse);
 Motor2.Drive(1, pourcentage_vitesse);
 casser;
 cas 5:
 /* Éteignez les deux moteurs */
 Moteur1.Drive(1, 0);
 Moteur2.Drive(1, 0);
 si (pourcentage_vitesse < 95) {
 speed_percentage += 5; /* Incrémenter la vitesse */
 } autre {
 speed_percentage = 50; /* Réinitialiser à 50 % de puissance */
 }
 mode = 0;
 casser;
 }
 }

Dans l'exemple suivant, nous utilisons le capteur de proximité du CodeCell pour activer les moteurs. Ce capteur agira comme un interrupteur gestuel et s'activera lorsqu'une main se trouvera à moins de 5 cm.

 #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);

 uint8_t speed_percentage = 0;
 bool on_flag = 0;

 void setup() {
 Serial.begin(115200); /* Set Serial baud rate to 115200. Ensure Tools/USB_CDC_On_Boot is enabled if using Serial. */

 myCodeCell.Init(LIGHT); /*Initializes Light Sensing*/
 Motor1.Init();
 Motor2.Init();
 speed_percentage = 100;
 }

 void loop() {
 if (myCodeCell.Run()) {
 /*Runs every 100ms - Put your code here*/
 if (myCodeCell.Light_ProximityRead() > 3000) { 
/*Si un tapotement est détecté, la LED s'allume en jaune pendant 1 seconde*/
 monCodeCell.LED(0XA0, 0x60, 0x00U);
 Moteur1.Drive(0, 0);
 Moteur2.Drive(0, 0);
 délai(1000);
 sur_drapeau = !sur_drapeau;
 }
 si (sur_drapeau) {
 /*Avancer*/
 Motor1.Drive(1, pourcentage_vitesse);
 Motor2.Drive(1, pourcentage_vitesse);
 } autre {
 Moteur1.Drive(0, 0);
 Moteur2.Drive(0, 0);
 }
 }
 }

Si vous avez d'autres questions sur le DriveCell, n'hésitez pas à nous envoyer un e-mail et nous serons heureux de vous aider !

Le FlatFlap est un actionneur incroyablement fin et innovant qui apporte du mouvement à vos projets dans un format compact. Pour comprendre son fonctionnement, plongeons dans sa conception unique et les principes qui sous-tendent son fonctionnement.

La structure

Le FlatFlap est conçu à partir d'un circuit imprimé flexible et de raidisseurs en aluminium. Ces composants sont soigneusement pliés ensemble pour former l'actionneur.

Le PCB flexible sert de base à l'actionneur. Contrairement aux PCB rigides, la version flexible peut se plier et se tordre sans se casser, ce qui est essentiel pour créer le mouvement de battement. La flexibilité du PCB permet au FlatFlap de se déplacer librement tout en conservant son intégrité structurelle.

Les raidisseurs en aluminium fournissent la rigidité nécessaire pour maintenir l'aimant qui dirige le mouvement de battement, garantissant que le mouvement est à la fois précis et cohérent.

Le système magnétique

Le FlatFlap est alimenté par un système magnétique intelligent qui convertit l'énergie électrique en mouvement mécanique. Ce système se compose d'un aimant à l'arrière de l'actionneur et d'une bobine en cuivre plane intégrée dans le circuit imprimé flexible.

Le FlatFlap est doté d'un aimant en néodyme N52 de 10 mm fixé à l'arrière. Cet aimant joue un rôle crucial dans le fonctionnement de l'actionneur, en interagissant avec le champ magnétique généré par la bobine en cuivre. Cette bobine se trouve à l'intérieur du PCB flexible et est responsable de la création du champ magnétique lorsqu'un courant électrique la traverse. Le mouvement de battement est obtenu en pulsant le courant à travers la bobine en cuivre dans différentes directions.

En fonction du sens du courant, ce champ magnétique interagit avec l'aimant situé à l'arrière du FlatFlap. En alternant le sens du courant, le champ magnétique peut soit attirer, soit repousser l'aimant, ce qui provoque le déplacement du FlatFlap. La tension peut également être modifiée via PWM, pour contrôler la distance entre la bobine et l'aimant.

En pulsant rapidement le courant dans différentes directions, créant ainsi une onde carrée, le FlatFlap peut produire un mouvement de battement continu. La vitesse et la fréquence de ce mouvement peuvent être contrôlées en ajustant la vitesse à laquelle le courant est pulsé. Dans sa configuration optimale, le FlatFlap peut atteindre une vitesse allant jusqu'à 25 Hz, créant un mouvement rapide et réactif.

Fixation facile et installation sécurisée

L'installation du FlatFlap est un jeu d'enfant grâce à son dos adhésif pelable et à ses vis en option. L'adhésif assure une liaison solide qui maintient l'actionneur bien en place, tandis que les vis offrent une couche de sécurité supplémentaire si nécessaire. Cette double méthode d'installation garantit une adhérence parfaite, que vous fixiez le FlatFlap sur une surface lisse ou sur quelque chose de plus texturé.

Conception ultra-mince et compacte

L'une des caractéristiques les plus remarquables du FlatFlap est son profil incroyablement fin. Avec un rabat de seulement 0,3 mm d'épaisseur et un actionneur mesurant seulement 2,6 mm, ce design élégant peut s'intégrer parfaitement à n'importe quelle surface plane. Son profil bas garantit qu'il n'interfère pas avec l'esthétique de votre projet, ce qui le rend idéal pour les applications où l'espace est limité.

Le FlatFlap est parfait pour une large gamme d'applications. Il est particulièrement adapté à la création de sculptures cinétiques et à l'expérimentation robotique. Sa capacité à ajouter un mouvement accrocheur à des objets légers, tels que du plastique fin imprimé en 3D ou de l'origami en papier, ouvre un monde de possibilités créatives.

Un moteur PCB est une solution innovante qui intègre la mécanique du moteur dans les composants électroniques, en utilisant le PCB lui-même comme structure du moteur.

Qu'est-ce qu'un moteur PCB ?

Un moteur PCB est un type de moteur unique qui utilise les traces de cuivre sur un circuit imprimé (PCB) pour créer un champ magnétique qui entraîne le moteur. Ce concept s'inspire de la façon dont les systèmes radio utilisent les traces de PCB comme antennes. Le même principe est appliqué pour générer un champ magnétique suffisamment puissant pour faire tourner un rotor. Ce type de moteur est connu sous le nom de moteur sans balai à flux axial, où le stator PCB et le rotor sont alignés en parallèle.

La conception et la construction d'un moteur PCB
La première étape de la création d'un moteur PCB consiste à concevoir les bobines du stator PCB. Dans les moteurs traditionnels, ces bobines sont souvent constituées de fils enroulés en formes tridimensionnelles denses. Dans un moteur PCB, les bobines sont plutôt fabriquées sous forme de traces en spirale plates imprimées sur les couches d'un PCB.

L'un des défis de ces moteurs planaires est de placer suffisamment de spires dans le petit espace disponible pour générer un flux magnétique suffisant. Ces bobines doivent être connectées dans une configuration en étoile ou en triangle pour créer un système triphasé. Dans notre conception MotorCell à 6 fentes configurée en étoile, nous avons pu empiler les bobines sur quatre couches, en utilisant deux couches supplémentaires pour le contrôleur, afin de produire le champ magnétique requis pour faire tourner le rotor.

Au fil des années, nous avons également appris que la conception du rotor est cruciale pour améliorer l'efficacité du moteur. Il est important d'utiliser des roulements à billes en céramique de haute qualité et d'aligner les roulements avec précision pour obtenir la solution mécanique optimale. Cela nécessite généralement des outils spécialisés, c'est pourquoi nous proposons également le rotor du MotorCell individuellement, ce qui vous permet de l'intégrer facilement à votre PCB personnalisé.

Réalisation de la synchronisation dans le moteur PCB
L'un des aspects les plus critiques de la conduite d'un moteur sans balais est de s'assurer que le rotor reste synchronisé avec le champ électromagnétique du stator. Dans les moteurs traditionnels à balais, la synchronisation est gérée mécaniquement par les balais eux-mêmes. Cependant, dans un moteur sans balais triphasé comme un moteur PCB, un retour sensoriel est nécessaire pour assurer le bon fonctionnement du moteur.

La force contre-électromotrice est généralement utilisée comme rétroaction pour contrôler la vitesse du moteur. La force contre-électromotrice est la tension générée par le moteur en rotation lui-même, qui peut être mesurée pour déterminer la vitesse du rotor. Ces informations sont ensuite transmises à l'électronique de commande du moteur, garantissant que les bobines du stator sont entraînées en synchronisation avec le mouvement du rotor. Pour le MotorCell , tout cela est géré directement par la puce embarquée, ce qui simplifie le processus.