Le module CodeCell, alimenté par l'ESP32-C3, intègre des fonctionnalités Wi-Fi qui lui permettent de se connecter à Internet, de communiquer avec d'autres appareils et même d'héberger un petit serveur web. Que vous soyez débutant ou expérimenté, ce guide vous aidera à démarrer avec le Wi-Fi sur CodeCell.

Qu’est-ce que le Wi-Fi et pourquoi l’utiliser ?

Le Wi-Fi permet à votre CodeCell de se connecter sans fil à Internet ou à un réseau local. Vous pouvez ainsi :

• Contrôlez votre CodeCell à distance depuis un smartphone ou un ordinateur
• Envoyer et recevoir des données sur Internet
• Hébergez une petite page Web à laquelle d'autres appareils peuvent accéder

Maintenant, passons étape par étape à la connexion de CodeCell au Wi-Fi.

Connexion de CodeCell à un réseau Wi-Fi

Pour connecter votre CodeCell à un réseau Wi-Fi, vous devez fournir le nom du réseau ( SSID ) et le mot de passe. Utilisons l'IDE Arduino pour écrire un programme simple qui connecte CodeCell au Wi-Fi.

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

 CodeCell myCodeCell;
 const char* ssid = "your_SSID"; // Replace with your Wi-Fi name
 const char* password = "your_PASSWORD"; // Replace with your Wi-Fi password

 void setup() {
 Serial.begin(115200); // Start the Serial Monitor
 myCodeCell.Init(LIGHT); // Set up CodeCell's light sensor
 WiFi.begin(ssid, password); // Connect to Wi-Fi

 Serial.print("Connecting to Wi-Fi");
 while (WiFi.status() != WL_CONNECTED) {
 delay(500);
 Serial.print("."); // Print dots while connecting
 }

 Serial.println("\nConnected!");
 Serial.print("IP Address: "); 
Serial.println(WiFi.localIP()); // Imprimer l'adresse IP attribuée
 }

 boucle vide() {
 // Exécuter tous les 10 Hz
 si (myCodeCell.Run(10)) {
 // Votre code de boucle principal ici
 }
 }

Comment ça marche :

• Ce code démarre le moniteur série pour suivre la progression de la connexion Wi-Fi.
• Il se connecte au Wi-Fi en utilisant WiFi.begin(ssid, password); .
• Une fois connecté, il imprime l'adresse IP attribuée.

Dépannage :

• Si la connexion ne se fait pas, vérifiez votre SSID et votre mot de passe .
• Assurez-vous que votre routeur est allumé et ne bloque pas les appareils inconnus.

Héberger une page Web simple sur CodeCell

Une fois CodeCell connecté au Wi-Fi, nous pouvons le transformer en un mini serveur web ! Cela signifie que nous pouvons le contrôler ou afficher des informations via une page web.

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

 CodeCell myCodeCell;
 const char* ssid = "your_SSID";
 const char* password = "your_PASSWORD";

 WebServer server(80);
 
void handleRoot() {
 int proximityValue = myCodeCell.Light_ProximityRead(); // Lire le capteur de proximité
 Réponse de chaîne = "
 Bienvenue sur le serveur Wi-Fi CodeCell !
 ";
 réponse += "
 Valeur de proximité : « + String(proximityValue) + »
 ";
 server.send(200, "texte/html", réponse);
 }

 configuration vide() {
 Serial.begin(115200);
 myCodeCell.Init(LIGHT); // Configurer le capteur de lumière de CodeCell
 WiFi.begin(ssid, mot de passe);

 tandis que (WiFi.status() != WL_CONNECTED) {
 délai(500);
 Série.print(".");
 }
 Serial.println("\nConnecté au Wi-Fi");
 Serial.print("Adresse IP : ");
 Série.println(WiFi.localIP());

 serveur.on("/", handleRoot);
 serveur.begin();
 Serial.println("Serveur HTTP démarré");
 }

 boucle vide() {
 si(myCodeCell.Run(10)){
 serveur.handleClient();
 }
 }

Comment ça marche :

• Ce code configure un serveur Web simple qui affiche un message.
• Lorsque vous saisissez l' adresse IP (imprimée dans Serial Monitor) dans un navigateur, une page Web indiquant « Bienvenue sur le serveur Wi-Fi CodeCell ! » s'affiche et affiche la valeur de proximité actuelle lue par le CodeCell.

