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!
In dieser Anleitung erfahren Sie, wie Sie den ESP32-C3 von CodeCell so konfigurieren, dass er als WLAN-Fernbedienung zur Kommunikation zwischen zwei Geräten verwendet werden kann.
In diesem Beispiel werden wir zwei CodeCell- Geräte koppeln. Gerät 1 sammelt Sensordaten und sendet sie über WLAN mithilfe des ESP-NOW-Protokolls an Gerät 2. Wir beginnen mit einem einfachen Setup, bei dem der Näherungssensor auf Gerät 1 die integrierte LED auf Gerät 2 steuert. Im zweiten Beispiel sendet Gerät 1 Winkeldaten und Gerät 2 verarbeitet die Daten, um die Motordrehzahl anzupassen.
Bevor Sie eine Kommunikation zwischen den beiden CodeCell- Geräten herstellen können, müssen Sie zunächst die MAC-Adresse des Empfängers ermitteln. Diese MAC-Adresse wird im Code des Absenders verwendet, um sicherzustellen, dass das richtige Gerät die Daten empfängt.
Um die MAC-Adresse des Empfängers zu ermitteln, gehen Sie folgendermaßen vor:
XX:XX:XX:XX:XX:XX ausgedruckt. Kopieren Sie diese Adresse, da Sie diese für den Absendercode benötigen.Dieses Beispiel zeigt, wie Näherungssensordaten von Gerät 1 an Gerät 2 gesendet werden, das die Daten zum Ein- oder Ausschalten der integrierten LED verwendet.
#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() {
wenn (myCodeCell.Run()) {
uint16_t ProxRead = (myCodeCell.Light_ProximityRead()) >> 4; // Näherungswert abrufen und durch 16 dividieren
Serial.println(ProxRead);
esp_err_t Ergebnis = esp_now_send(receiverMAC, (uint8_t *)&ProxRead, sizeof(ProxRead));
wenn (Ergebnis == ESP_OK) {
Serial.println("Daten erfolgreich gesendet");
} anders {
Serial.println("Sendefehler");
}
}
}
#include <esp_now.h>
#include <WiFi.h>
#include <CodeCell.h>
CodeCell myCodeCell;
void setup() {
Serial.begin(115200);
myCodeCell.Init(LIGHT); // Initializes Light Sensing
// Initialize WiFi in Station mode
WiFi.mode(WIFI_STA);
Serial.println(WiFi.macAddress());
// Initialize ESP-NOW
if (esp_now_init() != ESP_OK) {
Serial.println("Error initializing ESP-NOW");
return;
}
// Register the receive callback
esp_now_register_recv_cb(onDataRecv);
}
// Receive callback function
void onDataRecv(const esp_now_recv_info *recvInfo, const uint8_t *incomingData, int len) {
uint16_t Remote_Wert;
memcpy(&Remote_Value, eingehende Daten, Größe von(Remote_Value));
Serial.println(Remote_Wert);
myCodeCell.LED(0, Remote_Value, 0); // Helligkeit der integrierten LED steuern
}
void schleife() {
// Hier gibt es nichts zu tun
}
In diesem zweiten Beispiel verbinden wir zwei Motoren mit zwei DriveCells mit dem Empfänger. Gerät 1 liest Winkeldaten von seinen Bewegungssensoren und sendet sie an Gerät 2, das die Geschwindigkeit der beiden Motoren basierend auf den empfangenen Daten anpasst.
Wenn Sie für dieses Beispiel unterschiedliche Geräte verwenden, denken Sie daran, die neue MAC-Adresse des Empfängers auszulesen und die Platzhalter-MAC-Adresse im Code des Absenders zu ersetzen.
#include <esp_now.h>
#include <WiFi.h>
#include <CodeCell.h>
CodeCell meineCodeCell;
uint8_t receiverMAC[] = {0xXX, 0xXX, 0xXX, 0xXX, 0xXX, 0xXX}; // Ersetzen durch die MAC-Adresse des Empfängers
int Roll_Control = 0;
Gleitkommazahl Roll = 0,0;
Gleitkomma-Tonhöhe = 0,0;
Gleitkomma-Gieren = 0,0;
void setup() {
Seriell.begin(115200);
myCodeCell.Init(MOTION_ROTATION); // Bewegungserkennung initialisieren
// WiFi im Stationsmodus initialisieren
WiFi.Modus(WIFI_STA);
Serial.println(WiFi.macAddress());
// ESP-NOW initialisieren
wenn (esp_now_init() != ESP_OK) {
Serial.println("Fehler beim Initialisieren von ESP-NOW");
zurückkehren;
}
// Peer registrieren
esp_now_peer_info_t Peer-Info;
memcpy(peerInfo.peer_addr, Empfänger-MAC, 6);
peerInfo.channel = 0;
peerInfo.encrypt = falsch;
wenn (esp_now_add_peer(&peerInfo) != ESP_OK) {
Serial.println("Peer konnte nicht hinzugefügt werden");
zurückkehren;
}
}
void schleife() {
wenn (myCodeCell.Run()) {
myCodeCell.Motion_RotationRead(Rollen, Neigen, Gieren);
Rollen = Rollen + 180;
Rollen = (Rollen * 100) / 180;
Rollen = Einschränkung(Rollen, 0, 200) / 2;
Roll_Control = (uint8_t)Rollen;
Serial.println(Roll_Control);
esp_now_send(Empfänger-MAC, (uint8_t *)&Roll_Control, Größe von(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) {
Motor1.Antrieb(1, Roll_Speed);
Motor2.Antrieb(1, Roll_Speed);
} anders {
Rollgeschwindigkeit = 100 - Rollgeschwindigkeit;
Motor1.Antrieb(0, Roll_Speed);
Motor2.Antrieb(0, Roll_Speed);
}
Serial.println(Roll_Speed);
}
void schleife() {
wenn (myCodeCell.Run()) {}
}
Anhand dieser Beispiele können Sie zwei CodeCell- Geräte so konfigurieren, dass sie mit ESP-NOW über WLAN kommunizieren. Die Beispiele zeigen, wie Sie Näherungs- und Winkeldaten zwischen Geräten senden und die Daten zur Echtzeitsteuerung von LEDs und Motoren nutzen können.
Erweitern Sie diese Projekte gerne durch die Integration weiterer Sensoren oder zusätzlicher Funktionen, um die Funktionalität Ihres Remote-Systems zu verbessern!
In diesem Build untersuchen wir, wie man den ESP32-C3 von CodeCell so konfiguriert, dass er Googles Gemini AI für Arduino-basierte Interaktionen nutzt. Sie erfahren, wie Sie eine Eingabeaufforderung über den seriellen Monitor senden und in einem zweiten Beispiel, wie die CodeCell automatisch einen Witz basierend auf der Näherungserkennung auslösen kann. Dieses Projekt ist ideal für alle, die ihren IoT-Projekten KI-Funktionen hinzufügen möchten.
In diesem Beispiel verwenden wir Googles Gemini-Modell zur Generierung von Inhalten auf der Grundlage von Benutzereingaben oder Sensordaten. In diesem Tutorial verwenden und modifizieren wir das von „techiesms“ erstellte Codebeispiel . Das vollständige Tutorial finden Sie hier.
Mit den WiFi-Funktionen des ESP32-C3 können Sie HTTP-Anfragen an die Gemini-API von Google stellen und so eine Echtzeitinteraktion mit der KI ermöglichen. Egal, ob Sie nach Textantworten fragen oder kreative Ergebnisse wie Witze generieren, diese Integration ist unkompliziert zu implementieren.
Im ersten Beispiel senden Sie Eingabeaufforderungen direkt über den seriellen Monitor, und die CodeCell sendet diese Eingabe zur Verarbeitung an die Google Gemini-KI. Die Antwort der KI wird an den seriellen Monitor zurückgesendet, begrenzt auf 100 Token. Im zweiten Beispiel löst der Näherungssensor der CodeCell eine Eingabeaufforderung an die KI aus und fordert sie auf, einen Witz zu generieren, wenn sie ein Objekt erkennt. Dieses Setup kann für unterhaltsame interaktive Projekte verwendet werden, bei denen das Gerät mithilfe von KI-basierten Inhalten auf seine Umgebung reagiert.
Bevor wir die Gemini AI in unser ESP32-C3-Setup integrieren, müssen wir zunächst einen API-Schlüssel generieren und testen. Befolgen Sie die folgenden Schritte, um Ihren API-Schlüssel zu erstellen. Anschließend können Sie ihn auch mit einer Software wie Postman testen.
Da wir nun den API-Schlüssel haben, können wir ihn mit der Postman-Anwendung testen. Postman ist ein kostenloses Tool, mit dem Sie HTTP-Anfragen stellen und die Antworten anzeigen können.
https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=YOUR_API_KEY
Nachdem Sie die URL eingegeben haben, müssen wir die Anforderungsheader und den Anforderungstext einrichten.
{
"contents": [
{
"parts": [
{
"text": "Who are you?"
}
]
}
],
"generationConfig": {
"maxOutputTokens": 100
}
}
In diesem Beispiel stellen wir der KI eine einfache Frage: „Wer bist du?“ und setzen die maximale Anzahl an Token auf 100. Token steuern die Länge der von der KI generierten Antwort. Wenn Sie das Token-Limit verringern (z. B. 20 Token), wird die Antwort kürzer. Sie können mit verschiedenen Werten für maxOutputTokens experimentieren, um zu sehen, wie sich dies auf die Antwortlänge auswirkt.
"I am a large language model trained by Google."
Nachdem Sie die API generiert und ihre Funktionsfähigkeit überprüft haben, können Sie mit dem nächsten Schritt fortfahren: der Integration dieser API in Ihr CodeCell-Projekt.
Unten finden Sie den Beispielcode, der Ihnen den Einstieg erleichtert. In diesem Beispiel reagiert die KI auf Textaufforderungen, die Sie über den seriellen Monitor senden. Denken Sie daran, die Platzhalter durch Ihre WLAN-Anmeldeinformationen und das Gemini-API-Token zu ersetzen.
#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);
während (WiFi.status() != WL_CONNECTED) {
Verzögerung (1000);
Serial.print(".");
}
Serial.println("verbunden");
Serial.print("IP-Adresse: ");
Serial.println(WiFi.localIP());
}
void schleife() {
während (!Serial.available());
während (Serial.available()) {
char add = Serial.read();
res += hinzufügen;
Verzögerung(1);
}
int len = res.length();
res = res.substring(0, länge - 1);
res = "\"" + res + "\"";
HTTPClient https;
wenn (https.begin("https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=" + String(Gemini_Token))) {
https.addHeader("Inhaltstyp", "application/json");
String-Nutzlast = "{\"Inhalt\": [{\"Teile\":[{\"Text\":" + res + "}]}],\"GenerationConfig\": {\"maxOutputTokens\": " + String(Gemini_Max_Tokens) + "}} ";
int httpCode = https.POST(Nutzlast);
wenn (httpCode == HTTP_CODE_OK) {
String-Antwort = https.getString();
doc(1024);
deserializeJson(Dokument, Antwort);
String-Antwort = doc["Kandidaten"][0]["Inhalt"]["Teile"][0]["Text"];
antwort.trim();
Serial.println(Antwort);
} anders {
Serial.printf("[HTTPS] POST fehlgeschlagen, Fehler: %s\n", https.errorToString(httpCode).c_str());
}
https.ende();
} anders {
Serial.printf("[HTTPS] Verbindung konnte nicht hergestellt werden\n");
}
res = "";
}
In diesem Beispiel wird der Näherungssensor der CodeCell verwendet, um eine Eingabeaufforderung auszulösen, wenn ein Objekt in der Nähe erkannt wird. Die KI antwortet mit einem Witz.
#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
WiFi.Modus(WIFI_STA);
WiFi.trennen();
während (!Seriell);
WiFi.begin(ssid, passwort);
Serial.print("Verbindung wird hergestellt mit ");
Serial.println(ssid);
während (WiFi.status() != WL_CONNECTED) {
Verzögerung (1000);
Serial.print(".");
}
Serial.println("verbunden");
Serial.print("IP-Adresse: ");
Serial.println(WiFi.localIP());
}
void schleife() {
wenn (myCodeCell.Run()) {
uint16_t Nähe = myCodeCell.Light_ProximityRead();
wenn (Nähe > 100) {
Serial.println("Hier ist ein neuer Witz...");
myCodeCell.LED(0, 0xFF, 0); // LED auf Grün setzen, wenn Nähe erkannt wird
res = "\"Erzähl mir einen einzigartigen Witz\"";
HTTPClient https;
wenn (https.begin("https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=" + String(Gemini_Token))) {
https.addHeader("Inhaltstyp", "application/json");
String-Nutzlast = "{\"Inhalt\": [{\"Teile\":[{\"Text\":" + res + "}]}],\"GenerationConfig\": {\"maxOutputTokens\": " + String(Gemini_Max_Tokens) + "}} ";
int httpCode = https.POST(Nutzlast);
wenn (httpCode == HTTP_CODE_OK) {
String-Antwort = https.getString();
doc(1024);
deserializeJson(Dokument, Antwort);
String-Antwort = doc["Kandidaten"][0]["Inhalt"]["Teile"][0]["Text"];
antwort.trim();
Serial.println(Antwort);
} anders {
Serial.printf("[HTTPS] POST fehlgeschlagen, Fehler: %s\n", https.errorToString(httpCode).c_str());
}
https.ende();
} anders {
Serial.printf("[HTTPS] Verbindung konnte nicht hergestellt werden\n");
}
res = "";
}
}
}
Dieses Projekt zeigt, wie Sie mithilfe der Gemini-API von Google KI-Reaktionen in Ihre CodeCell-Projekte integrieren. Indem Sie die WiFi-Funktionen des ESP32-C3 nutzen, können Sie interaktive Geräte erstellen, die auf Benutzereingaben oder Umgebungsfaktoren reagieren und so Ihre IoT-Builds intelligenter und ansprechender machen.
Experimentieren Sie mit dem Code und passen Sie die Eingabeaufforderungen an Ihre Projekte an!
In diesem Build untersuchen wir, wie man das integrierte LED-Licht der CodeCell mithilfe der Espalexa -Bibliothek konfiguriert, mit der Alexa Geräte wie Smart Lights steuern kann. Wir führen Sie durch den Prozess der Verbindung der CodeCell mit Ihrem WLAN, der Einrichtung der Espalexa-Bibliothek und der Aktivierung der Sprachsteuerung für die integrierte LED über Alexa.
Die Espalexa -Bibliothek vereinfacht die Alexa-Integration für ESP32-Projekte. Sie erstellt ein virtuelles intelligentes Licht, das Alexa über Sprachbefehle steuern kann, ohne dass eine komplexe Einrichtung oder Cloud-Dienste erforderlich sind. Mithilfe dieser Bibliothek kann Ihre CodeCell als intelligentes Gerät fungieren, z. B. eine Glühbirne, die Alexa ein-, ausschalten oder dimmen kann.
In diesem Projekt wird die CodeCell so eingerichtet, dass sie eine Verbindung zu Ihrem WLAN-Netzwerk herstellt. Sobald die Verbindung hergestellt ist, kann Alexa das integrierte LED-Licht per Sprachbefehl steuern, egal ob es vollständig eingeschaltet (grün) oder ausgeschaltet (keine Farbe) ist.
Nachfolgend finden Sie den Beispielcode, der Ihnen den Einstieg erleichtert. Aktualisieren Sie die WLAN-Anmeldeinformationen mit Ihren Netzwerkdetails und folgen Sie den Kommentaren im Code, um jeden Schritt zu verstehen.
#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
}
}
void setup() {
//Seriell zum Debuggen initialisieren
Seriell.begin(115200);
myCodeCell.Init(LIGHT); /*Initialisiere die Lichterkennung*/
// Mit WLAN verbinden
WiFi.begin(ssid, passwort);
während (WiFi.status() != WL_CONNECTED) {
Verzögerung (500);
Serial.print(".");
}
Serial.println("WLAN verbunden");
// Ein Gerät zu Alexa hinzufügen
espalexa.addDevice("MeineLED", alexaCallback);
// Espalexa starten
espalexa.begin();
}
void schleife() {
espalexa.loop(); // Alexa-Anfragen verarbeiten
}
Nachdem Sie den Code hochgeladen und die CodeCell mit dem WLAN verbunden haben, müssen Sie das Gerät im nächsten Schritt zu Ihrer Alexa-App hinzufügen. Befolgen Sie diese Schritte, um es mit Alexa zu koppeln:
Mit diesen Schritten ist die integrierte LED Ihrer CodeCell jetzt vollständig in Ihr Smart-Home-Setup integriert und Sie können sie mit Alexa-Sprachbefehlen oder der Alexa-App steuern!
alexaCallback() , um je nach Helligkeitsstufe von Alexa unterschiedliche Farben zu verwenden. Sie können RGB-Werte verwenden, um verschiedene Effekte zu erzeugen.Dieses Projekt zeigt, wie Sie CodeCell mithilfe der Espalexa -Bibliothek in Alexa integrieren, um das integrierte LED-Licht zu steuern. Wenn Sie diesem Beispiel folgen, können Sie mit CodeCell ganz einfach sprachaktivierte Projekte erstellen und so IoT-Funktionen in Ihre Hände bekommen!
Werden Sie mit den Anpassungsoptionen kreativ und erwecken Sie mit der Alexa-Integration noch mehr Ihrer Projekte zum Leben!
In diesem Build untersuchen wir, wie wir den integrierten Näherungssensor der CodeCell verwenden können, um Tiefengesten zu erkennen und zwei FlatFlaps zu steuern, wobei ihre Winkel basierend auf den Näherungswerten variiert werden. Dieses Projekt zeigt eine einzigartige Möglichkeit, interaktive Roboter, Aktuatoren, Motoren oder Licht zu erstellen, die auf Handbewegungen reagieren.
Die CodeCell ist mit einem VCNL4040-Näherungssensor ausgestattet, der Entfernungen bis zu 20 cm messen kann. Mithilfe von Infrarotlicht erkennt der Sensor Objekte in seiner Reichweite und misst die Reflexion des emittierten IR-Lichts, um die Entfernung zu schätzen. Auf diese Weise können Sie reaktionsfähige Verhaltensweisen basierend auf der Nähe eines Objekts erstellen, was es ideal für interaktive Gesten macht.
Tiefengesten basieren auf den Näherungsdaten des integrierten Sensors der CodeCell . Indem Sie Ihre Hand oder andere Objekte näher an den Sensor heran oder weiter davon weg bewegen, können Sie dynamische Eingaben erstellen, die verschiedene Aktionen auslösen. In diesem Projekt werden die Näherungsdaten verwendet, um den Winkel von zwei FlatFlaps zu steuern, die mit zwei DriveCells (H-Brücken-Treibern) verbunden sind.
In diesem Beispiel liest die CodeCell kontinuierlich Näherungsdaten und passt den Winkel von zwei FlatFlaps an, je nachdem, wie nah das Objekt ist. Wenn sich das Objekt nähert oder entfernt, ändert sich der Winkel der FlatFlaps , was eine einfache, aber effektive Methode zur gestenbasierten Tiefensteuerung darstellt.
Die beiden FlatFlaps werden an zwei DriveCells (H-Brückentreiber) gelötet, die Pin-zu-Pin-kompatibel mit der CodeCell sind. Diese Komponenten werden dann auf einer 3D-gedruckten Halterung verbunden, um einen niedlichen kleinen Flappy-Bot zu erstellen! Vergessen Sie nicht, ein Wackelauge hinzuzufügen, um ihm mehr Persönlichkeit zu verleihen!
Unten finden Sie den Beispielcode, der Ihnen den Einstieg erleichtert. Stellen Sie sicher, dass Ihre CodeCell ordnungsgemäß über USB-C angeschlossen ist und die FlatFlaps mit den beiden DriveCells verbunden sind. Folgen Sie den Kommentaren im Code, um jeden Schritt zu verstehen.
#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); // Stellen Sie die serielle Baudrate auf 115200 ein. Stellen Sie sicher, dass Tools/USB_CDC_On_Boot aktiviert ist, wenn Sie die serielle Schnittstelle verwenden.
myCodeCell.Init(LIGHT); // Initialisiert die Lichterkennung
FlatFlap1.Init();
FlatFlap2.Init();
FlatFlap1.Tone();
FlatFlap2.Tone();
}
void schleife() {
wenn (myCodeCell.Run()) {
// Läuft alle 100ms
uint16_t Nähe = myCodeCell.Light_ProximityRead();
Serial.println(Nähe);
wenn (Nähe < 100) {
// Bei Annäherungserkennung flattern die FlatFlaps
FlatFlap1.Run(1, 100, 400);
FlatFlap2.Run(1, 100, 400);
} anders {
// Passen Sie den FlatFlap-Winkel basierend auf der Nähe an
Nähe = Nähe - 100;
Nähe = Nähe / 10;
wenn (Nähe > 100) {
Nähe = 100;
}
FlatFlap1.Drive(0, Näherung);
FlatFlap2.Drive(0, Näherung);
}
}
}
Dieses Projekt zeigt, wie Sie den Näherungssensor der CodeCell für Tiefengesten verwenden und die Winkel von FlatFlaps basierend auf der Objektentfernung steuern. Experimentieren Sie mit dem Code, passen Sie die Parameter an und erwecken Sie Ihren eigenen Flappy-Bot zum Leben!
In diesem Build untersuchen wir, wie man den integrierten Bewegungssensor der CodeCell so konfiguriert, dass er versucht, Ihre persönliche Aktivierung zu erraten und auf einem OLED-Bildschirm anzuzeigen. Er ist dafür gedacht, verschiedene Zustände wie Gehen, Laufen, Radfahren, Treppensteigen und Autofahren zu verfolgen!
Der Bewegungssensor der CodeCell kann verschiedene persönliche Aktivitäten anhand von Bewegungsmustern kategorisieren. Anhand dieser Muster versucht der BNO085-Sensor zu erraten, welche Aktivität ausgeführt wird. Zu diesen Aktivitäten gehören Gehen, Laufen, Radfahren, Autofahren und mehr.
Die CodeCell -Bibliothek erleichtert Ihnen das direkte Lesen der Aktivität ohne komplexen Code.
In diesem Beispiel überwacht die CodeCell kontinuierlich die persönliche Aktivitätsschätzung des BNO085. Die Aktivität mit der höchsten Wahrscheinlichkeit wird dann mithilfe der Adafruit SSD1306-Bibliothek auf einem OLED-Bildschirm angezeigt. Dieses Setup ist ideal für die Erstellung tragbarer Aktivitätsmonitore oder Fitnesstracker, die Echtzeit-Feedback zu körperlichen Aktivitäten liefern.
Beachten Sie, dass es bei manchen Aktivitäten 10–30 Sekunden dauern kann, bis sie erkannt werden. Dies hängt hauptsächlich von der Ausrichtung der CodeCell und ihrem Montageort ab.
Unten finden Sie den Beispielcode, der Ihnen den Einstieg erleichtert. Stellen Sie sicher, dass Ihre CodeCell über USB-C angeschlossen ist und Ihr OLED-Display mithilfe der Erdungs-, 3V3- und I2C-Pins (SDA und SCL) korrekt mit der Unterseite der CodeCell verbunden ist.
Folgen Sie den Kommentaren im Code, um jeden Schritt zu verstehen.
#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 des OLED-Displays
Adafruit_SSD1306-Anzeige (BILDSCHIRMBREITE, BILDSCHIRMHÖHE, &Kabel, OLED_RESET);
int read_timer = 0;
void setup() {
Serial.begin(115200); // Stellen Sie die serielle Baudrate auf 115200 ein. Stellen Sie sicher, dass Tools/USB_CDC_On_Boot aktiviert ist, wenn Sie die serielle Schnittstelle verwenden.
myCodeCell.Init(MOTION_ACTIVITY); // Initialisiert die Aktivitätserkennung.
wenn (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
Serial.println(F("SSD1306-Zuweisung fehlgeschlagen"));
}
Anzeige.clearDisplay();
Anzeige.Setzen Sie die Textgröße (1);
Anzeige.SetTextColor(SSD1306_WHITE);
Anzeige.Anzeige();
Verzögerung (2000);
}
void schleife() {
wenn (myCodeCell.Run()) {
wenn (Lesetimer < 10) {
Timer lesen++;
} anders {
// Alle 1 Sekunde aktualisieren
lese_timer = 0;
Anzeige.clearDisplay();
display.setCursor(32, 16);
display.print(F("Aktivität: "));
display.setCursor(32, 24);
Schalter (myCodeCell.Motion_ActivityRead()) {
Fall 1:
display.print("Fahren");
brechen;
Fall 2:
display.print("Radfahren");
brechen;
Fall 3:
Fall 6:
display.print("Gehen");
brechen;
Fall 4:
display.print("Still");
brechen;
Fall 5:
display.print("Kippen");
brechen;
Fall 7:
display.print("Läuft");
brechen;
Fall 8:
display.print("Treppe");
brechen;
Standard:
display.print("Lesen..");
brechen;
}
Anzeige.Anzeige();
}
}
}
Dieses Projekt zeigt, wie Sie mit dem Bewegungssensor von CodeCell persönliche Aktivitäten überwachen und die Ergebnisse auf einem OLED-Bildschirm anzeigen können. Diese grundlegende Konfiguration bietet eine Grundlage für die Entwicklung fortgeschrittenerer Aktivitätsüberwachungssysteme.
Experimentieren Sie mit dem Code und den Einstellungen, um Ihr eigenes personalisiertes Wearable zu erstellen!
In diesem Build untersuchen wir, wie man den integrierten Bewegungssensor von CodeCell verwendet, um die Anzahl der Schritte zu messen und diese auf einem OLED-Display anzuzeigen. Dieses Projekt zeigt, wie man einen Schrittzähler erstellt, der sich ideal für Fitnesstracker, Pedometer oder jedes andere DIY-Projekt eignet, das eine Aktivitätsüberwachung erfordert.
Die CodeCell ist mit einem Bewegungssensor ausgestattet, der die Schrittzahl mithilfe der integrierten Sensoren erfassen kann, um bestimmte Bewegungsmuster zu erkennen. Dieser Algorithmus wird im BNO085-Sensor ausgeführt, und die CodeCell -Bibliothek hilft Ihnen dabei, diese Schrittzahlen einfach abzulesen.
In diesem Beispiel überwacht die CodeCell kontinuierlich die Anzahl der Schritte und aktualisiert diese. Diese Anzahl wird dann mithilfe der Adafruit SSD1306-Bibliothek auf einem OLED-Bildschirm angezeigt.
Unten finden Sie den Beispielcode, der Ihnen den Einstieg erleichtert. Stellen Sie sicher, dass Ihre CodeCell ordnungsgemäß über USB-C angeschlossen ist und Ihr OLED-Display richtig mit der Unterseite der CodeCell verkabelt ist. Dort können Sie die Masse-, 3V3- und I2C-Pins (SDA und SCL) verwenden.
Folgen Sie den Kommentaren im Code, um jeden Schritt zu verstehen.
#include <CodeCell.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
CodeCell meineCodeCell;
/* Konfigurieren Sie das OLED-Display */
#define SCREEN_WIDTH 64 // Breite des OLED-Displays in Pixeln
#define SCREEN_HEIGHT 32 // Höhe des OLED-Displays in Pixeln
#define OLED_RESET -1 // Pin # zurücksetzen (oder -1, wenn Arduino-Reset-Pin geteilt wird)
#define SCREEN_ADDRESS 0x3C // Adresse des OLED-Displays
Adafruit_SSD1306-Anzeige (BILDSCHIRMBREITE, BILDSCHIRMHÖHE, &Kabel, OLED_RESET);
uint16_t Schrittzähler = 0;
void setup() {
Serial.begin(115200); // Stellen Sie die serielle Baudrate auf 115200 ein. Stellen Sie sicher, dass Tools/USB_CDC_On_Boot aktiviert ist, wenn Sie die serielle Schnittstelle verwenden.
myCodeCell.Init(MOTION_STEP_COUNTER); // Initialisiert Schrittzählung und Aktivitätserkennung.
wenn (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
Serial.println("Anzeigefehler");
}
Anzeige.clearDisplay();
Anzeige.Setzen Sie die Textgröße (1);
Anzeige.SetTextColor(SSD1306_WHITE);
Anzeige.Anzeige();
Verzögerung (2000);
}
void schleife() {
wenn (myCodeCell.Run()) {
// Schrittzahl vom CodeCell-Bewegungssensor lesen.
myCodeCell.Motion_StepCounterRead(Schrittzähler);
// Anzeige löschen und Schrittzahl anzeigen.
Anzeige.clearDisplay();
display.setCursor(32, 16); // In der oberen linken Ecke beginnen
display.print(F("Schritte: "));
Anzeige.Drucken(Schrittzähler);
Anzeige.Anzeige();
}
}
Dieses Projekt zeigt, wie Sie mit dem Bewegungssensor von CodeCell Schritte zählen und die Anzahl auf einem OLED-Bildschirm anzeigen können. Experimentieren Sie mit dem Code, um Ihr eigenes tragbares Fitnessgerät zu erstellen!
In diesem Build untersuchen wir, wie man den integrierten 9-Achsen-Bewegungssensor von CodeCell verwendet, um Roll-, Nick- und Gierwinkel zu erfassen und diese Winkel zur Steuerung eines Servomotors zu verwenden. Dieses Projekt zeigt, wie man interaktive bewegungsbasierte Steuerungen erstellt, die sich perfekt für Robotik, Kardanringe oder jedes Projekt eignen, das eine reaktionsschnelle Rotationssteuerung erfordert.
Die CodeCell ist mit einem BNO085-Bewegungssensor ausgestattet, der präzise Bewegungserkennungsfunktionen bietet, einschließlich Roll-, Nick- und Gierwinkel. Durch das Auslesen dieser Winkel können Sie interaktive Bewegungssteuerungen für verschiedene Anwendungen erstellen, z. B. zum Stabilisieren von Plattformen oder zum Erzeugen einer Reaktion auf die Geräteausrichtung.
Der Bewegungssensor BNO085 liest die Daten von Beschleunigungsmesser, Gyroskop und Magnetometer und berechnet die Rotationsvektoren. Diese Vektoren werden an die CodeCell gesendet, die sie dann in Winkeldaten umwandelt, um Roll-, Nick- und Gierungswinkel basierend auf der Ausrichtung des Geräts im Raum zu ermitteln. Diese Winkel stellen die Drehung des Geräts entlang dreier Achsen dar. In diesem Beispiel verwenden wir den Nickwinkel, um die Position eines Servomotors zu steuern, sodass dieser dynamisch auf Änderungen der Ausrichtung reagieren kann.
In diesem Beispiel überwacht die CodeCell kontinuierlich den Neigungswinkel. Der Neigungswert wird verwendet, um die Position des Servomotors festzulegen, sodass er sich je nach Neigung des Geräts drehen kann. Diese grundlegende Funktionalität kann erweitert werden, um komplexere Interaktionen zu ermöglichen, z. B. die Steuerung mehrerer Servos, die Stabilisierung einer Plattform oder das Hinzufügen von reaktionsfähigen Bewegungen zu einem Roboter.
Unten finden Sie den Beispielcode, der Ihnen den Einstieg erleichtert. Stellen Sie sicher, dass Ihre CodeCell ordnungsgemäß über USB-C angeschlossen ist. Stellen Sie außerdem sicher, dass Ihr Servomotor über USB-C mit Strom versorgt werden kann, und fügen Sie seine Winkelgrenzen dem Code hinzu.
Für dieses Beispiel müssen Sie die ESp32Servo-Bibliothek herunterladen, um den Servomotor mit Ihrer CodeCell zu steuern. Folgen Sie den Kommentaren im Code, um jeden Schritt zu verstehen.
#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)Pitch);
Servowinkel = (180 - Servowinkel);
// Begrenzen Sie den Servowinkel auf den Bereich 0-60 Grad
wenn (Servowinkel > 60) {
Servowinkel = 60;
} sonst wenn (Servowinkel < 0) {
Servowinkel = 0;
}
Serial.println(servo_angle); // Drucke den Servowinkel zum Debuggen
myservo.write(servo_angle); // Servoposition einstellen
}
}
servo_angle festgelegten Grenzwerte anpassen. In diesem Beispiel verwenden wir einen Mikroservo mit einem Bereich von 60 Grad. Beachten Sie, dass einige Servomotoren mechanisch nicht linear sind, sodass Sie möglicherweise auch deren winkelmechanischen Fehler kompensieren müssen.Dieses Projekt führt in die Grundlagen der Verwendung von Rotationssensoren mit CodeCell zur Steuerung eines Servos ein und eröffnet zahlreiche Möglichkeiten für bewegungsreaktive Projekte. Experimentieren Sie mit dem Code, optimieren Sie die Einstellungen und erstellen Sie Ihre eigenen dynamischen Builds!
In diesem Build untersuchen wir, wie der integrierte 9-Achsen-Bewegungssensor von CodeCell zum Erkennen von Tippen verwendet werden kann. Dieses Projekt zeigt, wie die Tipperkennung für interaktive Steuerelemente verwendet wird, sodass es sich perfekt zum Erstellen reaktionsfähiger Aktionen durch einfaches Tippen auf das Gerät eignet.
Die CodeCell ist mit einem Bewegungssensor BNO085 ausgestattet, der eine Vielzahl von Sensorfunktionen bietet, darunter auch die Tipperkennung. Diese Funktion verwendet Beschleunigungsmesserdaten, um Tippvorgänge zu erkennen, und eignet sich daher ideal für interaktive Steuerungen wie das Ein- und Ausschalten von Lichtern, das Auslösen von Soundeffekten oder andere Aktionen, die auf einer einfachen Tippbewegung basieren.
Der Bewegungssensor BNO085 erkennt Tippen, indem er plötzliche Beschleunigungen entlang seiner Achsen überwacht. Wenn ein Tippen erkannt wird, registriert der Sensor das Ereignis, sodass Sie Aktionen wie das Aufleuchten einer LED oder das Umschalten anderer Geräte auslösen können. Diese Funktion ist besonders nützlich, um berührungsbasierte Interaktionen ohne mechanische Tasten zu erstellen.
In diesem Beispiel überwacht die CodeCell kontinuierlich, ob getippt wird. Wenn ein Tippen erkannt wird, leuchtet die integrierte LED eine Sekunde lang gelb. Sie können diese grundlegende Funktionalität erweitern, um komplexere Interaktionen zu erstellen, z. B. die Steuerung mehrerer LEDs, Motoren oder anderer angeschlossener Geräte basierend auf Tippeingaben.
Unten finden Sie den Beispielcode, der Ihnen den Einstieg erleichtert. Stellen Sie sicher, dass Ihre CodeCell ordnungsgemäß über USB-C angeschlossen ist, und befolgen Sie die Kommentare im Code, um jeden Schritt zu verstehen.
#include <CodeCell.h>
CodeCell myCodeCell;
void setup() {
Serial.begin(115200); // Stellen Sie die serielle Baudrate auf 115200 ein. Stellen Sie sicher, dass Tools/USB_CDC_On_Boot aktiviert ist, wenn Sie die serielle Schnittstelle verwenden.
myCodeCell.Init(MOTION_TAP_DETECTOR); // Initialisiert die Antipperkennung
}
void schleife() {
wenn (myCodeCell.Run()) {
// Wird alle 100 ms ausgeführt, um nach Taps zu suchen
wenn (myCodeCell.Motion_TapRead()) {
// Wenn ein Tippen erkannt wird, leuchtet die LED 1 Sekunde lang gelb
myCodeCell.LED(0xA0, 0x60, 0x00); // LED auf gelb setzen
delay(1000); // Lasse die LED 1 Sekunde lang an
}
}
}
Im nächsten Beispiel verwenden wir eine CoilCell, um ihre Polarität umzukehren und einen Flip-Dot zu betätigen. Dies erweitert die Interaktivität, indem es die Tipperkennung zur Steuerung externer Geräte nutzt und so eine dynamischere Reaktion erzeugt.
#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); // Stellen Sie die serielle Baudrate auf 115200 ein. Stellen Sie sicher, dass Tools/USB_CDC_On_Boot aktiviert ist, wenn Sie die serielle Schnittstelle verwenden.
myCodeCell.Init(MOTION_TAP_DETECTOR); // Initialisiert die Tipperkennung.
myCoilCell.Init(); // Initialisiert die CoilCell.
myCoilCell.Tone(); // Spielt einen Ton ab, um die Initialisierung zu bestätigen.
}
void schleife() {
wenn (myCodeCell.Run()) {
// Wird alle 100 ms ausgeführt, um nach Taps zu suchen.
wenn (myCodeCell.Motion_TapRead()) {
// Wenn ein Tippen erkannt wird, lasse die LED gelb leuchten und kehre die Polarität der CoilCell um.
myCodeCell.LED(0xA0, 0x60, 0x00); // LED auf Gelb setzen.
myCoilCell.Toggle(100); // Die Polarität der CoilCell umschalten.
Verzögerung (1000); // Verzögerung, um die LED 1 Sekunde lang eingeschaltet zu lassen und die Polarität umzukehren.
}
}
}
Dieses Projekt führt in die Grundlagen der Verwendung der Tipperkennung mit CodeCell ein. Experimentieren Sie mit dem Code, passen Sie die Antworten an und erkunden Sie das Potenzial der Tipperkennung in Ihrem nächsten Projekt!
In diesem Build untersuchen wir, wie der integrierte Näherungssensor von CodeCell zum Erkennen von Objekten verwendet wird.
Die CodeCell ist mit einem VCNL4040-Sensor ausgestattet, der Nähe bis zu 20 cm messen kann. Dieser Sensor verwendet I2C-Kommunikation und wird automatisch über die CodeCell -Bibliothek initialisiert, was eine nahtlose Integration in Ihre Projekte ermöglicht. Egal, ob Sie eine einfache Gestentiefensteuerung hinzufügen oder nahe gelegene Objekte erkennen möchten, mit dem VCNL4040 können Sie Ihren Builds ganz einfach Näherungssensoren hinzufügen.
Der Näherungssensor VCNL4040 verwendet Infrarotlicht, um Objekte in seiner Reichweite zu erkennen. Er misst die Reflexion des emittierten IR-Lichts, um die Nähe eines Objekts zu ermitteln. So können Sie reaktionsfähiges Verhalten basierend auf der Nähe erstellen. Diese Funktion ist besonders nützlich für die Erstellung interaktiver Beleuchtung, Robotik, berührungsloser Schalter oder anderer auf Nähe basierender Aktionen.
In diesem Beispiel überwacht die CodeCell kontinuierlich Näherungsdaten und schaltet eine rote LED ein, wenn ein Objekt erkannt wird. Sie können diese grundlegende Funktionalität erweitern, um komplexere Interaktionen zu erstellen, z. B. die Änderung der LED-Farbe oder -Helligkeit je nach Entfernung oder das Auslösen unterschiedlicher Aktionen je nach Nähe.
Unten finden Sie den Beispielcode, der Ihnen den Einstieg erleichtert. Stellen Sie sicher, dass Ihre CodeCell ordnungsgemäß über USB-C angeschlossen ist, und befolgen Sie die Kommentare im Code, um jeden Schritt zu verstehen.
#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 {
// Keine Aktion, wenn das Objekt außerhalb des Bereichs liegt
}
}
}
100 ), um die Empfindlichkeit der Näherungserkennung basierend auf Ihrer Anwendung anzupassen.myCodeCell.LED() um mehrfarbige Reaktionen auf Annäherung zu erzeugen.Dieses Projekt führt in die Grundlagen der Verwendung von Näherungssensoren mit CodeCell ein und eröffnet eine Reihe interaktiver Möglichkeiten. Experimentieren Sie mit dem Code, optimieren Sie die Einstellungen und machen Sie ihn zu Ihrem eigenen!
In diesem Build erkunden wir, wie man mit der CodeCell weißes Licht erkennt und die Helligkeit von LEDs automatisch anpasst. Dieses Projekt demonstriert den integrierten Lichtsensor der CodeCell und hilft Ihnen, reaktionsschnelle Lichteffekte zu erzeugen, die sich an wechselnde Lichtverhältnisse anpassen.
Die CodeCell verfügt über einen integrierten VCNL4040-Sensor, der sowohl Lichtstärke als auch Nähe bis zu 20 cm messen kann. Dieser Sensor verwendet I2C-Kommunikation und kommuniziert mit dem ESP32 in der CodeCell -Bibliothek, wo der Sensor automatisch initialisiert wird, um seine Sensorauflösung zu optimieren. Dies macht die Einrichtung unkompliziert, sodass Sie sich auf die Erstellung Ihres Projekts konzentrieren können.
Der VCNL4040-Sensor auf der CodeCell kann sowohl Umgebungslicht als auch Weißlicht erfassen, wobei jeder Sensor unterschiedliche Zwecke erfüllt:
In diesem Projekt verwenden wir die Weißlichtsensorfunktion, um die LED-Helligkeit basierend auf den erkannten Weißlichtstärken direkt zu beeinflussen und so im Vergleich zur allgemeinen Umgebungslichtsensorik eine gezieltere Reaktion zu erzielen.
In diesem Beispiel misst die CodeCell kontinuierlich das weiße Umgebungslicht und passt die Helligkeit einer integrierten LED basierend auf der erkannten Lichtstärke an. Wenn der Raum dunkler wird, wird die LED gedimmt und sorgt so für einen sanften Übergang, den Sie für Ihre eigenen Beleuchtungsprojekte optimieren und anpassen können.
Unten finden Sie den Beispielcode, der Ihnen den Einstieg erleichtert. Stellen Sie sicher, dass Ihre CodeCell richtig verbunden ist, und befolgen Sie die Kommentare im Code, um jeden Schritt zu verstehen.
#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); // Initialisiert die Lichterkennung.
}
void schleife() {
delay(100); // Kleine Verzögerung – Sie können sie entsprechend anpassen
// Weißes Licht vom Sensor lesen und Helligkeit für 8-Bit anpassen
uint16_t Helligkeit = (myCodeCell.Light_WhiteRead()) >> 3;
Serial.println(Helligkeit); // Drucke den Helligkeitswert zum Debuggen auf den seriellen Monitor.
// Begrenzen Sie die Sensorwerte auf den Helligkeitsbereich der LED (1 bis 254)
wenn (Helligkeit == 0U) {
Helligkeit = 1U; // Stellen Sie eine Mindesthelligkeit ein, um ein vollständiges Ausschalten der LED zu vermeiden
} sonst wenn (Helligkeit > 254U) {
Helligkeit = 254U; // Begrenzen Sie die Helligkeit auf das maximale Niveau der LED
}
Helligkeit = 255U - Helligkeit; //Kehre die Helligkeit um, sodass die LED dunkler wird, wenn sie heller wird
myCodeCell.LED(0, 0, Helligkeit); // Lasse die integrierte blaue RGB-LED mit der neu eingestellten Helligkeit leuchten
}
myCodeCell.LED() können Sie RGB-Werte angeben. Experimentieren Sie mit verschiedenen Farben je nach Lichtstärke.Dieses Projekt ist nur der Ausgangspunkt für die Nutzung der Lichtsensorfunktionen von CodeCell . Tauchen Sie ein in den Code, machen Sie ihn zu Ihrem eigenen und bringen Sie Licht in Ihr nächstes Projekt!