L'efficacité énergétique est cruciale pour de nombreuses applications embarquées, notamment celles fonctionnant sur batterie. Dans ce guide, nous expliquons comment mettre CodeCell en mode veille basse consommation et le réactiver à l'aide d'un capteur de proximité.
Pour les applications nécessitant une coupure complète de l'alimentation, vous pouvez ajouter un interrupteur en série avec la batterie. Cela vous permet d'allumer et d'éteindre manuellement l'appareil. Vous pouvez également mettre CodeCell en veille et le réactiver en cas d'activité des capteurs.
CodeCell présente un courant de veille moyen de 689 μA. Bien que ce soit supérieur aux exigences de certaines applications à très faible consommation, nous travaillons activement à optimiser la consommation d'énergie de la prochaine version, tout en conservant la même taille.
En raison de la petite taille et du nombre limité de broches de l'ESP32C3, nous n'avons pas pu inclure de broche d'interruption dédiée aux capteurs pour réveiller l'appareil. Bien qu'une véritable interruption matérielle soit idéale, vous pouvez toujours mettre CodeCell en veille en vérifiant régulièrement l'activité des capteurs avant de le réveiller.
Le code suivant illustre comment CodeCell entre en mode veille et se réveille lorsque la proximité est détectée.
#include <CodeCell.h>
CodeCell myCodeCell;
void setup() {
Serial.begin(115200);
delay(60); // Waking up from Sleep - add a small delay for Serial
if (myCodeCell.WakeUpCheck()) {
// Initialize light sensor
while (myCodeCell.Light_Init() == 1) {
delay(1);
myCodeCell.LightReset(); // If sensor not responding, reset it
}
delay(40);
myCodeCell.Light_Read(); // Read value from light sensor
if (myCodeCell.Light_ProximityRead() < 10) {
myCodeCell.Sleep(1); // Si la proximité n'est toujours pas détectée, retournez en mode veille et vérifiez à nouveau après 1 seconde
}
}
myCodeCell.Init(LIGHT); // Heure de réveil - Initialise tous les périphériques CodeCell
}
boucle vide() {
if (myCodeCell.Run(10)) { // Exécuter toutes les 10 Hz
si (myCodeCell.Light_ProximityRead() < 10) {
myCodeCell.Sleep(1); // Si la proximité n'est pas détectée, mettez-vous en veille et vérifiez à nouveau après 1 seconde
}
}
}
Comment ça marche :
Au démarrage, CodeCell initialise le capteur de lumière et vérifie la proximité.
Si aucune proximité n'est détectée, CodeCell entre en mode veille pendant 1 seconde.
Chaque seconde, CodeCell se réveille brièvement, vérifie la proximité et se rendort si nécessaire.
Si une proximité est détectée, CodeCell se réveille complètement et initialise tous les périphériques.
Grâce à cet exemple, vous pouvez réaliser d'importantes économies d'énergie avec CodeCell, le rendant ainsi plus adapté aux applications alimentées par batterie. Nous travaillons en permanence à l'optimisation de CodeCell pour les applications basse consommation. Restez à l'affût des mises à jour et des améliorations !
Dans ce guide, nous découvrirons comment utiliser le CodeCell pour mesurer directement sa rotation en lisant les angles de roulis, de tangage et de lacet. La compréhension de ces angles est essentielle dans des applications comme la robotique, les drones et le suivi de mouvement, où des données d'orientation précises sont nécessaires.
CodeCell est équipé d'un capteur de mouvement BNO085 , qui fusionne les données d'un accéléromètre, d'un gyroscope et d'un magnétomètre pour calculer des vecteurs de rotation. Ces vecteurs permettent de déterminer l'orientation de l'appareil dans l'espace en termes de roulis, de tangage et de lacet :
En surveillant en permanence ces valeurs, CodeCell fournit un retour d'orientation en temps réel, ce qui le rend utile pour une variété d'applications basées sur le mouvement.
Pour lire les angles de rotation, suivez cet exemple simple. Ce code initialise le capteur de mouvement de CodeCell et imprime en continu les valeurs de roulis, de tangage et de lacet sur le moniteur série.
#include <CodeCell.h>
CodeCell myCodeCell;
float Roll = 0.0;
float Pitch = 0.0;
float Yaw = 0.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
}
void loop() {
if (myCodeCell.Run(10)) { // Run every 10Hz
myCodeCell.Motion_RotationRead(Roll, Pitch, Yaw);
Serial.printf("Roll: %.2f°, Pitch: %.2f°, Yaw: %.2f°\n", Roll, Pitch, Yaw);
}
}
Explication du Code :
Initialisez le capteur de mouvement CodeCell pour lire les valeurs de rotation.
Exécutez le capteur à 10 Hz (toutes les 100 ms) pour obtenir des données actualisées.
Imprimez les angles de roulis, de tangage et de lacet en degrés sur le moniteur série.
Cela fournit un moyen précis de mesurer l’orientation de CodeCell en temps réel.
Une application pratique de la lecture du roulis, du tangage et du lacet consiste à contrôler un servomoteur en fonction de l'orientation de CodeCell. L'exemple suivant associe l'angle de tangage à la position du servomoteur.
#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
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(10)) {
// 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)Pitch);
servo_angle = (180 - servo_angle);
// Limiter 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
}
}
Explication:
Cartographie l'angle de pas pour contrôler la position du servo.
Limite l'angle du servo à une plage de sécurité (0 à 60 degrés) pour éviter tout mouvement excessif.
Utilise des mises à jour de 10 Hz pour maintenir une réponse fluide.
En lisant directement le roulis, le tangage et le lacet, vous pouvez débloquer des applications avancées basées sur le mouvement avec CodeCell. Essayez de modifier les exemples et de les intégrer à vos propres projets. Consultez le dépôt GitHub de CodeCell pour plus d'exemples et de documentation technique !
Le CodeCell offre une grande flexibilité d'alimentation, permettant de l'alimenter via le connecteur de la batterie LiPo, un câble USB-C, ou les deux simultanément. Cela garantit une adaptabilité à différents cas d'utilisation.
La gestion de l'alimentation est assurée par la puce de gestion de batterie BQ24232 , qui prend en charge la gestion dynamique du chemin d'alimentation (DPPM). Cela permet au CodeCell de fonctionner sur une alimentation externe tout en chargeant la batterie. Le processus de charge de la batterie se déroule en trois phases principales :
La puce BQ24232 régule la tension de sortie, prenant en charge une sortie maximale de 1500 mA lorsqu'elle est alimentée par la batterie LiPo et 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 courant est optimisé pour la batterie LiPo 170 mAh en option, garantissant une charge sûre et équilibrée.
Les utilisateurs avancés souhaitant modifier le courant de charge peuvent remplacer la résistance R12 du 0402. Cependant, cette modification nécessite des compétences de soudure précises, car les composants 0402 sont extrêmement compacts. Pour plus de détails, consultez la fiche technique du BQ24232.
La bibliothèque CodeCell fournit un retour visuel sur l'état de charge et d'alimentation à l'aide de la LED RVB intégrée :
Pour lire l'état d'alimentation du CodeCell, les utilisateurs peuvent utiliser la fonction PowerStateRead() :
Remarque : Cette fonctionnalité est disponible à partir de la version 1.2.8 du logiciel. Assurez-vous donc d'avoir mis à jour le micrologiciel. Le CodeCell reste opérationnel pendant la charge de la batterie. Si vous souhaitez interrompre son fonctionnement, nous vous recommandons de vérifier l'état de l'alimentation.
Pour lire la tension de la batterie, vous pouvez utiliser la fonction BatteryVoltageRead() ou BatteryLevelRead() pour lire le pourcentage de la batterie.
Pour BatteryLevelRead() , la valeur renvoyée est comprise entre 1 et 100 % . Si la batterie est en charge, la valeur renvoyée est 101 ; si le CodeCell est alimenté uniquement par USB sans batterie, la valeur renvoyée est 102 .
Grâce à ces informations, vous avez désormais une compréhension complète du fonctionnement du système de facturation de CodeCell, y compris ses comportements par défaut et ses options de personnalisation !
CodeCell est un module compact intégrant l'ESP32-C3, de multiples options d'alimentation et des capteurs intégrés, le tout dans un format compact de 1,85 cm de large. Ces caractéristiques en font un outil puissant pour un large éventail d'applications.
Dans cette première section, nous commencerons par nous familiariser avec les circuits qui composent le CodeCell. Ensuite, nous vous expliquerons les étapes simples de configuration de votre CodeCell.
Pour suivre le circuit plus en détail, consultez les schémas CodeCell ici .
Au cœur du CodeCell se trouve le module ESP32-C3, un microcontrôleur compact reconnu pour sa facilité d'utilisation dans le domaine de l'IoT. Il associe une architecture compatible Arduino à des fonctionnalités Wi-Fi et Bluetooth Low Energy (BLE) intégrées.
L'antenne PCB du module ESP32-C3 est positionnée sur un côté, à l'écart des autres composants, afin de minimiser les interférences et d'améliorer la transmission et la réception du signal. Ce positionnement permet de réduire l'impact des plans de masse ou autres surfaces conductrices, susceptibles de dégrader les performances de l'antenne. Les tests ont montré que les performances de l'antenne restent inchangées dans les applications alimentées par batterie, avec des interférences minimales lors du branchement du câble USB-C pour la charge, ces câbles étant généralement blindés.
L'ESP32-C3 dispose de 4 Mo de mémoire Flash et de 400 Ko de SRAM, lui permettant d'exécuter la plupart des applications. Son processeur monocœur RISC-V 32 bits, cadencé jusqu'à 160 MHz, gère efficacement diverses tâches. L'ESP32-C3 intègre également un contrôleur USB série/JTAG, permettant la reflashabilité de CodeCell via le port USB-C et facilitant la communication série et le débogage.
Le CodeCell offre une grande flexibilité d'alimentation. Il peut être alimenté par le connecteur de la batterie LiPo, par un câble USB-C, ou par les deux.
La gestion de l'alimentation est assurée par la puce de gestion de batterie BQ24232, qui prend en charge la gestion dynamique du chemin d'alimentation (DPPM). Cela permet d'alimenter le CodeCell tout en chargeant la batterie. Le processus de charge de la batterie se déroule en trois phases :
La tension de sortie est régulée via la puce BQ24232, prenant en charge jusqu'à 1500 mA lorsqu'elle est alimentée par la batterie LiPo et 450 mA via USB.
Par défaut, le courant de charge de la batterie LiPo est réglé à 90 mA afin de garantir un taux de charge sûr pour la batterie LiPo optionnelle de 170 mAh. Les utilisateurs expérimentés peuvent ajuster ce taux en remplaçant la résistance 0402 R12, selon la formule R = 870/Ichrg. Cette modification est recommandée uniquement aux personnes expérimentées dans le soudage de composants 0402. Consultez la fiche technique du BQ24232 pour plus de détails.
La bibliothèque CodeCell fournit un retour visuel sur l'état de l'alimentation via la LED RVB adressable intégrée :
La carte comprend également des condensateurs de 100 µF pour une alimentation stable et des diodes TVS pour la protection contre les décharges électrostatiques. Un régulateur à faible chute de tension (LDO) de 3,3 V (NCP177) fournit une sortie stable de 500 mA avec une chute de tension de 200 mV à courant maximal.
La conception compacte du CodeCell a nécessité un positionnement précis des broches GPIO et d'alimentation. La carte est divisée en sections fonctionnelles :
Le CodeCell est équipé de capteurs embarqués pour améliorer ses fonctionnalités :
Capteur de lumière VCNL4040 :
Capteur de mouvement BNO085 9 axes en option :
Notre bibliothèque CodeCell simplifie la configuration des capteurs et la lecture de chaque capteur.
De nombreuses cartes de développement ESP32 incluent des boutons RST (Reset) et BOOT . Cependant, l'ESP32-C3 sur CodeCell peut passer automatiquement en mode boot via l'IDE Arduino, éliminant ainsi ces boutons et permettant un format plus compact.
Si le CodeCell rencontre une exception (provoquant des réinitialisations continues), il peut être forcé manuellement en mode de démarrage pour le reflashage :
En suivant ces étapes, le CodeCell reprendra vie.
Chaque package CodeCell comprend :
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 :
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 via 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 :
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.
GPIO et broches 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és 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 !
Nous verrons ensuite comment la bibliothèque CodeCell simplifie à la fois la configuration de ces capteurs et la lecture de leurs données.
Qu'en est-il de la broche BOOT ?
Certaines cartes de développement ESP32 incluent à la fois un bouton RST (Reset) et un bouton BOOT pour mettre manuellement l'appareil en mode programmation. Cependant, l'ESP32-C3, comme celui du module CodeCell, peut entrer automatiquement en mode boot via l'interface série lors de l'utilisation de l'IDE Arduino. Cela signifie que le CodeCell n'a pas besoin de boutons RST ou BOOT dédiés, ce qui nous a permis de le rendre aussi petit qu'il l'est.
Dans le cas rare où votre CodeCell se bloque ou rencontre une exception (le forçant à se réinitialiser en permanence), vous pouvez le forcer manuellement à passer en mode démarrage pour reflasher le firmware. Pour ce faire, suivez simplement ces étapes :
En suivant ces étapes, votre CodeCell retrouvera sa vie.
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 :
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 :
Configuration de votre CodeCell
L'étape suivante consiste à connecter le CodeCell à l'IDE Arduino et à exécuter un croquis :
Une fois votre IDE configuré, nous pouvons maintenant procéder à l'installation de la bibliothèque « CodeCell ». Pour ce faire, allez dans « 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 :
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 :
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:
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 :
Fonctions du capteur de mouvement :
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 :
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 !
Le moyen le plus simple de connecter CodeCell à une télécommande est d'utiliser notre application Bluetooth MicroLink , qui vous permet d'ajouter rapidement des boutons, des curseurs et un joystick à votre projet. Tout est expliqué ici , mais dans ce guide, nous nous concentrerons sur la configuration de l'ESP32-C3 du CodeCell pour qu'il fonctionne comme une télécommande Wi-Fi, permettant la communication entre deux appareils.
L'ESP32-C3 du CodeCell est doté d'une fonction Wi-Fi, lui permettant de communiquer sans fil. Grâce à ESP-NOW, nous pouvons établir une communication directe entre appareils avec une configuration minimale. Ce guide explique comment appairer deux appareils : l'un comme télécommande à capteurs, l'autre pour recevoir et exploiter les données transmises.
Dans cet exemple, nous allons coupler deux appareils CodeCell . L'appareil 1 collectera les données du capteur et les transmettra à l'appareil 2 via Wi-Fi grâce au protocole ESP-NOW. Nous commencerons par une configuration simple où le capteur de proximité de l'appareil 1 contrôlera la LED intégrée de l'appareil 2. Dans le deuxième exemple, l'appareil 1 enverra des données angulaires, et l'appareil 2 traitera ces données pour ajuster la vitesse du moteur.
Avant d'établir la communication entre les deux appareils CodeCell , vous devez d'abord obtenir l'adresse MAC du récepteur. Cette adresse MAC sera utilisée dans le code de l'expéditeur pour garantir que le bon appareil reçoit les données.
Suivez ces étapes pour obtenir l’adresse MAC du récepteur :
XX:XX:XX:XX:XX:XX . Copiez cette adresse, car vous en aurez besoin pour le code de l'expéditeur. 
Remplacez l'adresse MAC de l'espace réservé dans le code de l'expéditeur (appareil 1) par l'adresse MAC que vous venez d'obtenir de l'appareil 2. Cela garantira que l'appareil 1 envoie les données au bon récepteur.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.
#include <esp_now.h>
#include <WiFi.h>
#include <CodeCell.h>
CodeCell myCodeCell;
uint8_t receiverMAC[] = { 0xXX, 0xXX, 0xXX, 0xXX, 0xXX, 0xXX }; // Remplacer par l'adresse MAC du récepteur
configuration vide() {
Serial.begin(115200);
myCodeCell.Init(LIGHT); // Initialise la détection de lumière
// Initialiser le WiFi en mode Station
WiFi.mode(WIFI_STA);
Serial.println(WiFi.macAddress());
// Initialiser ESP-NOW
si (esp_now_init() != ESP_OK) {
Serial.println("Erreur lors de l'initialisation d'ESP-NOW");
retour;
}
// Enregistrer un pair
esp_now_peer_info_t peerInfo;
memcpy(peerInfo.peer_addr, receiverMAC, 6);
peerInfo.channel = 0;
peerInfo.encrypt = faux;
si (esp_now_add_peer(&peerInfo) != ESP_OK) {
Serial.println("Échec de l'ajout du pair");
retour;
}
}
boucle vide() {
si (myCodeCell.Run(10)) {
uint16_t ProxRead = (myCodeCell.Light_ProximityRead()) >> 4; // Obtenir la valeur de proximité et diviser par 16
Serial.println(ProxRead);
résultat esp_err_t = esp_now_send(receiverMAC, (uint8_t *)&ProxRead, sizeof(ProxRead));
si (résultat == ESP_OK) {
Serial.println("Données envoyées avec succès");
} autre {
Serial.println("Erreur d'envoi");
}
}
}
#include <esp_now.h>
#include <WiFi.h>
#include <CodeCell.h>
CodeCell myCodeCell;
void setup() {
Serial.begin(115200);
myCodeCell.Init(LIGHT); // Initializes Light Sensing
// Initialize WiFi in Station mode
WiFi.mode(WIFI_STA);
Serial.println(WiFi.macAddress());
// Initialize ESP-NOW
if (esp_now_init() != ESP_OK) {
Serial.println("Error initializing ESP-NOW");
return;
}
// Register the receive callback
esp_now_register_recv_cb(onDataRecv);
}
// Receive callback function
void onDataRecv(const esp_now_recv_info *recvInfo, const uint8_t *incomingData, int len) {
uint16_t Remote_Value;
memcpy(&Remote_Value, incomingData, sizeof(Remote_Value));
Serial.println(Remote_Value);
myCodeCell.LED(0, Remote_Value, 0); // Control onboard LED brightness
}
void loop() {
// Nothing to do here
}
Dans ce deuxième exemple, nous connectons deux moteurs équipés de deux DriveCells au récepteur. L'appareil 1 lit les données angulaires de ses capteurs de mouvement et les transmet à l'appareil 2, qui ajuste la vitesse des deux moteurs en fonction des données reçues.
Si vous utilisez des appareils différents pour cet exemple, n'oubliez pas de lire la nouvelle adresse MAC du récepteur et de remplacer l'adresse MAC de remplacement dans le code de l'expéditeur.
#include <esp_now.h>
#include <WiFi.h>
#include <CodeCell.h>
CodeCell myCodeCell;
uint8_t receiverMAC[] = {0xXX, 0xXX, 0xXX, 0xXX, 0xXX, 0xXX}; // Replace with receiver's MAC address
int Roll_Control = 0;
float Roll = 0.0;
float Pitch = 0.0;
float Yaw = 0.0;
void setup() {
Serial.begin(115200);
myCodeCell.Init(MOTION_ROTATION); // Initialize motion sensing
// Initialize WiFi in Station mode
WiFi.mode(WIFI_STA);
Serial.println(WiFi.macAddress());
// Initialize ESP-NOW
si (esp_now_init() != ESP_OK) {
Serial.println("Erreur lors de l'initialisation d'ESP-NOW");
retour;
}
// Enregistrer un pair
esp_now_peer_info_t peerInfo;
memcpy(peerInfo.peer_addr, receiverMAC, 6);
peerInfo.channel = 0;
peerInfo.encrypt = faux;
si (esp_now_add_peer(&peerInfo) != ESP_OK) {
Serial.println("Échec de l'ajout du pair");
retour;
}
}
boucle vide() {
si (myCodeCell.Run(10)) {
myCodeCell.Motion_RotationRead(Roll, Pitch, Yaw);
Jet = Jet + 180 ;
Lancer = (Lancer * 100) / 180 ;
Roll = contraindre(Roll, 0, 200) / 2;
Roll_Control = (uint8_t)Roll;
Serial.println(Roll_Control);
esp_now_send(receiverMAC, (uint8_t *)&Roll_Control, sizeof(Roll_Control));
}
}
#include <esp_now.h>
#include <WiFi.h>
#include <CodeCell.h>
#include <DriveCell.h>
#define IN1_pin1 2
#define IN1_pin2 3
#define IN2_pin1 5
#define IN2_pin2 6
CodeCell myCodeCell;
DriveCell Motor1(IN1_pin1, IN1_pin2);
DriveCell Motor2(IN2_pin1, IN2_pin2);
void setup() {
Serial.begin(115200);
myCodeCell.Init(LIGHT); // Initialiser la détection de lumière
Moteur1.Init();
Moteur2.Init();
// Initialiser le WiFi en mode Station
WiFi.mode(WIFI_STA);
Serial.println(WiFi.macAddress());
// Initialiser ESP-NOW
si (esp_now_init() != ESP_OK) {
Serial.println("Erreur lors de l'initialisation d'ESP-NOW");
retour;
}
// Enregistrer le rappel de réception
esp_now_register_recv_cb(onDataRecv);
}
void onDataRecv(const esp_now_recv_info *recvInfo, const uint8_t *incomingData, int len) {
int Roll_Speed = 0;
memcpy(&Roll_Speed, données entrantes, sizeof(Roll_Speed));
si (Roll_Speed > 50) {
Moteur1.Drive(1, Vitesse_Roll);
Motor2.Drive(1, Roll_Speed);
} autre {
Roll_Speed = 100 - Roll_Speed;
Moteur1.Drive(0, Vitesse_Roll);
Motor2.Drive(0, Roll_Speed);
}
Serial.println(Roll_Speed);
}
boucle vide() {
si (myCodeCell.Run(10)) {}
}
En suivant ces exemples, vous pouvez configurer deux appareils CodeCell pour communiquer en Wi-Fi avec ESP-NOW. Ces exemples expliquent comment transmettre des données de proximité et angulaires entre les appareils et exploiter ces données pour contrôler en temps réel les LED et les moteurs.
N'hésitez pas à développer ces projets en incorporant davantage de capteurs ou de fonctionnalités supplémentaires pour améliorer les fonctionnalités de votre système distant !
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.
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 capteurs. 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.
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.
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.
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.
https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=YOUR_API_KEY
Une fois l'URL entrée, nous devons configurer les en-têtes et le corps de la demande.
{
"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.
"I am a large language model trained by Google."
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.
Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Dans cet exemple, l'IA répondra aux messages 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 = "";
}
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(10)) {
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 = "";
}
}
}
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.
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.
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).
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
}
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 :
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 !
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.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 !
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.
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).
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.
#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();
}
boucle vide() {
si (myCodeCell.Run(10)) {
// 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é);
}
}
}
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 ce guide, 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, comme la marche, la course, le vélo, la montée d'escaliers et la conduite !
Le capteur de mouvement du CodeCell est capable de catégoriser diverses activités personnelles en fonction de leurs schémas de mouvement. À partir de ces schémas, le capteur BNO085 tente de deviner l'activité en cours. Ces activités incluent la marche, la course, le vélo, la conduite, etc.
La bibliothèque CodeCell vous permet de lire directement l'activité sans aucun code complexe.
Dans cet exemple, le CodeCell surveille en continu l'activité personnelle du BNO085. L'activité la plus probable est ensuite affichée sur un écran OLED grâce à la bibliothèque Adafruit SSD1306. Cette configuration est idéale pour créer des moniteurs d'activité portables ou des trackers d'activité fournissant 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é.
Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Assurez-vous que votre CodeCell est connecté en USB-C et que votre écran OLED est correctement câblé à sa face inférieure, via 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 // Address of the OLED display
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
int read_timer = 0;
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_ACTIVITY); // Initialise la détection d'activité.
si (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
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(10)) {
si (read_timer < 10) {
read_timer++;
} autre {
// Mise à jour toutes les 1 seconde
read_timer = 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("Escaliers");
casser;
défaut:
display.print("Lecture..");
casser;
}
affichage.display();
}
}
}
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 constitue 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 ce guide, nous explorerons 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 qui facilite la transformation de CodeCell en votre propre podomètre ou même en tracker de fitness !
CodeCell est équipé d'un capteur de mouvement BNO085 qui utilise les données d'un accéléromètre, d'un gyroscope et d'un magnétomètre pour suivre des schémas de mouvement spécifiques et déterminer si un pas a été effectué. Chaque pas est ensuite ajouté à un compteur, et la bibliothèque CodeCell vous permet de lire facilement le nombre de pas.
Dans cet exemple, le CodeCell surveille en permanence les étapes et met à jour le décompte. Ce décompte est ensuite affiché sur un écran OLED grâce à la bibliothèque Adafruit SSD1306.
Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Assurez-vous que votre CodeCell est correctement connecté en USB-C et que votre écran OLED est correctement câblé sur sa face inférieure. Vous pouvez alors 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 myCodeCell; /* Configure the OLED Display */ #define SCREEN_WIDTH 64 // 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 // Address of the OLED display Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET); uint16_t step_counter = 0;configuration vide() { 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_STEP_COUNTER); // Initialise le comptage des pas et la détection d'activité. si (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) { Serial.println("Erreur d'affichage"); } affichage.clearDisplay(); affichage.setTextSize(1); affichage.setTextColor(SSD1306_WHITE); affichage.display(); retard(2000); } boucle vide() { if (myCodeCell.Run(10)) { //Exécuter toutes les 10 Hz
step_counter = myCodeCell.Motion_StepCounterRead(); //Lire le compteur de pas
affichage.clearDisplay();
display.setCursor(32, 16); // Commence dans le coin supérieur gauche
display.print(F("Étapes : "));
affichage.print(compteur_de_pas);
display.display(); //Mettre à jour l'affichage
} }
Ce projet montre comment utiliser le capteur de mouvement du CodeCell comme podomètre et afficher le nombre de pas sur un écran OLED. Expérimentez avec le code pour créer votre propre appareil de fitness portable et consultez le dépôt GitHub de CodeCell pour plus d'exemples de code et de documentation technique !
Dans ce guide, nous explorerons comment utiliser le CodeCell pour contrôler un servomoteur. Nous verrons également comment contrôler la position angulaire du servomoteur grâce à la fonction de positionnement angulaire du CodeCell, particulièrement utile pour les applications robotiques comme les cardans ou le contrôle de la stabilité angulaire.
Un servomoteur est un actionneur rotatif permettant un contrôle précis de la position angulaire. Il est composé d'un moteur couplé à des engrenages et à un capteur de position. Il est couramment utilisé dans les applications de robotique, d'automatisation et de stabilisation.
CodeCell est équipé d'un capteur de mouvement BNO085 qui fusionne les données d'un accéléromètre, d'un gyroscope et d'un magnétomètre pour calculer les vecteurs de rotation. Ces vecteurs sont traités par CodeCell pour obtenir les angles de roulis, de tangage et de lacet en fonction de l'orientation de l'appareil dans l'espace.
Dans cet exemple, notre CodeCell surveille en continu l'angle d'inclinaison pour contrôler la position d'un servomoteur, lui permettant ainsi de réagir dynamiquement aux changements d'orientation. La valeur d'inclinaison permet de définir la position du servomoteur, lui permettant ainsi de pivoter en fonction de l'inclinaison de l'appareil.
Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Assurez-vous que votre CodeCell est correctement connecté via USB-C. Vérifiez également que votre servomoteur peut être alimenté via USB-C (CodeCell peut fournir jusqu'à 500 mA via USB-C et jusqu'à 1 500 mA avec une batterie). Ajustez les limites angulaires du code en conséquence.
Pour cet exemple, vous devez installer la bibliothèque « ESP32Servo » pour contrôler le servomoteur avec votre CodeCell. Suivez les commentaires du 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. Enable Tools/USB_CDC_On_Boot 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(10)) {
// 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)Pitch);
servo_angle = (180 - servo_angle);
// Limit the servo angle to the range 0-60 degrees
if (servo_angle > 60) {
servo_angle = 60;
} sinon si (servo_angle < 0) {
servo_angle = 0;
}
autre{
//Sauter
}
Serial.println(servo_angle); // Imprimer l'angle du servo pour le débogage
myservo.write(servo_angle); // Définir la position du servo
}
}
Cette fonctionnalité de base peut être étendue pour créer des interactions plus complexes, telles que :
servo_angle dans le code. Dans cet exemple, nous utilisons un micro-servomoteur avec une plage de 60 degrés. Certains servomoteurs ne sont pas linéaires ; il peut donc être nécessaire de compenser les erreurs angulaires et mécaniques.Ce projet montre comment contrôler un servomoteur avec CodeCell grâce à ses capacités de détection de mouvement. Expérimentez avec le code, créez vos propres projets et consultez le dépôt GitHub de CodeCell pour plus d'exemples de code et de documentation technique !