Essayez-le !

1. Téléchargez le code sur CodeCell.
2. Ouvrez le moniteur série pour trouver l' adresse IP .
3. Tapez l’adresse IP dans un navigateur – vous devriez voir le message !
4. Actualisez la page pour voir la mise à jour de la valeur de proximité

Envoi de données à un serveur (exemple IoT de base)

CodeCell peut également envoyer des données à un serveur Web, tel qu'un service cloud qui collecte les lectures des capteurs.

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

 CodeCell myCodeCell;
 const char* ssid = "your_SSID";
 const char* password = "your_PASSWORD";
 const char* serverName = "http://example.com/data"; // Replace with your server URL

 void setup() {
 Serial.begin(115200);
 myCodeCell.Init(LIGHT); // Set up CodeCell's light sensor 
WiFi.begin(ssid, mot de passe);
 tandis que (WiFi.status() != WL_CONNECTED) {
 délai(500);
 Série.print(".");
 }
 Serial.println("Connecté au Wi-Fi");
 }

 boucle vide() {
 if (myCodeCell.Run(10)) { // Exécuter toutes les 10 Hz
 Client HTTP http;
 http.begin(nom du serveur);
 int httpResponseCode = http.GET();
 Serial.print("Code de réponse HTTP : ");
 Serial.println(httpResponseCode);
 http.end();
 }
 }

Comment ça marche :

• Le CodeCell se connecte au Wi-Fi et envoie une requête à http://example.com/data .
• La réponse est imprimée dans le moniteur série.
• Vous pouvez utiliser cette méthode pour envoyer des données de capteur à un service Web !

Conclusion

Le Wi-Fi rend CodeCell puissant pour les projets IoT ! Commencez à expérimenter et vous réaliserez bientôt des projets exceptionnels !

Vous êtes-vous déjà demandé comment votre téléphone détecte votre direction ? C'est grâce à un magnétomètre ! Votre CodeCell est équipé d'un magnétomètre 3 axes BNO085, qui détecte les champs magnétiques dans trois directions. Il vous permet de mesurer le cap (direction), de détecter les interférences magnétiques et même de créer une simple boussole numérique !

Qu'est-ce qu'un magnétomètre ?

Un magnétomètre mesure le champ magnétique terrestre selon trois axes :

• Axe X → Mesure l'intensité du champ magnétique gauche-droite.
• Axe Y → Mesure l'intensité du champ magnétique avant-arrière.
• Axe Z → Mesure l'intensité du champ magnétique de haut en bas.

En utilisant ces valeurs, nous pouvons calculer le cap de la boussole (0° à 360°) et déterminer dans quelle direction CodeCell pointe.

Étape 1 : Lire les données du magnétomètre à partir de CodeCell

Commençons par initialiser le magnétomètre et lire les valeurs brutes du champ magnétique.

 #include <CodeCell.h>

 CodeCell myCodeCell;

 float x = 0.0; // Magnetic field on X-axis
 float y = 0.0; // Magnetic field on Y-axis
 float z = 0.0; // Magnetic field on Z-axis

 void setup() {
 Serial.begin(115200);
 myCodeCell.Init(MOTION_MAGNETOMETER); // Initialize the magnetometer
 }

 void loop() {
 if (myCodeCell.Run(10)) { // Read at 10Hz (every 100ms)
 myCodeCell.Motion_MagnetometerRead(x, y, z); // Get magnetometer readings

 Serial.print("Mag X: "); Serial.print(x);
 Serial.print(" Y: "); Serial.print(y);
 Serial.print(" Z: "); Serial.println(z);
 }
 }

Une fois que vous avez téléchargé le code et ouvert le Serial Monitor , vous verrez des valeurs telles que :

Mag X: 12.4 Y: -7.8 Z: 35.2

Que signifient ces valeurs ?

• Si vous faites pivoter CodeCell , les valeurs X et Y changeront en fonction de la direction.
• Si vous inclinez CodeCell , la valeur Z changera .
• Si vous placez CodeCell près d'un aimant , toutes les valeurs fluctueront considérablement.

Étape 2 : Convertir les données du magnétomètre en cap de boussole

