If you’ve just got your hands on the CodeCell, you're in for a treat. This tiny module is designed to simplify your DIY projects with multiple features packed into a penny-sized board. In this guide, we’ll walk you through:
CodeCell is a compact and versatile module featuring the ESP32-C3, multiple power options, and integrated sensors, all within a tiny 1.85 cm wide form factor. These features make it a powerful tool for a wide range of applications.
In this first section, we'll start by getting familiar with the circuitry that forms the CodeCell. After that, we'll walk through the simple steps to set up your CodeCell.
ESP32C3 Module
At the heart of the CodeCell is the ESP32C3 module, a compact microcontroller known for being maker-friendly in the IoT space. It combines an Arduino-compatible architecture with built-in Wi-Fi and Bluetooth Low Energy (BLE) capabilities. This integration offers the most popular connectivity options while maintaining a small form factor.
The ESP32C3 module's PCB antenna is positioned on one side, away from other components, to minimize interference and improve signal transmission and reception. This placement helps reduce the impact of ground planes or other conductive surfaces that could degrade antenna performance. The components on the bottom side are kept within the recommended clearance for the antenna. From testing we found that the antenna's performance remains unaffected by the minimal interference from a USB-C cable, as these cables are typically shielded.
The ESP32-C3 provides plenty of memory, with 4 MB of Flash and 400 KB of SRAM, making it capable of running most typical applications. Its 32-bit RISC-V single-core processor, running at up to 160 MHz, efficiently handles various tasks. This combination of memory and processing power makes the ESP32-C3 suitable for a wide range of uses.
The ESP32C3 module also supports a USB Serial/JTAG Controller, allowing us to make the CodeCell reflashable through the USB-C port and to send serial data for communication and debugging.
Power Management
The CodeCell offers flexibility in power supply options. It can be powered through the LiPo battery connector, a USB-C cable, or both.
The LiPo battery connector makes it easier than ever to safely connect the battery without the need for soldering or risking accidental shorting it.
The USB-C port serves dual purposes: it is used for both powering the device and/or reprogramming it. This multi-power option is enabled through the BQ24232 battery management chip, which features dynamic power-path management (DPPM) that can power the system while simultaneously and independently charging the battery. The battery charging process is managed in three phases: conditioning precharge, constant current, and constant voltage. To protect the battery the output voltage (Vo) is regulated though the BQ24232 chip. This output supports a maximum output current of 1500mA when powered by the LiPo battery and 450mA when powered via USB.
By default, the LiPo battery charge current is set to 90mA, ensuring a balanced and a safe charge rate for the optional 170mAh LiPo battery. Further more, for those who wish to adjust the charging rate, 0402 resistor R12 have to be de-soldered and replace it with a new resistor based on the formula (R = 870/Ichrg). This is only recommended for soldering pros, who aren’t afraid of wrestling with tiny 0402 components! Check the BQ24232 datasheet for more information on the battery charging.
The CodeCell library can provides visual feedback on the battery/usb power status via the onboard addressable RGB LED:
The power regulation is further supported by multiple decoupling capacitors, including up to two bulk capacitors of 100µF each, placed next to the battery-connector. These capacitors are connected to the 3.3V and the output Vo pins to ensure stable power delivery. Additionally, the board features two TVS diodes for protection; one safeguards the USB input 5V voltage (Vin), and the other protects the output voltage (Vo). These TVS diodes provide protection against electrostatic discharges (ESD), capable of safely absorbing repetitive ESD strikes above the maximum level specified in the IEC 61000-4-2 international standard without performance degradation.
The board also includes an onboard 3.3V Low Dropout (LDO) regulator, which provides a stable power supply to its low-voltage components. This tiny NCP177 LDO chip can output up to 500mA output current with a typically low dropout voltage of 200mV at 500mA.
GPIO and Power Pins
Given the compact design, the main challenge was to maximize the use of GPIO pins. We tackled this by dividing each of the three available sides of the CodeCell into different I/O sections based on their applications. We also placed power pins along the edges of the module for easy connection to various power sources, allowing you to connect other modules, sensors, and actuators to different sides.
On the bottom side, 3 out of 5 pins are used for power: a ground pin (GD), a 3.3V logic-level power pin (3V3) and a 5V input charge pin (5V0). This 5V0 pin is connected to the USB input-voltage. This means you can use it to get 5V power when the USB is connected, or you can use it as a power input for charging instead of using the USB.. The other 2 pins are the I2C SDA & SCL pins for adding external digital sensors. If your not using any external and the light/motion sensors, these I2C pins can be set up as GPIOs.
The other two sides each have a ground pin (GD) and a voltage output pin (VO). Each side also features 3 programmable GPIO pins (IO1, IO2, IO3, IO5, IO6, IO7), which can all be configured as PWM pins (ideal for directly connecting an h-bridge for actuator/motor control). IO1, IO2, and IO3 can also be used as ADC pins.
Sensing Capabilities
The CodeCell's standout features include its onboard sensors. Each unit comes equipped with a built-in light sensor, and there's also an optional motion sensor available to elevate your project's motion detection—especially useful for robotics and wearables!
Next we'll dive into how the CodeCell library simplifies both configuring these sensors and reading their data.
What about the BOOT Pin?
Some ESP32 development boards include both a RST (Reset) button and a BOOT button to manually put the device into programming mode. However, the ESP32-C3, such as the one on the CodeCell module, can automatically enter boot mode through the serial interface when using the Arduino IDE. This means the CodeCell doesn't need dedicated RST or BOOT buttons, which allowed us to make it as small as it is.
In the rare case that your CodeCell freezes or encounters an exception (causing it to continuously reset), you can manually force it into boot mode to reflash the firmware. To do this, simply follow these steps:
Following these steps will restore your CodeCell back to life.
To make programming even easier, the CodeCell library provides a wide array of functions for initializing, reading, and managing sensors and power. In this section we're going to explain everything you need to know about setup up your device and it's library.
Unboxing Your CodeCell
Let’s start with what you’ll find inside the box. Depending on the options you selected during checkout, in the box you'll find:
Powering Up Your CodeCell for the First Time
Let's start by plugging in a USB-C cable! Once your CodeCell receives power it should:
Setting Up Your CodeCell
Next step is to connect the CodeCell to Arduino IDE and run a sketch:
With your IDE all set up, we can now go ahead an install the "CodeCell" library. To do this go to 'Sketch>Include Library>Manage Libraries' - the 'Library Manager' should open up. Just type "CodeCell" and click 'Install' to download the latest version of the CodeCell.
We are continuously updating and adding new features to this library, so make sure you're using the latest version.
To quickly get familiar with this library, go to 'File > Examples > CodeCell,' where you'll find multiple examples you can use and modify for your projects. We recommend starting with the 'GettingStarted' example, which contains just a few lines of code but explains all the sensing functionalities available with CodeCell.
Once you select an example sketch, click the 'Upload' button to flash the code onto your CodeCell. After uploading, open the Serial Monitor 'Tools > Serial Monitor' to see serial data from your CodeCell.
Here are some additional CodeCell tutorials to help you get started with various applications:
CodeCell Library Functions
To explore the code further, let's break down all the functions and explain what each one does:
Initializing CodeCell
The first step in using the CodeCell is to initialize it. This is done using the `myCodeCell.Init()` function, which allows you to specify the sensors you want to enable.
Available Sensing Macros:
You can combine multiple macros using the `+` operator to initialize multiple sensors at once.
Managing Power
The `myCodeCell.Run()` function is crucial for power management. This function should be called within the `loop()` function to handle battery status and ensure optimal power usage.
Function Behavior:
Reading Sensor Data
After initializing the sensors, you can read their data using various functions provided by the library. Here's a quick rundown of the available functions:
Light Sensor Functions:
Motion Sensor Functions:
Example Usage:
Sleep, Power-Saving, Diagnostic & LED Functions
The CodeCell includes several functions to manage sleep and power-saving modes:
You've now taken your first steps with CodeCell. Dive deeper into the library examples, explore sensor integrations, and start bringing your innovative projects to life with CodeCell!
Dans ce guide, nous découvrirons comment configurer l'ESP32-C3 du CodeCell pour qu'il soit utilisé comme télécommande WiFi, communiquant entre deux appareils.
Dans cet exemple, nous allons associer deux appareils CodeCell . L'appareil 1 collectera les données du capteur et les enverra à l'appareil 2 via le Wi-Fi à l'aide du protocole ESP-NOW. Nous commencerons par une configuration simple où le capteur de proximité de l'appareil 1 contrôle la LED intégrée de l'appareil 2. Dans le deuxième exemple, l'appareil 1 enverra des données angulaires et l'appareil 2 traitera les données pour ajuster les vitesses du moteur.
Avant de pouvoir établir une communication entre les deux appareils CodeCell , vous devez d'abord obtenir l'adresse MAC du récepteur. Cette adresse MAC sera utilisée dans le code de l'expéditeur pour garantir que le bon appareil reçoit les données.
Suivez ces étapes pour obtenir l’adresse MAC du récepteur :
XX:XX:XX:XX:XX:XX . Copiez cette adresse, car vous en aurez besoin pour le code de l'expéditeur.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 }; // Replace with receiver's MAC address
void setup() {
Serial.begin(115200);
myCodeCell.Init(LIGHT); // Initializes Light Sensing
// Initialize WiFi in Station mode
WiFi.mode(WIFI_STA);
Serial.println(WiFi.macAddress());
// Initialize ESP-NOW
if (esp_now_init() != ESP_OK) {
Serial.println("Error initializing ESP-NOW");
return;
}
// Register peer
esp_now_peer_info_t peerInfo;
memcpy(peerInfo.peer_addr, receiverMAC, 6);
peerInfo.channel = 0;
peerInfo.encrypt = false;
if (esp_now_add_peer(&peerInfo) != ESP_OK) {
Serial.println("Failed to add peer");
return;
}
}
void loop() {
si (myCodeCell.Run()) {
uint16_t ProxRead = (myCodeCell.Light_ProximityRead()) >> 4; // Obtenir la valeur de proximité et diviser par 16
Série.println(ProxRead);
résultat esp_err_t = esp_now_send(récepteurMAC, (uint8_t *)&ProxRead, sizeof(ProxRead));
si (résultat == ESP_OK) {
Serial.println("Données envoyées avec succès");
} autre {
Serial.println("Erreur d'envoi");
}
}
}
#include <esp_now.h>
#include <WiFi.h>
#include <CodeCell.h>
CodeCell myCodeCell;
void setup() {
Serial.begin(115200);
myCodeCell.Init(LIGHT); // Initializes Light Sensing
// Initialize WiFi in Station mode
WiFi.mode(WIFI_STA);
Serial.println(WiFi.macAddress());
// Initialize ESP-NOW
if (esp_now_init() != ESP_OK) {
Serial.println("Error initializing ESP-NOW");
return;
}
// Register the receive callback
esp_now_register_recv_cb(onDataRecv);
}
// Receive callback function
void onDataRecv(const esp_now_recv_info *recvInfo, const uint8_t *incomingData, int len) {
uint16_t Valeur_distante;
memcpy(&Valeur_à_distance, données_entrantes, sizeof(Valeur_à_distance));
Serial.println(Valeur_à_distance);
myCodeCell.LED(0, Remote_Value, 0); // Contrôle la luminosité de la LED intégrée
}
boucle vide() {
// Rien à faire ici
}
Dans ce deuxième exemple, nous connectons deux moteurs avec deux DriveCells au récepteur. L'appareil 1 lit les données angulaires de ses capteurs de mouvement et les envoie à l'appareil 2, qui ajuste la vitesse de deux moteurs en fonction des données reçues.
Si vous utilisez des appareils différents pour cet exemple, n'oubliez pas de lire la nouvelle adresse MAC du récepteur et de remplacer l'adresse MAC réservée dans le code de l'expéditeur.
#include <esp_now.h>
#include <WiFi.h>
#include <CodeCell.h>
CodeCell monCodeCell;
uint8_t receiverMAC[] = {0xXX, 0xXX, 0xXX, 0xXX, 0xXX, 0xXX}; // Remplacer par l'adresse MAC du récepteur
int Roll_Control = 0;
flotteur Rouleau = 0,0;
float Pas = 0,0 ;
flotteur Lacet = 0,0;
configuration vide() {
Série.begin(115200);
myCodeCell.Init(MOTION_ROTATION); // Initialiser la détection de mouvement
// Initialiser le WiFi en mode Station
mode.WiFi(WIFI_STA);
Série.println(WiFi.macAddress());
// Initialiser ESP-NOW
si (esp_now_init() != ESP_OK) {
Serial.println("Erreur lors de l'initialisation d'ESP-NOW");
retour;
}
// Enregistrer un pair
esp_now_peer_info_t peerInfo;
memcpy(peerInfo.peer_addr, récepteurMAC, 6);
peerInfo.channel = 0;
peerInfo.encrypt = faux;
si (esp_now_add_peer(&peerInfo) != ESP_OK) {
Serial.println("Échec de l'ajout d'un homologue");
retour;
}
}
boucle vide() {
si (myCodeCell.Run()) {
myCodeCell.Motion_RotationRead(Roll, Pitch, Yaw);
Jet = Jet + 180 ;
Lancer = (lancer * 100) / 180 ;
Roll = contraindre(Roll, 0, 200) / 2;
Roll_Control = (uint8_t)Rouler;
Série.println(Roll_Control);
esp_now_send(récepteurMAC, (uint8_t *)&Roll_Control, sizeof(Roll_Control));
}
}
#include <esp_now.h>
#include <WiFi.h>
#include <CodeCell.h>
#include <DriveCell.h>
#define IN1_pin1 2
#define IN1_pin2 3
#define IN2_pin1 5
#define IN2_pin2 6
CodeCell myCodeCell;
DriveCell Motor1(IN1_pin1, IN1_pin2);
DriveCell Motor2(IN2_pin1, IN2_pin2);
void setup() {
Serial.begin(115200);
myCodeCell.Init(LIGHT); // Initialize Light Sensing
Motor1.Init();
Motor2.Init();
// Initialize WiFi in Station mode
WiFi.mode(WIFI_STA);
Serial.println(WiFi.macAddress());
// Initialize ESP-NOW
if (esp_now_init() != ESP_OK) {
Serial.println("Error initializing ESP-NOW");
return;
}
// Register the receive callback
esp_now_register_recv_cb(onDataRecv);
}
void onDataRecv(const esp_now_recv_info *recvInfo, const uint8_t *incomingData, int len) {
int Roll_Speed = 0;
memcpy(&Roll_Speed, incomingData, sizeof(Roll_Speed));
if (Roll_Speed > 50) {
Moteur1.Drive(1, Vitesse_Roll);
Motor2.Drive(1, Roll_Speed);
} autre {
Vitesse_de_roulage = 100 - Vitesse_de_roulage ;
Motor1.Drive(0, Vitesse_Roll);
Motor2.Drive(0, Vitesse_Roll);
}
Série.println(Roll_Speed);
}
boucle vide() {
si (myCodeCell.Run()) {}
}
En suivant ces exemples, vous pouvez configurer deux appareils CodeCell pour communiquer via WiFi à l'aide d'ESP-NOW. Les exemples montrent comment envoyer des données de proximité et angulaires entre les appareils et utiliser les données pour le contrôle en temps réel des LED et des moteurs.
N'hésitez pas à développer ces projets en incorporant davantage de capteurs ou de fonctionnalités supplémentaires pour améliorer les fonctionnalités de votre système distant !
Dans cette version, nous allons découvrir comment configurer l'ESP32-C3 du CodeCell pour utiliser l'IA Gemini de Google pour les interactions basées sur des invites Arduino. Vous apprendrez comment envoyer une invite via le moniteur série et, dans un deuxième exemple, comment le CodeCell peut déclencher automatiquement une blague en fonction de la détection de proximité. Ce projet est idéal pour tous ceux qui cherchent à ajouter des capacités d'IA à leurs projets IoT.
Dans cet exemple, nous utilisons le modèle Gemini de Google pour générer du contenu en fonction des entrées utilisateur ou des données de capteur. Tout au long de ce tutoriel, nous utiliserons et modifierons l' exemple de code créé par « techiesms » - Regardez le tutoriel complet ici.
Grâce aux capacités Wi-Fi de l'ESP32-C3, vous pouvez effectuer des requêtes HTTP vers l'API Gemini de Google, ce qui permet une interaction en temps réel avec l'IA. Que vous demandiez des réponses textuelles ou que vous génériez des résultats créatifs comme des blagues, cette intégration est simple à mettre en œuvre.
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 invites de texte que vous envoyez via le moniteur série. N'oubliez pas de remplacer les espaces réservés par vos identifiants Wi-Fi et votre jeton API Gemini.
#include <Arduino.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <CodeCell.h>
CodeCell myCodeCell;
const char* ssid = "SSID"; //Enter your SSID
const char* password = "PASSWORD"; //Enter your password
const char* Gemini_Token = ""; //Enter your Gemini token
const char* Gemini_Max_Tokens = "100";
String res = "";
void setup() {
Serial.begin(115200);
WiFi.mode(WIFI_STA);
WiFi.disconnect();
while (!Serial);
// Wait for WiFi connection
WiFi.begin(ssid, password);
Serial.print("Connecting to ");
Serial.println(ssid);
tandis que (WiFi.status() != WL_CONNECTED) {
délai(1000);
Série.print(".");
}
Serial.println("connecté");
Serial.print("Adresse IP : ");
Série.println(WiFi.localIP());
}
boucle vide() {
tandis que (!Serial.available());
tandis que (Serial.available()) {
char add = Serial.lire();
res += ajouter;
retard(1);
}
int len = res.length();
res = res.substring(0, len - 1);
res = "\"" + res + "\"";
Client HTTP https;
si (https.begin("https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=" + String(Gemini_Token))) {
https.addHeader("Type de contenu", "application/json");
Chaîne de charge utile = "{\"contenu\": [{\"parties\":[{\"texte\": " + res + "}]}],\"generationConfig\": {\"maxOutputTokens\": " + String(Gemini_Max_Tokens) + "}} ";
int httpCode = https.POST(charge utile);
si (httpCode == HTTP_CODE_OK) {
Réponse de chaîne = https.getString();
Document dynamiqueJsonDocument doc(1024);
deserializeJson(doc, réponse);
Chaîne de réponse = doc["candidats"][0]["contenu"]["parties"][0]["texte"];
réponse.trim();
Serial.println(réponse);
} autre {
Serial.printf("[HTTPS] Échec du POST, erreur : %s\n", https.errorToString(httpCode).c_str());
}
https.end();
} autre {
Serial.printf("[HTTPS] Impossible de se connecter\n");
}
res = "";
}
Cet exemple utilise le capteur de proximité de CodeCell pour déclencher une invite lorsqu'un objet est détecté à proximité. L'IA répondra avec une blague.
#include <Arduino.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <CodeCell.h>
CodeCell myCodeCell;
const char* ssid = "SSID"; //Enter your SSID
const char* password = "PASSWORD"; //Enter your password
const char* Gemini_Token = ""; //Enter your Gemini token
const char* Gemini_Max_Tokens = "100";
String res = "";
void setup() {
Serial.begin(115200);
myCodeCell.Init(LIGHT); // Initializes proximity sensing
mode.WiFi(WIFI_STA);
WiFi.déconnecter();
tandis que (!Série);
WiFi.begin(ssid, mot de passe);
Serial.print("Connexion à ");
Série.println(ssid);
tandis que (WiFi.status() != WL_CONNECTED) {
délai(1000);
Série.print(".");
}
Serial.println("connecté");
Serial.print("Adresse IP : ");
Série.println(WiFi.localIP());
}
boucle vide() {
si (myCodeCell.Run()) {
uint16_t proximité = myCodeCell.Light_ProximityRead();
si (proximité > 100) {
Serial.println("Voici une nouvelle blague...");
myCodeCell.LED(0, 0xFF, 0); // Réglez la LED sur Vert lorsque la proximité est détectée
res = "\"Raconte-moi une blague unique\"";
Client HTTP https;
si (https.begin("https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=" + String(Gemini_Token))) {
https.addHeader("Type de contenu", "application/json");
Chaîne de charge utile = "{\"contenu\": [{\"parties\":[{\"texte\": " + res + "}]}],\"generationConfig\": {\"maxOutputTokens\": " + String(Gemini_Max_Tokens) + "}} ";
int httpCode = https.POST(charge utile);
si (httpCode == HTTP_CODE_OK) {
Réponse de chaîne = https.getString();
Document dynamiqueJsonDocument doc(1024);
deserializeJson(doc, réponse);
Chaîne de réponse = doc["candidats"][0]["contenu"]["parties"][0]["texte"];
réponse.trim();
Serial.println(réponse);
} autre {
Serial.printf("[HTTPS] Échec du POST, erreur : %s\n", https.errorToString(httpCode).c_str());
}
https.end();
} autre {
Serial.printf("[HTTPS] Impossible de se connecter\n");
}
res = "";
}
}
}
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); // Définissez le débit en bauds série sur 115 200. Assurez-vous que Tools/USB_CDC_On_Boot est activé si vous utilisez Serial.
myCodeCell.Init(LIGHT); // Initialise la détection de lumière
FlatFlap1.Init();
FlatFlap2.Init();
FlatFlap1.Tone();
FlatFlap2.Tone();
}
boucle vide() {
si (myCodeCell.Run()) {
// S'exécute toutes les 100 ms
uint16_t proximité = myCodeCell.Light_ProximityRead();
Serial.println(proximité);
si (proximité < 100) {
// Si une proximité est détectée, le rabat FlatFlaps
FlatFlap1.Run(1, 100, 400);
FlatFlap2.Run(1, 100, 400);
} autre {
// Ajuster l'angle de FlatFlap en fonction de la proximité
proximité = proximité - 100 ;
proximité = proximité / 10 ;
si (proximité > 100) {
proximité = 100;
}
FlatFlap1.Drive(0, proximité);
FlatFlap2.Drive(0, proximité);
}
}
}
Ce projet montre comment utiliser le capteur de proximité du CodeCell pour les gestes de profondeur, en pilotant les angles des FlatFlaps en fonction de la distance de l'objet. Expérimentez avec le code, personnalisez les paramètres et donnez vie à votre propre robot Flappy !
Dans cette version, nous allons découvrir comment configurer le capteur de mouvement intégré du CodeCell pour essayer de deviner l'activité personnelle que vous effectuez et l'afficher sur un écran OLED. Il est conçu pour suivre différents états tels que la marche, la course, le vélo, la montée des escaliers et la conduite !
Le capteur de mouvement du CodeCell est capable de catégoriser diverses activités personnelles en fonction des schémas de mouvement. En fonction de ces schémas, le capteur BNO085 essaiera de deviner quelle activité est en cours d'exécution. Ces activités comprennent la marche, la course, le vélo, la conduite et bien plus encore.
La bibliothèque CodeCell vous permet de lire directement l'activité sans aucun code complexe.
Dans cet exemple, le CodeCell surveille en permanence l'activité personnelle estimée du BNO085. L'activité ayant la plus grande chance d'être détectée est ensuite affichée sur un écran OLED à l'aide de la bibliothèque Adafruit SSD1306. Cette configuration est idéale pour créer des moniteurs d'activité portables ou des trackers de fitness qui fournissent un retour d'information en temps réel sur les activités physiques.
Notez que certaines activités peuvent prendre entre 10 et 30 secondes pour commencer à être reconnues, car cela dépendra principalement de l'orientation du CodeCell et de l'endroit où il est monté.
Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Assurez-vous que votre CodeCell est connecté via USB-C et que votre écran OLED est correctement câblé sur le côté inférieur du CodeCell , à l'aide de ses broches de masse, 3V3 et I2C (SDA et SCL).
Suivez les commentaires dans le code pour comprendre chaque étape.
#include <CodeCell.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
CodeCell myCodeCell;
/* Configure the OLED Display */
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 32 // OLED display height, in pixels
#define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin)
#define SCREEN_ADDRESS 0x3C // Adresse de l'écran OLED
Affichage Adafruit_SSD1306 (LARGEUR_ÉCRAN, HAUTEUR_ÉCRAN, &Câble, RÉINITIALISATION_OLED) ;
int read_timer = 0;
configuration vide() {
Serial.begin(115200); // Définissez le débit en bauds série sur 115 200. Assurez-vous que Tools/USB_CDC_On_Boot est activé si vous utilisez Serial.
myCodeCell.Init(MOTION_ACTIVITY); // Initialise la détection d'activité.
si (!display.begin(SSD1306_SWITCHCAPVCC, ADRESSE_ECRAN)) {
Serial.println(F("Échec de l'allocation SSD1306"));
}
affichage.clearDisplay();
affichage.setTextSize(1);
affichage.setTextColor(SSD1306_WHITE);
affichage.display();
retard (2000);
}
boucle vide() {
si (myCodeCell.Run()) {
si (read_timer < 10) {
lire_timer++;
} autre {
// Mise à jour toutes les 1 seconde
minuteur_de_lecture = 0;
affichage.clearDisplay();
affichage.setCursor(32, 16);
display.print(F("Activité : "));
affichage.setCursor(32, 24);
commutateur (myCodeCell.Motion_ActivityRead()) {
cas 1:
display.print("Conduite");
casser;
cas 2:
display.print("Cyclisme");
casser;
cas 3:
cas 6:
display.print("Marche");
casser;
cas 4:
display.print("Toujours");
casser;
cas 5:
display.print("Inclinaison");
casser;
cas 7:
display.print("En cours d'exécution");
casser;
cas 8:
display.print("Escalier");
casser;
défaut:
display.print("Lecture..");
casser;
}
affichage.display();
}
}
}
Ce projet montre comment utiliser le capteur de mouvement du CodeCell pour surveiller les activités personnelles et afficher les résultats sur un écran OLED. Cette configuration de base fournit une base pour le développement de systèmes de surveillance d'activité plus avancés.
Expérimentez avec le code et les paramètres pour créer votre propre objet portable personnalisé !
Dans cette version, nous allons découvrir comment utiliser le capteur de mouvement intégré du CodeCell pour mesurer le nombre de pas et afficher ces nombres sur un écran OLED. Ce projet montre comment créer un compteur de pas, idéal pour les trackers de fitness, les podomètres ou tout autre projet de bricolage nécessitant une surveillance de l'activité.
Le CodeCell est équipé d'un capteur de mouvement qui peut suivre le nombre de pas en utilisant ses capteurs intégrés pour détecter des modèles de mouvement spécifiques. Cet algorithme est exécuté à l'intérieur du capteur BNO085 et la bibliothèque CodeCell vous aide à lire facilement ces nombres de pas.
Dans cet exemple, le CodeCell surveille en permanence les pas et met à jour le nombre. Ce nombre est ensuite affiché sur un écran OLED à l'aide de la bibliothèque Adafruit SSD1306.
Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Assurez-vous que votre CodeCell est correctement connecté via USB-C et que votre écran OLED est correctement câblé sur le côté inférieur du CodeCell . Vous pouvez y utiliser ses broches de masse, 3V3 et I2C (SDA et SCL).
Suivez les commentaires dans le code pour comprendre chaque étape.
#include <CodeCell.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
CodeCell monCodeCell;
/* Configurer l'écran OLED */
#define SCREEN_WIDTH 64 // Largeur de l'écran OLED, en pixels
#define SCREEN_HEIGHT 32 // Hauteur de l'écran OLED, en pixels
#define OLED_RESET -1 // Réinitialiser la broche # (ou -1 si vous partagez la broche de réinitialisation Arduino)
#define SCREEN_ADDRESS 0x3C // Adresse de l'écran OLED
Affichage Adafruit_SSD1306 (LARGEUR_ÉCRAN, HAUTEUR_ÉCRAN, &Câble, RÉINITIALISATION_OLED) ;
uint16_t compteur_pas = 0;
vide configuration() {
Serial.begin(115200); // Définissez le débit en bauds série sur 115 200. Assurez-vous que Tools/USB_CDC_On_Boot est activé si vous utilisez Serial.
myCodeCell.Init(MOTION_STEP_COUNTER); // Initialise le comptage des pas et la détection d'activité.
si (!display.begin(SSD1306_SWITCHCAPVCC, ADRESSE_ECRAN)) {
Serial.println("Erreur d'affichage");
}
affichage.clearDisplay();
affichage.setTextSize(1);
affichage.setTextColor(SSD1306_WHITE);
affichage.display();
retard (2000);
}
boucle vide() {
si (myCodeCell.Run()) {
// Lire le nombre de pas à partir du capteur de mouvement CodeCell.
myCodeCell.Motion_StepCounterRead(compteur_de_pas);
// Effacer l'affichage et afficher le nombre de pas.
affichage.clearDisplay();
display.setCursor(32, 16); // Commence dans le coin supérieur gauche
display.print(F("Étapes : "));
affichage.print(compteur_de_pas);
affichage.display();
}
}
Ce projet montre comment utiliser le capteur de mouvement du CodeCell pour compter les pas et afficher le nombre sur un écran OLED. Expérimentez avec le code pour créer votre propre appareil de fitness portable !
Dans cette version, nous allons découvrir comment utiliser le capteur de mouvement à 9 axes intégré du CodeCell pour lire les angles de roulis, de tangage et de lacet, et utiliser ces angles pour contrôler un servomoteur. Ce projet montre comment créer des commandes interactives basées sur le mouvement, parfaites pour la robotique, les cardans ou tout projet nécessitant un contrôle de rotation réactif.
Le CodeCell est équipé d'un capteur de mouvement BNO085, qui fournit des capacités de détection de mouvement précises, notamment les angles de roulis, de tangage et de lacet. En lisant ces angles, vous pouvez créer des commandes de mouvement interactives pour diverses applications, telles que la stabilisation de plates-formes ou la création d'une réponse à l'orientation de l'appareil.
Le capteur de mouvement BNO085 lit les valeurs de l'accéléromètre, du gyroscope et du magnétomètre et calcule les vecteurs de rotation. Ces vecteurs sont envoyés au CodeCell qui les transforme ensuite en données angulaires pour obtenir le roulis, le tangage et le lacet en fonction de l'orientation de l'appareil dans l'espace. Ces angles représentent la rotation de l'appareil selon trois axes. Dans cet exemple, nous utiliserons l'angle de tangage pour contrôler la position d'un servomoteur, lui permettant de réagir de manière dynamique aux changements d'orientation.
Dans cet exemple, le CodeCell surveille en permanence l'angle d'inclinaison. La valeur d'inclinaison est utilisée pour définir la position du servomoteur, lui permettant de tourner en fonction de l'inclinaison de l'appareil. Cette fonctionnalité de base peut être étendue pour créer des interactions plus complexes, telles que le contrôle de plusieurs servos, la stabilisation d'une plate-forme ou l'ajout de mouvements réactifs à un robot.
Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Assurez-vous que votre CodeCell est correctement connecté via USB-C. Assurez-vous également que votre servomoteur peut être alimenté via USB-C et ajoutez ses limites angulaires au code.
Pour cet exemple, vous devez télécharger la bibliothèque ESp32Servo pour contrôler le servomoteur avec votre CodeCell . Suivez les commentaires dans le code pour comprendre chaque étape.
#include <CodeCell.h>
#include <ESP32Servo.h>
CodeCell myCodeCell;
Servo myservo;
float Roll = 0.0;
float Pitch = 0.0;
float Yaw = 0.0;
int servo_angle = 0;
void setup() {
Serial.begin(115200); // Set Serial baud rate to 115200. Ensure Tools/USB_CDC_On_Boot is enabled if using Serial
myCodeCell.Init(MOTION_ROTATION); // Initializes rotation sensing
myservo.attach(1); // Attaches the servo on pin 1 to the servo object
}
void loop() {
if (myCodeCell.Run()) {
// Read rotation angles from the BNO085 sensor
myCodeCell.Motion_RotationRead(Roll, Pitch, Yaw);
// Convert the pitch angle to a servo angle
servo_angle = abs((int)Pas);
servo_angle = (180 - servo_angle);
// Limitez l'angle du servo à la plage de 0 à 60 degrés
si (servo_angle > 60) {
servo_angle = 60;
} sinon si (servo_angle < 0) {
servo_angle = 0;
}
Serial.println(servo_angle); // Imprimer l'angle du servo pour le débogage
myservo.write(servo_angle); // Définir la position du servo
}
}
servo_angle dans le code. Dans cet exemple, nous utilisons un micro-servomoteur à plage de 60 degrés. Notez que certains servomoteurs ne sont pas mécaniquement linéaires, vous devrez donc peut-être également compenser son erreur angulaire-mécanique.Ce projet présente les bases de l'utilisation de la détection de rotation avec CodeCell pour contrôler un servomoteur, ouvrant de nombreuses possibilités pour des projets sensibles au mouvement. Expérimentez avec le code, modifiez les paramètres et créez vos propres builds dynamiques !
Dans cette version, nous allons découvrir comment utiliser le capteur de mouvement à 9 axes intégré du CodeCell pour détecter les appuis. Ce projet montre comment utiliser la détection d'appui pour les commandes interactives, ce qui la rend parfaite pour créer des actions réactives avec un simple appui sur l'appareil.
Le CodeCell est équipé d'un capteur de mouvement BNO085, qui offre une variété de capacités de détection, notamment la détection des appuis. Cette fonction utilise les données de l'accéléromètre pour détecter les appuis, ce qui la rend idéale pour les commandes interactives telles que l'activation et la désactivation de lumières, le déclenchement d'effets sonores ou d'autres actions basées sur un simple geste d'appui.
Le capteur de mouvement BNO085 détecte les appuis en surveillant les accélérations soudaines le long de ses axes. Lorsqu'un appui est détecté, le capteur enregistre l'événement, ce qui vous permet de déclencher des actions telles que l'allumage d'une LED ou le basculement d'autres appareils. Cette fonctionnalité est particulièrement utile pour créer des interactions tactiles sans avoir recours à des boutons mécaniques.
Dans cet exemple, le CodeCell surveille en permanence les appuis. Lorsqu'un appui est détecté, la LED intégrée s'allume en jaune pendant une seconde. Vous pouvez étendre cette fonctionnalité de base pour créer des interactions plus complexes, telles que le contrôle de plusieurs LED, moteurs ou autres appareils connectés en fonction des entrées d'appui.
Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Assurez-vous que votre CodeCell est correctement connecté via USB-C et suivez les commentaires dans le code pour comprendre chaque étape.
#include <CodeCell.h>
CodeCell myCodeCell;
void setup() {
Serial.begin(115200); // Définissez le débit en bauds série sur 115200. Assurez-vous que Tools/USB_CDC_On_Boot est activé si vous utilisez Serial
myCodeCell.Init(MOTION_TAP_DETECTOR); // Initialise la détection de pression
}
boucle vide() {
si (myCodeCell.Run()) {
// S'exécute toutes les 100 ms pour vérifier les robinets
si (myCodeCell.Motion_TapRead()) {
// Si un tapotement est détecté, la LED s'allume en jaune pendant 1 seconde
myCodeCell.LED(0xA0, 0x60, 0x00); // Définir la LED sur jaune
delay(1000); // Gardez la LED allumée pendant 1 seconde
}
}
}
Dans l'exemple suivant, nous utilisons une CoilCell pour inverser sa polarité et actionner un point de retournement. Cela étend l'interactivité en utilisant la détection de tapotement pour contrôler les appareils externes, créant ainsi une réponse plus dynamique.
#include <CoilCell.h>
#include <CodeCell.h>
#define IN1_pin1 5
#define IN1_pin2 6
CoilCell myCoilCell(IN1_pin1, IN1_pin2);
CodeCell myCodeCell;
void setup() {
Serial.begin(115200); // Définissez le débit en bauds série sur 115 200. Assurez-vous que Tools/USB_CDC_On_Boot est activé si vous utilisez Serial.
myCodeCell.Init(MOTION_TAP_DETECTOR); // Initialise la détection de pression.
myCoilCell.Init(); // Initialise le CoilCell.
myCoilCell.Tone(); // Joue une tonalité pour confirmer l'initialisation.
}
boucle vide() {
si (myCodeCell.Run()) {
// S'exécute toutes les 100 ms pour vérifier les robinets.
si (myCodeCell.Motion_TapRead()) {
// Si un tapotement est détecté, faites briller la LED en jaune et inversez la polarité de la CoilCell.
myCodeCell.LED(0xA0, 0x60, 0x00); // Définir la LED sur jaune.
myCoilCell.Toggle(100); // Basculer la polarité de la CoilCell.
delay(1000); // Délai pour maintenir la LED allumée et la polarité inversée pendant 1 seconde.
}
}
}
Ce projet présente les bases de l'utilisation de la détection de tapotement avec CodeCell . Expérimentez avec le code, personnalisez les réponses et explorez le potentiel de la détection de tapotement dans votre prochain projet !
Dans cette version, nous explorerons comment utiliser le capteur de proximité intégré du CodeCell pour détecter des objets.
Le CodeCell est équipé d'un capteur VCNL4040 capable de mesurer la proximité jusqu'à 20 cm. Ce capteur utilise la communication I2C et est automatiquement initialisé via la bibliothèque CodeCell , ce qui permet une intégration transparente dans vos projets. Que vous cherchiez à ajouter un simple contrôle de la profondeur par gestes ou à détecter des objets à proximité, le VCNL4040 facilite l'ajout de la détection de proximité dans vos constructions.
Le capteur de proximité VCNL4040 utilise la lumière infrarouge pour détecter les objets à sa portée. Il mesure la réflexion de la lumière infrarouge émise pour évaluer la proximité d'un objet, ce qui vous permet de créer des comportements réactifs en fonction de la proximité. Cette fonctionnalité est particulièrement utile pour créer un éclairage interactif, des robots, des interrupteurs sans contact ou d'autres actions basées sur la proximité.
Dans cet exemple, le CodeCell surveille en permanence les données de proximité et allume une LED rouge lorsqu'un objet est détecté. Vous pouvez étendre cette fonctionnalité de base pour créer des interactions plus complexes, telles que la variation de la couleur ou de la luminosité de la LED en fonction de la distance, ou le déclenchement de différentes actions en fonction de la proximité.
Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Assurez-vous que votre CodeCell est correctement connecté via USB-C et suivez les commentaires dans le code pour comprendre chaque étape.
#include <CodeCell.h>
CodeCell myCodeCell;
void setup() {
Serial.begin(115200); // Set Serial baud rate to 115200. Ensure Tools/USB_CDC_On_Boot is enabled if using Serial
myCodeCell.Init(LIGHT); // Initializes light sensing, including proximity
}
void loop() {
if (myCodeCell.Run()) {
// Runs every 100ms to check proximity
uint16_t proximity = myCodeCell.Light_ProximityRead();
// Check if an object is within range
if (proximity > 100) {
myCodeCell.LED(0xFF, 0, 0); // Set LED to Red when proximity is detected
delay(1000); // Keep the LED on for 1 second
} else {
// Aucune action si l'objet est hors de portée
}
}
}
100 dans l'exemple) pour ajuster la sensibilité de la détection de proximité en fonction de votre application.myCodeCell.LED() pour créer des réponses multicolores à la proximité.Ce projet présente les bases de l'utilisation de la détection de proximité avec CodeCell , ouvrant ainsi une gamme de possibilités interactives. Expérimentez avec le code, modifiez les paramètres et personnalisez-le !
Dans cette version, nous allons découvrir comment utiliser le CodeCell pour détecter la lumière blanche et ajuster automatiquement la luminosité des LED. Ce projet présente le capteur de lumière intégré du CodeCell , qui vous aide à créer des effets d'éclairage réactifs qui s'adaptent aux conditions d'éclairage changeantes.
Le CodeCell est doté d'un capteur VCNL4040 intégré qui peut mesurer à la fois les niveaux de lumière et la proximité jusqu'à 20 cm. Ce capteur utilise la communication I2C et communique avec l'ESP32 de la bibliothèque CodeCell , où le capteur est automatiquement initialisé pour optimiser sa résolution de détection. Cela simplifie la configuration, vous pouvez donc vous concentrer sur la construction de votre projet.
Le capteur VCNL4040 du CodeCell est capable de détecter à la fois la lumière ambiante et la lumière blanche, chacune servant à des fins distinctes :
Dans ce projet, nous utilisons la fonction de détection de lumière blanche pour influencer directement la luminosité des LED en fonction des niveaux de lumière blanche détectés, créant ainsi une réponse plus ciblée par rapport à la détection de lumière ambiante générale.
Dans cet exemple, le CodeCell mesure en continu la lumière blanche ambiante et ajuste la luminosité d'une LED intégrée en fonction du niveau de lumière détecté. À mesure que la pièce s'assombrit, la LED s'atténue, offrant une transition en douceur que vous pouvez modifier et personnaliser pour vos propres projets d'éclairage.
Vous trouverez ci-dessous un exemple de code pour vous aider à démarrer. Assurez-vous que votre CodeCell est correctement connecté et suivez les commentaires dans le code pour comprendre chaque étape.
#include <CodeCell.h>
CodeCell myCodeCell;
void setup() {
Serial.begin(115200); // Set Serial baud rate to 115200. Ensure Tools/USB_CDC_On_Boot is enabled if using Serial.
myCodeCell.Init(LIGHT); // Initialise la détection de lumière.
}
boucle vide() {
delay(100); // Petit délai - Vous pouvez l'ajuster en conséquence
// Lisez la lumière blanche du capteur et ajustez la luminosité pour 8 bits
uint16_t luminosité = (myCodeCell.Light_WhiteRead()) >> 3;
Serial.println(brightness); // Imprime la valeur de luminosité sur le moniteur série pour le débogage.
// Limiter les valeurs du capteur à la plage de luminosité de la LED (1 à 254)
si (luminosité == 0U) {
luminosité = 1U; // Définir une luminosité minimale pour éviter d'éteindre complètement la LED
} sinon si (luminosité > 254U) {
luminosité = 254U; // Limitez la luminosité au niveau maximum de la LED
}
luminosité = 255U - luminosité ; // Inverser la luminosité pour que la LED diminue à mesure qu'elle devient plus lumineuse
myCodeCell.LED(0, 0, luminosité); // Faites briller la LED RVB bleue intégrée avec la nouvelle luminosité ajustée
}
myCodeCell.LED() vous permet de spécifier des valeurs RVB. Essayez d'expérimenter différentes couleurs en fonction des niveaux de lumière.Ce projet n'est que le point de départ pour exploiter les capacités de détection de lumière du CodeCell . Plongez dans le code, faites-en votre propre et illuminez votre prochain projet !