L'application MicroLink simplifie le contrôle sans fil de votre CodeCell , que vous construisiez de petits robots, installiez des capteurs ou expérimentiez des projets interactifs. Grâce à des boutons, des curseurs, un joystick et la diffusion de données en temps réel, vous pouvez contrôler, surveiller et déboguer vos projets directement depuis votre téléphone : sans fil, sans souci.
MicroLink est une application mobile Bluetooth conçue pour interagir avec nos appareils, dont le CodeCell . Associé à la bibliothèque MicroLink Arduino, votre CodeCell peut :
Cela rend MicroLink idéal pour le contrôle à distance, le retour en direct et la construction d'électronique interactive.
Installez la bibliothèque CodeCell MicroLink depuis le gestionnaire de bibliothèques Arduino. Elle comprend six exemples de schémas couvrant les fonctions de base du retour d'information des capteurs, de la télécommande et de l'interaction avec les moteurs.
Voici un aperçu rapide de la manière dont votre CodeCell communique avec l'application :
myMicroLink.Init();
Cela configure les boutons, les curseurs, le joystick et les notifications Bluetooth pour la batterie, la proximité, le cap et les messages.
myMicroLink.ShowSensors(battery, proximity, heading);
Envoie uniquement lorsque les valeurs changent, réduisant ainsi le trafic BLE.
myMicroLink.Print("Hello from CodeCell");
Utilisez cette fonction pour envoyer des messages de débogage ou d'état. Print() prend en charge les chaînes jusqu'à 20 caractères. Combinez texte et variables comme suit :
sprintf(message, "%u RPM", MotorRPM);
myMicroLink.Print(message);
Utilisez ces fonctions pour lire les entrées de l’application :
myMicroLink.ReadButtonA(); // true if pressed
myMicroLink.ReadButtonB();
myMicroLink.ReadButtonC();
myMicroLink.ReadButtonD();
myMicroLink.ReadSlider1(); // 0–100
myMicroLink.ReadSlider2();
myMicroLink.ReadSlider3();
myMicroLink.ReadJoystickX(); // axe X du joystick
myMicroLink.ReadJoystickY(); // axe Y du joystick
Une fois que l’un d’entre eux est utilisé dans votre code, il apparaît automatiquement dans l’application MicroLink.
Dans cet exemple, deux modules DriveCell contrôlent des moteurs. Deux curseurs dans l'application permettent de régler la vitesse des moteurs. Un bouton permet d'inverser la polarité :
uint8_t slider1 = myMicroLink.ReadSlider1();
uint8_t slider2 = myMicroLink.ReadSlider2();
DriveCell1.Drive(polarity, slider1);
DriveCell2.Drive(polarity, slider2);
Inverser la polarité en appuyant sur un bouton :
if (myMicroLink.ReadButtonA()) {
polarity = !polarity;
myMicroLink.Print("Reversing Polarity");
}
Une fois installé, ouvrez l'IDE Arduino et accédez à :
Fichier → Exemples → CodeCell MicroLink
Vous trouverez 6 exemples de croquis prêts à être explorés et personnalisés ; aucune configuration avancée n'est requise. Commencez par les exemples, explorez les commandes et créez quelque chose d'amusant !
L'application MicroLink Connect est disponible sur Google Play Store et Apple iOS . Entièrement gratuite , elle propose une interface épurée et sans publicité.
Si vous avez besoin d'aide supplémentaire, n'hésitez pas à nous contacter - Happy Building !
CodeCell est conçu pour être facile à configurer et à utiliser, mais comme tout microcontrôleur, des problèmes peuvent survenir. Ce guide vous aidera à dépanner et à déboguer efficacement CodeCell.
Avant de procéder au dépannage, assurez-vous que vous utilisez les dernières versions de :
Pour mettre à jour :
Pour faciliter la programmation, la bibliothèque CodeCell propose diverses fonctions d'initialisation, de lecture et de gestion des capteurs et de l'alimentation. Voici tout ce que vous devez savoir pour configurer votre appareil et sa bibliothèque.
À l'intérieur de la boîte, vous trouverez :
Branchez un câble USB-C et CodeCell va :
Téléchargez la dernière version depuis le site officiel d'Arduino .
https://dl.espressif.com/dl/package_esp32_index.json
La première étape consiste à initialiser le CodeCell en utilisant :
myCodeCell.Init(SENSOR_MACRO);
Macros disponibles :
Vous pouvez combiner plusieurs macros à l'aide de l'opérateur + :
myCodeCell.Init(LIGHT + MOTION_ACCELEROMETER + MOTION_GYRO);
myCodeCell.Init(SENSOR_MACRO);
Nous espérons que cela vous a aidé à identifier la cause du problème. Si le problème persiste, n'hésitez pas à nous contacter ; nous serons ravis de vous aider !
Le Bluetooth Low Energy (BLE) est un puissant moyen de communication sans fil entre votre CodeCell et d'autres appareils tels que les smartphones, les tablettes et même d'autres microcontrôleurs. Dans ce guide, nous allons configurer le BLE sur CodeCell, lui permettre de recevoir des commandes d'un client BLE et contrôler ses LED RVB en fonction des données reçues.
Le BLE est une version économe en énergie du Bluetooth qui permet aux appareils d'échanger de petites quantités de données avec une faible consommation d'énergie. Voici ses concepts clés :
Avant de commencer les tests, vous devez télécharger une application pour envoyer des données BLE sur votre smartphone. Commencez donc par la télécharger. une application de scanner BLE :
Pour que CodeCell se présente comme un appareil BLE , nous devons initialiser BLE, créer un service et une caractéristique, et commencer à faire de la publicité .
Ce code crée un serveur BLE , annonce un service et configure une caractéristique lisible et écrivable par un appareil connecté. Le CodeCell recevra la caractéristique du bouton et contrôlera sa LED RVB intégrée :
#include <BLEDevice.h> #include <BLEUtils.h> #include <BLEServer.h> #include <BLE2902.h> #include <CodeCell.h> CodeCell myCodeCell; BLECharacteristic *pButtonCharacteristic = NULL; #define BUTTON_UUID "abcd1234-abcd-1234-abcd-123456789012" class MyServerCallbacks : public BLEServerCallbacks { void onConnect(BLEServer *pServer) override { Serial.println("BLE Connected"); delay(1000); } void onDisconnect(BLEServer *pServer) override { Serial.println("BLE Disconnected"); delay(500); BLEDevice::startAdvertising(); // Restart advertising } }; // Callback class for handling button writes class ButtonCallback : public BLECharacteristicCallbacks { void onWrite(BLECharacteristic *pCharacteristic) override { String value = pCharacteristic->getValue(); if (value.length() > 0) { int buttonState = value[0]; Serial.print("Button State: ");Serial.println(boutonÉtat); si (buttonState == 1) { myCodeCell.LED(255, 0, 0); // LED rouge lorsque le bouton est à 1 } autre { myCodeCell.LED(0, 255, 0); // LED verte lorsque le bouton n'est pas à 1 } } } }; void setup() { Serial.begin(115200); myCodeCell.Init(LIGHT); // Initialise le capteur de lumière BLEDevice::init("CodeCell_BLE"); // Définir le nom du périphérique BLE Serveur BLE *bleServer = BLEDevice::createServer(); bleServer->setCallbacks(nouveau MyServerCallbacks()); BLEService *bleService = bleServer->createService(BLEUUID("12345678-1234-5678-1234-56789abcdef0")); // Créer une caractéristique BLE pour l'état du bouton pButtonCharacteristic = bleService->createCharacteristic( BOUTON_UUID, BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_WRITE ); pButtonCharacteristic->addDescriptor(nouveau BLE2902()); pButtonCharacteristic->setCallbacks(nouveau ButtonCallback()); bleService->start(); BLEAdvertising *pAdvertising = BLEDevice::getAdvertising(); pAdvertising->addServiceUUID("12345678-1234-5678-1234-56789abcdef0"); BLEDevice::startAdvertising(); } boucle vide() { // Pas besoin de vérifier en permanence, les mises à jour LED ne se font que lors de l'écriture BLE }
"CodeCell_BLE" ."CodeCell_BLE" dans l'application BLE Scanner.
BUTTON_UUID ) et envoyez la valeur :
1 → La LED devient rouge 🔴0 → la LED devient verte 🟢Ensuite, nous allons définir une nouvelle caractéristique BLE qui permet à CodeCell d' envoyer des valeurs de capteur à un appareil connecté .
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
#include <BLE2902.h>
#include <CodeCell.h>
CodeCell myCodeCell;
BLECharacteristic *pSensorCharacteristic = NULL;
#define SENSOR_UUID "abcd5678-abcd-5678-abcd-56789abcdef0"
class MyServerCallbacks : public BLEServerCallbacks {
void onConnect(BLEServer *pServer) override {
Serial.println("BLE Connected");
delay(1000);
}
void onDisconnect(BLEServer *pServer) override {
Serial.println("BLE déconnecté");
délai(500);
BLEDevice::startAdvertising(); // Redémarrer la publicité
}
};
configuration vide() {
Serial.begin(115200);
myCodeCell.Init(LIGHT); // Initialiser le capteur de lumière et de proximité
BLEDevice::init("CodeCell_BLE"); // Nommer le périphérique BLE
Serveur BLE *bleServer = BLEDevice::createServer();
bleServer->setCallbacks(nouveau MyServerCallbacks());
BLEService *bleService = bleServer->createService(BLEUUID("12345678-1234-5678-1234-56789abcdef0"));
// Créer une caractéristique BLE pour les données du capteur
pSensorCharacteristic = bleService->createCharacteristic(
CAPTEUR_UUID,
BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY
);
pSensorCharacteristic->addDescriptor(nouveau BLE2902());
bleService->start();
BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
pAdvertising->addServiceUUID("12345678-1234-5678-1234-56789abcdef0");
BLEDevice::startAdvertising();
}
boucle vide() {
if (myCodeCell.Run(10)) { // Lecture toutes les 100 ms (10 Hz)
uint16_t proximity = myCodeCell.Light_ProximityRead();
Serial.print("Proximité : ");
Serial.println(proximité);
// Convertir la valeur de proximité en chaîne et l'envoyer via BLE
Chaîne de proximitéStr = String(proximité);
pSensorCharacteristic->setValue(proximityStr.c_str());
pSensorCharacteristic->notify(); // Notifier l'appareil connecté
}
}
SENSOR_UUID ) que les clients peuvent lire et obtenir des mises à jour en temps réel :
Maintenant que CodeCell envoie des données de capteur de proximité via BLE , vous pouvez les visualiser sur un téléphone .
"CodeCell_BLE" et connectez-vousSENSOR_UUID )
Déplacez un objet près du capteur et voyez comment les valeurs changent !
Maintenant que vous pouvez contrôler CodeCell via BLE, essayez :
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.
Le Wi-Fi permet à votre CodeCell de se connecter sans fil à Internet ou à un réseau local. Vous pouvez ainsi :
Maintenant, passons étape par étape à la connexion de CodeCell au 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
}
}
WiFi.begin(ssid, password); .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(); } }
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();
}
}
http://example.com/data .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 !
Un magnétomètre mesure le champ magnétique terrestre selon trois axes :
En utilisant ces valeurs, nous pouvons calculer le cap de la boussole (0° à 360°) et déterminer dans quelle direction CodeCell pointe.
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 ?
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 :
| Cap (°) | Direction |
|---|---|
| 0° (ou 360°) | Nord ↑ |
| 90° | Est → |
| 180° | Sud ↓ |
| 270° | Ouest ← |
Essayez de faire pivoter CodeCell et regardez le titre changer !
Nous pouvons maintenant éclairer la LED dans différentes couleurs en fonction de la direction :
#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
}
}
}
Maintenant que vous pouvez lire les données du magnétomètre et calculer la direction, essayez :
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.
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).
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 :
Plus la valeur est élevée, plus la rotation est rapide.
Maintenant, détectons quand CodeCell tourne à gauche ou à droite et modifions la couleur de la LED RVB en conséquence .
Ce programme :
#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.
Essayez de modifier ROTATION_THRESHOLD pour augmenter ou diminuer la sensibilité.
Maintenant que vous pouvez suivre la rotation, essayez :
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.
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 :
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.
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);
}
}
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.
Maintenant que vous pouvez détecter les mouvements , voici quelques défis amusants :
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.
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.
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
}
}
}
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.
Les broches SDA et SCL de l'I2C sont situées sur la face inférieure de la carte CodeCell.
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 :
| Capteur | Adresse |
|---|---|
| VCNL4040 (capteur de lumière) | 0x60 |
| BNO085 (IMU - Capteur de mouvement) | 0x4A |
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.
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.
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.
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);
}
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() .
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 ).Si vous connectez un potentiomètre à IO2 , vous pouvez lire sa position avec :
uint16_t potValue = myCodeCell.pinADC(2);
Serial.println(potValue);
É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
Le microcontrôleur embarqué utilise une référence de tension interne de 2,5 V. Cela signifie :
Pour mettre à l’échelle correctement les lectures :
float voltage = (myCodeCell.pinADC(2) / 4095.0) * 2.5;
Serial.println(voltage);
pinADC()
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.
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.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);
pinPWM() et vous êtes prêt à partir.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.
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);
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.
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 !