Pour construire une boussole numérique , nous devons convertir les valeurs X et Y en un angle à l'aide de la fonction atan2() .

 #include <CodeCell.h>
 #include <math.h> // Needed for atan2 function

 CodeCell myCodeCell;

 float x = 0.0, y = 0.0, z = 0.0;

 void setup() {
 Serial.begin(115200);
 myCodeCell.Init(MOTION_MAGNETOMETER); // Initialize the magnetometer
 }

 void loop() {
 if (myCodeCell.Run(10)) { // Read at 10Hz
 myCodeCell.Motion_MagnetometerRead(x, y, z); // Read magnetometer values
 
// Calculer le cap (angle en degrés)
 titre flottant = atan2(y, x) * (180,0 / M_PI);

 // Assurez-vous que le cap est compris entre 0° et 360°
 si (titre < 0) {
 cap += 360;
 }

 Serial.print("Cap de la boussole : ");
 Serial.println(heading); // Imprimer le titre en degrés
 }
 }

La valeur du cap (0° à 360°) nous indique dans quelle direction pointe CodeCell :

Essayez de faire pivoter CodeCell et regardez le titre changer !

Étape 3 : Afficher la direction avec la LED intégrée

Nous pouvons maintenant éclairer la LED dans différentes couleurs en fonction de la direction :

• 🔵 Nord (0° - 45° & 315° - 360°) → LED bleue
• 🟢 Est (45° - 135°) → LED verte
• 🔴 Sud (135° - 225°) → LED rouge
• 🟡 Ouest (225° - 315°) → LED jaune

 #include <CodeCell.h>
 #include <math.h>

 CodeCell myCodeCell;

 float x = 0.0, y = 0.0, z = 0.0;

 void setup() {
 Serial.begin(115200);
 myCodeCell.Init(MOTION_MAGNETOMETER); // Initialize the magnetometer
 }

 void loop() {
 if (myCodeCell.Run(10)) { // Read at 10Hz
 myCodeCell.Motion_MagnetometerRead(x, y, z); // Read magnetometer values

 // Calculate heading
 float heading = atan2(y, x) * (180.0 / M_PI);
 if (heading < 0) heading += 360;

 Serial.print("Heading: ");
 Serial.println(heading);

 // Change LED color based on heading
 if (heading >= 315 || heading < 45) {
 myCodeCell.LED(0, 0, 255); // Blue for North
 } else if (heading >= 45 && heading < 135) {
 myCodeCell.LED(0, 255, 0); // Green for East
 } else if (heading >= 135 && heading < 225) {
 myCodeCell.LED(255, 0, 0); // Red for South 
} autre {
 myCodeCell.LED(255, 255, 0); // Jaune pour l'Ouest
 }
 }
 }

Expérimentez vos propres idées !

Maintenant que vous pouvez lire les données du magnétomètre et calculer la direction, essayez :

• Affichage de la direction (N, E, S, O) sur un écran OLED .
• Détection d'un champ magnétique à proximité de bobines ou d'aimants .
• Combinaison avec d'autres capteurs

Le CodeCell est livré avec un gyroscope 3 axes BNO085 intégré, qui peut mesurer la vitesse angulaire - la vitesse à laquelle CodeCell tourne autour de chaque axe - ce qui facilite la détection des changements de direction.

Qu'est-ce qu'un gyroscope ?

Contrairement à un accéléromètre qui mesure le mouvement en ligne droite, un gyroscope détecte le mouvement de rotation . Il indique la vitesse de rotation de CodeCell en degrés par seconde (°/s).

• Axe X → Rotation autour de l'axe gauche-droite (pas)
• Axe Y → Rotation autour de l'axe avant-arrière (roulement)
• Axe Z → Rotation autour de l'axe haut-bas (lacet)

Étape 1 : Lire les données du gyroscope à partir de CodeCell

Avant de pouvoir utiliser le gyroscope, nous devons l’initialiser et commencer à lire les données.

Ce code lit les valeurs de vitesse angulaire X, Y et Z et les imprime toutes les 100 ms.

 #include <CodeCell.h>

 CodeCell myCodeCell;

 float x = 0.0; // Angular velocity around X-axis
 float y = 0.0; // Angular velocity around Y-axis
 float z = 0.0; // Angular velocity around Z-axis

 void setup() {
 Serial.begin(115200);
 myCodeCell.Init(MOTION_GYRO); // Initialize the gyroscope
 }

 void loop() {
 if (myCodeCell.Run(10)) { // Read at 10Hz (every 100ms)
 myCodeCell.Motion_GyroRead(x, y, z); // Get gyro readings

 Serial.print("Gyro X: "); Serial.print(x);
 Serial.print(" Y: "); Serial.print(y);
 Serial.print(" Z: "); Serial.println(z);
 }
 }

Ce que vous remarquerez :

• Lorsque CodeCell est toujours , toutes les valeurs doivent être proches de 0.
• Si vous l'inclinez vers l'avant ou vers l'arrière , les valeurs de l'axe X changent.
• Si vous le tournez vers la gauche ou la droite , les valeurs de l'axe Y changent.
• Si vous le faites pivoter comme un volant , les valeurs de l'axe Z changent.

Plus la valeur est élevée, plus la rotation est rapide.

Étape 2 : Détecter la rotation et changer la couleur de la LED

Maintenant, détectons quand CodeCell tourne à gauche ou à droite et modifions la couleur de la LED RVB en conséquence .

Ce programme :

• Fait passer la LED au vert lorsqu'elle est tournée vers la droite (Z positif) .
• Fait passer la LED au rouge lorsqu'elle est tournée vers la gauche (Z négatif) .

 #include <CodeCell.h>

 CodeCell myCodeCell;

 float x = 0.0, y = 0.0, z = 0.0;
 const float ROTATION_THRESHOLD = 3.0; // Rotation speed threshold (°/s)

 void setup() {
 Serial.begin(115200);
 myCodeCell.Init(MOTION_GYRO); // Initialize gyroscope
 }

 void loop() {
 if (myCodeCell.Run(10)) { // Read at 10Hz
 myCodeCell.Motion_GyroRead(x, y, z); // Get gyroscope values

 Serial.print("Gyro Z: ");
 Serial.println(z); // Print rotation speed
 
si (z > SEUIL_DE_ROTATION) {
 myCodeCell.LED(0, 255, 0); // Allume la LED verte (rotation à droite)
 }
 sinon si (z < -ROTATION_THRESHOLD) {
 myCodeCell.LED(255, 0, 0); // Allumer la LED en rouge (rotation à gauche)
 }
 autre {
 myCodeCell.LED(0, 0, 0); // Éteint la LED lorsqu'elle ne tourne pas
 }
 }
 }

Le gyroscope mesure la vitesse angulaire en degrés par seconde (°/s). Si la valeur de la rotation Z (lacet) dépasse le seuil, nous considérons que CodeCell est en rotation.

• Z > 3 → En tournant vers la droite , la LED devient verte .
• Z < -3 → En tournant vers la gauche , la LED devient rouge .

Essayez de modifier ROTATION_THRESHOLD pour augmenter ou diminuer la sensibilité.

• Valeur supérieure = Détecte uniquement les rotations rapides
• Valeur inférieure = Détecte même les petites rotations

Expérimentez vos propres idées !

Maintenant que vous pouvez suivre la rotation, essayez :

• Utilisation de différentes couleurs de LED pour différents axes
• Détection de mouvements rapides ou de gestes
• Apprendre et suivre la rotation au fil du temps

Votre CodeCell contient un accéléromètre 3 axes BNO085, un minuscule capteur qui mesure les mouvements. Avec seulement quelques lignes de code, vous pouvez détecter les tremblements et même déclencher une LED en cas de mouvement ! Voyons comment procéder étape par étape.

Qu'est-ce qu'un accéléromètre ?

Un accéléromètre mesure l'accélération, c'est-à-dire la vitesse à laquelle un objet accélère ou ralentit. Il détecte :

• Gauche et droite (axe X)
• Avant et arrière (axe Y)
• Haut et bas (axe Z)

On ressent même la gravité ! Lorsque CodeCell est immobile, l'axe Z affiche une valeur proche de 9,81 m/s² , soit la gravité terrestre.

Étape 1 : Lire le mouvement à partir de CodeCell

Commençons par lire les valeurs de mouvement en temps réel de l'accéléromètre intégré de CodeCell. Ce code indique l'amplitude du mouvement de CodeCell dans chaque direction :

 #include <CodeCell.h>

 CodeCell myCodeCell;
 
float x = 0,0 ; // Accélération de l'axe X
 float y = 0,0 ; // Accélération de l'axe Y
 float z = 0,0 ; // Accélération de l'axe Z

 configuration vide() {
 Serial.begin(115200);
 myCodeCell.Init(MOTION_ACCELEROMETER); // Initialiser l'accéléromètre
 }

 boucle vide() {
 if (myCodeCell.Run(10)) { // Exécuter 10 fois par seconde (10 Hz)
 myCodeCell.Motion_AccelerometerRead(x, y, z); // Lire les valeurs de mouvement
 Serial.print("X: "); Serial.print(x);
 Serial.print(" Y: "); Serial.print(y);
 Série.print(" Z: "); Série.println(z);
 }
 }

Ce que vous remarquerez :

• Lorsque CodeCell est immobile, face vers le haut, X et Y doivent être proches de 0 et Z doit être autour de 9,81 (gravité).
• Lorsque vous déplacez CodeCell vers la gauche ou vers la droite, X change.
• Lorsque vous le déplacez vers l'avant ou vers l'arrière, Y change.
• Quand vous le secouez, toutes les valeurs sautent !

Étape 2 : Détecter une secousse

Maintenant, détectons quand CodeCell est secoué et utilisons la LED RVB intégrée pour le signaler.

Ce programme allumera la LED en rouge si un tremblement est détecté.

#include <CodeCell.h>
 #include <math.h> // Needed for square root calculations

 CodeCell myCodeCell;

 float x = 0.0, y = 0.0, z = 0.0;
 const float SHAKE_THRESHOLD = 15.0; // Adjust this value for sensitivity

 void setup() {
 Serial.begin(115200);
 myCodeCell.Init(MOTION_ACCELEROMETER); // Initialize accelerometer
 }

 void loop() {
 if (myCodeCell.Run(10)) { // Check every 100ms (10Hz)
 myCodeCell.Motion_AccelerometerRead(x, y, z); // Read accelerometer data

 // Calculate total movement strength (vector magnitude)
 float totalAcceleration = sqrt(x * x + y * y + z * z);

 Serial.print("Total Acceleration: ");
 Serial.println(totalAcceleration); // Show acceleration strength

 // If the acceleration is stronger than the threshold, it's a shake!
 if (totalAcceleration > SHAKE_THRESHOLD) {
 Serial.println("Shake detected!");
 myCodeCell.LED(255, 0, 0); // Turn LED red 
delay(500); // Garder la LED allumée pendant 0,5 seconde
 } autre {
 //Ne tremble pas
 }
 }
 }

Au lieu de vérifier X, Y et Z séparément, nous les combinons en une seule valeur :

Cela nous indique l'amplitude globale des mouvements de CodeCell , quelle que soit la direction. Si totalAcceleration dépasse 15,0 , nous supposons que CodeCell est secoué. La LED RVB devient rouge pendant 0,5 seconde pour signaler le tremblement.

Expérimentez vos propres idées !

Maintenant que vous pouvez détecter les mouvements , voici quelques défis amusants :

• Changez les couleurs des LED en fonction du mouvement (par exemple, bleu pour l'inclinaison, rouge pour le tremblement).
• Utilisez l'accéléromètre pour détecter les coups ou les chocs.
• Découvrez comment CodeCell se déplace lorsqu'il est attaché à un robot ou à un véhicule !

En comprenant la détection de mouvement, vous apprenez la même technologie utilisée dans les smartphones, les drones et les fusées ! 🚀

La LED RVB intégrée sur CodeCell peut également être contrôlée par programmation pour afficher différentes couleurs en fonction des besoins de votre projet.

Grâce à la fonction intégrée de CodeCell, vous pouvez facilement définir la couleur de la LED :

 myCodeCell.LED(uint8_t r, uint8_t g, uint8_t b);

• r → Composante rouge (0-255)
• g → Composante verte (0-255)
• b → Composante bleue (0-255)

Cela permet un contrôle complet des couleurs RVB pour les besoins de votre projet.

Réglage de la luminosité des LED

En plus du contrôle des couleurs, vous pouvez également régler la luminosité de la LED embarquée à l'aide de la fonction suivante :

 myCodeCell.LED_SetBrightness(uint16_t level);

• level → Niveau de luminosité de 0 (éteint) à 10 (luminosité maximale)

Par défaut, le niveau de luminosité est réglé sur 7 .

Par exemple, pour éteindre complètement la LED pendant le fonctionnement normal, utilisez :

 myCodeCell.LED_SetBrightness(0); // Turn off CodeCell LED

Remarque : même avec la luminosité réglée sur 0, la LED clignote toujours en rouge lorsque la batterie est faible, vous assurant ainsi de ne pas manquer les alertes importantes sur l'état de l'alimentation.

Exemple : Modification de la LED en fonction de la proximité

Dans cet exemple, la LED RVB intégrée devient rouge lorsqu'un objet est détecté dans une certaine plage à l'aide de la détection de proximité du capteur de lumière.

 #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(10)) {
 // Runs every 100ms to check proximity
 uint16_t proximity = myCodeCell.Light_ProximityRead();

 // Check if an object is within range 
si (proximité > 100) {
 myCodeCell.LED(0xFF, 0, 0); // Définir la LED sur rouge lorsque la proximité est détectée
 delay(1000); // Garder la LED allumée pendant 1 seconde
 } autre {
 // Aucune action si l'objet est hors de portée
 }
 }
 }

Remarques sur la LED embarquée

N'oubliez pas que la LED RVB intégrée sert également à indiquer l'état de la batterie et de l'alimentation . Lors de l'utilisation de myCodeCell.Run() , la LED peut être remplacée pour refléter l'état de charge ou de la batterie.

Si vous souhaitez contrôler la LED sans interruption, vous devrez peut-être ajuster la fréquence d'appel de myCodeCell.Run() ou vous assurer que vos commandes LED sont appliquées après les mises à jour du système.

De plus, le réglage du niveau de luminosité peut aider à gérer la visibilité de la LED dans différents environnements, ou à l'éteindre complètement pendant le fonctionnement tout en conservant les alertes critiques de batterie faible.

I2C est un protocole largement utilisé pour communiquer avec des capteurs, des écrans et d'autres périphériques. CodeCell simplifie la communication I2C en configurant automatiquement le bus I2C à l'initialisation, pour une utilisation immédiate.

Configuration des broches I2C

Les broches SDA et SCL de l'I2C sont situées sur la face inférieure de la carte CodeCell.

• SDA (ligne de données) → GPIO8
• SCL (ligne d'horloge) → GPIO9
• Vitesse → 400 kHz (mode rapide I2C)

CodeCell configure automatiquement I2C dans la fonction Init() , et cette configuration ne peut pas être modifiée si vous prévoyez d'utiliser les capteurs de lumière et de mouvement intégrés, car ils sont connectés au même bus I2C.

Les capteurs embarqués suivants utilisent déjà I2C, assurez-vous donc de ne pas utiliser les mêmes adresses lors de la connexion d'autres périphériques I2C tels que des écrans, des capteurs supplémentaires ou des modules :

Remarque : si un nouveau périphérique I2C possède la même adresse que l'un de ces capteurs intégrés, ils entreront en conflit et vous risquez d'obtenir des données incorrectes ou inexistantes.

Résistances de rappel I2C intégrées

Pour garantir une communication I2C stable, CodeCell dispose de résistances de rappel de 2 kΩ déjà connectées aux lignes SDA et SCL. Ainsi, vous n'avez pas besoin d'ajouter de résistances de rappel externes lors de l'utilisation de capteurs I2C externes.

Lecture de données à partir d'un périphérique I2C

Pour communiquer avec un périphérique I2C externe, utilisez la bibliothèque standard « Wire.h ».

Contrairement aux périphériques I2C Arduino standard, CodeCell intègre plusieurs capteurs sur le même bus I2C. L'appel de Wire.endTransmission(false); garantit que le bus reste actif, permettant ainsi aux capteurs embarqués de fonctionner correctement.

Exemple:

 Wire.beginTransmission(SLAVE_ADDRESS); // Start communication with the device
 Wire.write(SLAVE_REG); // Send the register we want to read
 Wire.endTransmission(false); // Don't release the bus (needed for onboard sensors)
 Wire.requestFrom(SLAVE_ADDRESS, 1); // Request 1 byte from the slave

 if (Wire.available()) {
 uint8_t data = Wire.read(); // Read received byte
 Serial.println(data);
 }

Conclusion

CodeCell configure automatiquement le bus I2C, évitant ainsi toute configuration manuelle. Il configure également automatiquement les capteurs embarqués et prend en charge des périphériques I2C supplémentaires !

Les capteurs analogiques, les potentiomètres et autres entrées variables nécessitent un convertisseur analogique-numérique (CAN) pour être lus par un microcontrôleur. Avec CodeCell, lire un signal analogique est aussi simple que d'appeler pinADC() .

Comment utiliser pinADC()

Pour lire une valeur analogique, utilisez :

 uint16_t myADC = myCodeCell.pinADC(uint8_t pin_num);

• pin_num → La broche ADC à partir de laquelle vous souhaitez lire ( IO1, IO2 ou IO3 ).
• Renvoie une valeur de 12 bits comprise entre 0 et 4095 (correspondant à 0 V – 2,5 V , en raison de la référence de tension interne).

Exemple : Lecture d'un potentiomètre

Si vous connectez un potentiomètre à IO2 , vous pouvez lire sa position avec :

 uint16_t potValue = myCodeCell.pinADC(2);
 Serial.println(potValue);

Câblage correct du potentiomètre :

Étant donné que la tension maximale sur les broches ADC de CodeCell ne doit pas dépasser 3,3 V, vous devez connecter le potentiomètre à 3 V3 au lieu de Vo :

 3V3 → One end of the potentiometer
 GND → Other end of the potentiometer
 IO2 → Middle pin of the potentiometer

Important : la référence de tension interne est de 2,5 V

Le microcontrôleur embarqué utilise une référence de tension interne de 2,5 V. Cela signifie :

• Si votre tension d'entrée est de 2,5 V , la lecture ADC sera de 4095 (valeur maximale) - toute tension supérieure à 2,5 V sera de 4095
• Si votre tension d'entrée est de 1,25 V , la lecture ADC sera d'environ 2048 .
  

Pour mettre à l’échelle correctement les lectures :

 float voltage = (myCodeCell.pinADC(2) / 4095.0) * 2.5;
 Serial.println(voltage);

Pourquoi utiliser cette fonction ?

• Fonctionne sur IO1, IO2 et IO3 - flexibilité dans le choix des broches ADC
• Aucune configuration supplémentaire n'est nécessaire : appelez simplement pinADC()
• Résolution 12 bits intégrée pour des lectures précises.

Que vous lisiez un potentiomètre, un capteur ou d'autres signaux analogiques, CodeCell facilite la lecture de l'ADC.

La modulation de largeur d'impulsion (PWM) est essentielle pour contrôler la luminosité des LED, la vitesse des moteurs et même la génération de signaux audio. Avec CodeCell, configurer la PWM est incroyablement simple grâce à la fonction pinPWM() . Contrairement à la PWM traditionnelle d'Arduino qui nécessite des broches prédéfinies et une configuration supplémentaire, CodeCell vous permet d'activer la PWM sur n'importe laquelle de ses 6 broches disponibles sans effort.

Comment utiliser pinPWM()

Pour générer un signal PWM, utilisez :

 myCodeCell.pinPWM(uint8_t pin_num, uint16_t pin_freq, uint8_t pin_dutycycle);

• pin_num → La broche que vous souhaitez utiliser (l'un des 6 GPIO disponibles de CodeCell).
• pin_freq → La fréquence du signal PWM (en Hz).
• pin_dutycycle → Le cycle de service (0–100), représentant le pourcentage de temps pendant lequel le signal reste HAUT.

Exemple : variation d'intensité d'une LED

Disons que vous souhaitez atténuer une LED connectée à la broche 3 avec une fréquence de 1 kHz (1000 Hz) et une luminosité de 50 % :

 myCodeCell.pinPWM(3, 1000, 50);

Pour rendre la LED plus lumineuse (par exemple, 80 % de luminosité) :

 myCodeCell.pinPWM(3, 1000, 80);

Ou pour l'éteindre (luminosité 0%) :

 myCodeCell.pinPWM(3, 1000, 0);

Pourquoi utiliser cette fonction ?

• Fonctionne sur n'importe lequel des 6 GPIO de CodeCell - aucune restriction.
• Aucune configuration supplémentaire n'est requise : appelez simplement pinPWM() et vous êtes prêt à partir.
• Fréquence et cycle de service réglables - parfait pour les LED, les moteurs et plus encore.

Cette fonction rend le contrôle PWM sur CodeCell plus flexible et plus simple que jamais. Essayez-la pour votre prochain projet !

Le module CodeCell simplifie plus que jamais l'utilisation des broches GPIO (entrée/sortie). Bien que vous puissiez toujours utiliser les fonctions traditionnelles Arduino digitalWrite() et digitalRead() , la bibliothèque CodeCell utilise pinWrite() et pinRead() , qui gèrent automatiquement l'initialisation des broches.

Aucune initialisation de broche

Grâce aux fonctions optimisées de CodeCell, inutile de définir manuellement le mode de pin avec pinMode() . Appelez simplement :

 myCodeCell.pinWrite(uint8_t pin_num, bool pin_value);

Par exemple, pour allumer une LED connectée à la broche 5 :

 myCodeCell.pinWrite(5, HIGH);

Ou désactivez-le :

myCodeCell.pinWrite(5, LOW);

Lecture des états GPIO

La lecture de l’état d’une broche est tout aussi simple :

 if (myCodeCell.pinRead(5)) {
 // Pin is HIGH, do something
 }

La fonction pinRead() renvoie un booléen ( true pour HIGH, false pour LOW), ce qui rend les interactions GPIO sans effort.

Pourquoi utiliser ces fonctions ?

• Pas besoin de pinMode() — il est géré automatiquement, ce qui rend vos croquis plus propres.

• Détection d'erreur intégrée : si une broche n'est pas disponible sur votre module CodeCell, une erreur sera générée sur le moniteur série, vous aidant à déboguer le problème.

Ces fonctions rendent la gestion GPIO de CodeCell plus intuitive, que vous contrôliez des LED, des boutons et bien plus encore !

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é.

Comprendre le mode veille de CodeCell

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.

Mise en œuvre du mode veille

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 :

1. Au démarrage, CodeCell initialise le capteur de lumière et vérifie la proximité.

2. Si aucune proximité n'est détectée, CodeCell entre en mode veille pendant 1 seconde.

3. Chaque seconde, CodeCell se réveille brièvement, vérifie la proximité et se rendort si nécessaire.

4. Si une proximité est détectée, CodeCell se réveille complètement et initialise tous les périphériques.

Conclusion

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.

Comprendre le roulis, le tangage et le lacet

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 :

• Roulis : Rotation autour de l'axe X (inclinaison à gauche ou à droite)
• Pitch : Rotation autour de l'axe Y (inclinaison vers l'avant ou vers l'arrière)
• Lacet : Rotation autour de l'axe Z (tourner à gauche ou à droite)

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.

Lecture du roulis, du tangage et du lacet avec CodeCell

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 :

1. Initialisez le capteur de mouvement CodeCell pour lire les valeurs de rotation.

2. Exécutez le capteur à 10 Hz (toutes les 100 ms) pour obtenir des données actualisées.

3. 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.

Utilisation des données de rotation pour le contrôle servo

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.

Conclusion

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.

• Connecteur de batterie LiPo : conçu pour une connexion de batterie sûre et facile sans soudure.
• Port USB-C : Fonctionne comme source d'alimentation, port de charge et interface de programmation.

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 :

1. Précharge de conditionnement – ​​Assure une charge sûre des batteries profondément déchargées.
2. Charge à courant constant – Fournit un taux de charge stable jusqu’à ce que la batterie atteigne un seuil de tension désigné.
3. Charge à tension constante – Maintient une tension constante tout en réduisant progressivement le courant pour terminer le cycle de charge.

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.

Paramètres de charge par défaut

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.

Indicateurs de charge

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 :

• Avertissement de batterie faible : lorsque la tension de la batterie tombe en dessous de 3,3 V, la LED clignote en rouge dix fois et l'appareil entre en mode veille pour économiser l'énergie.
• Processus de charge : Pendant la charge via USB, la LED reste bleue. Une fois la batterie complètement chargée, la LED s'allume en clignotant.
• Mode alimenté par batterie : lorsque l'appareil fonctionne uniquement sur batterie, la LED devient verte et effectue une animation lumineuse respiratoire.

Lecture de l'état de la batterie

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.

Lecture de la tension et du niveau de la batterie

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 .

Conclusion:

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 !