Die MicroLink-App vereinfacht die drahtlose Steuerung Ihrer CodeCell – egal, ob Sie kleine Roboter bauen, DIY-Sensoren einrichten oder mit interaktiven Projekten experimentieren. Mit Tasten, Schiebereglern, Joystick und Echtzeit-Datenstreaming können Sie Ihre Projekte direkt von Ihrem Smartphone aus steuern, überwachen und debuggen – ganz ohne Kabel und Aufwand.
MicroLink ist eine mobile Bluetooth-App für die Interaktion mit unseren Geräten – einschließlich der CodeCell . In Verbindung mit der MicroLink Arduino-Bibliothek kann Ihre CodeCell:
Dadurch eignet sich MicroLink ideal für die Fernsteuerung, Live-Feedback und den Aufbau interaktiver Elektronik.
Installieren Sie die CodeCell MicroLink- Bibliothek aus dem Arduino Library Manager. Sie enthält sechs Beispielskizzen zu grundlegendem Sensorfeedback, Fernsteuerung und Motorinteraktion.
Hier ist ein kurzer Überblick darüber, wie Ihre CodeCell mit der App kommuniziert:
myMicroLink.Init();
Dadurch werden Schaltflächen, Schieberegler, Joystick und Bluetooth-Benachrichtigungen für Akku, Nähe, Richtung und Nachrichten eingerichtet.
myMicroLink.ShowSensors(battery, proximity, heading);
Sendet nur, wenn sich Werte ändern, wodurch der BLE-Verkehr reduziert wird.
myMicroLink.Print("Hello from CodeCell");
Verwenden Sie diese Funktion, um Debug- oder Statusmeldungen zu senden. Print() unterstützt Zeichenfolgen mit bis zu 20 Zeichen. Kombinieren Sie Text und Variablen wie folgt:
sprintf(message, "%u RPM", MotorRPM);
myMicroLink.Print(message);
Verwenden Sie diese Funktionen, um Eingaben aus der App zu lesen:
myMicroLink.ReadButtonA(); // true if pressed
myMicroLink.ReadButtonB();
myMicroLink.ReadButtonC();
myMicroLink.ReadButtonD();
myMicroLink.ReadSlider1(); // 0–100
myMicroLink.ReadSlider2();
myMicroLink.ReadSlider3();
myMicroLink.ReadJoystickX(); // Joystick X-Achse
myMicroLink.ReadJoystickY(); // Joystick Y-Achse
Sobald eines davon in Ihrem Code verwendet wird, wird es automatisch in der MicroLink-App angezeigt.
In diesem Beispiel steuern zwei DriveCell -Module Motoren. Zwei Schieberegler in der App regeln die Motordrehzahl. Ein Knopf dient zum Umschalten der Polarität:
uint8_t slider1 = myMicroLink.ReadSlider1();
uint8_t slider2 = myMicroLink.ReadSlider2();
DriveCell1.Drive(polarity, slider1);
DriveCell2.Drive(polarity, slider2);
Polarität per Knopfdruck umkehren:
if (myMicroLink.ReadButtonA()) {
polarity = !polarity;
myMicroLink.Print("Reversing Polarity");
}
Öffnen Sie nach der Installation die Arduino IDE und gehen Sie zu:
Datei → Beispiele → CodeCell MicroLink
Sie finden sechs Beispielskizzen, die Sie erkunden und anpassen können – keine erweiterte Einrichtung erforderlich. Beginnen Sie mit den Beispielen, erkunden Sie die Bedienelemente und erstellen Sie etwas Lustiges!
Die MicroLink Connect App ist sowohl im Google Play Store als auch für Apple iOS erhältlich. Sie ist völlig kostenlos und verfügt über eine übersichtliche, werbefreie Oberfläche.
Wenn Sie weitere Hilfe benötigen, können Sie sich jederzeit an uns wenden – viel Spaß beim Bauen!
CodeCell ist einfach einzurichten und zu verwenden, aber wie bei jedem Mikrocontroller können Probleme auftreten. Diese Anleitung hilft Ihnen bei der effektiven Fehlerbehebung und Fehlerbehebung bei CodeCell.
Stellen Sie vor der Fehlerbehebung sicher, dass Sie die neuesten Versionen von:
So aktualisieren Sie:
Um die Programmierung zu vereinfachen, bietet die CodeCell-Bibliothek verschiedene Funktionen zum Initialisieren, Lesen und Verwalten von Sensoren und Stromversorgung. Hier finden Sie alles, was Sie zur Einrichtung Ihres Geräts und seiner Bibliothek wissen müssen.
In der Box finden Sie:
Schließen Sie ein USB-C-Kabel an, und CodeCell führt Folgendes aus:
Laden Sie die neueste Version von der offiziellen Arduino-Website herunter.
https://dl.espressif.com/dl/package_esp32_index.json
Der erste Schritt besteht darin, die CodeCell mit folgendem Befehl zu initialisieren:
myCodeCell.Init(SENSOR_MACRO);
Verfügbare Makros:
Sie können mehrere Makros mit dem Operator + kombinieren:
myCodeCell.Init(LIGHT + MOTION_ACCELEROMETER + MOTION_GYRO);
myCodeCell.Init(SENSOR_MACRO);
Wir hoffen, dies hat Ihnen geholfen, die Ursache zu identifizieren. Sollte das Problem weiterhin bestehen, zögern Sie nicht, uns zu kontaktieren – wir helfen Ihnen gerne weiter!
Bluetooth Low Energy (BLE) ist eine leistungsstarke Möglichkeit zur drahtlosen Kommunikation zwischen Ihrer CodeCell und anderen Geräten wie Smartphones, Tablets und sogar anderen Mikrocontrollern. In dieser Anleitung richten wir BLE auf CodeCell ein, ermöglichen den Empfang von Befehlen von einem BLE-Client und steuern die RGB-LED basierend auf den empfangenen Daten.
BLE ist eine energieeffiziente Version von Bluetooth, die es Geräten ermöglicht, kleine Datenmengen bei geringem Stromverbrauch auszutauschen. Hier sind die wichtigsten Konzepte:
Bevor wir mit dem Testen beginnen, müssen Sie eine App herunterladen, um BLE-Daten auf Ihr Smartphone zu senden. Beginnen Sie mit dem Herunterladen eine BLE-Scanner-App:
Damit CodeCell sich selbst als BLE-Gerät ankündigt , müssen wir BLE initialisieren, einen Dienst und eine Eigenschaft erstellen und mit der Werbung beginnen .
Dieser Code erstellt einen BLE-Server , kündigt einen Dienst an und richtet eine Eigenschaft ein , die von einem angeschlossenen Gerät gelesen und geschrieben werden kann. Die CodeCell empfängt die Tasteneigenschaft und steuert ihre integrierte RGB-LED:
#include <BLEDevice.h> #include <BLEUtils.h> #include <BLEServer.h> #include <BLE2902.h> #include <CodeCell.h> CodeCell myCodeCell; BLECharacteristic *pButtonCharacteristic = NULL; #define BUTTON_UUID "abcd1234-abcd-1234-abcd-123456789012" class MyServerCallbacks : public BLEServerCallbacks { void onConnect(BLEServer *pServer) override { Serial.println("BLE Connected"); delay(1000); } void onDisconnect(BLEServer *pServer) override { Serial.println("BLE Disconnected"); delay(500); BLEDevice::startAdvertising(); // Restart advertising } }; // Callback class for handling button writes class ButtonCallback : public BLECharacteristicCallbacks { void onWrite(BLECharacteristic *pCharacteristic) override { String value = pCharacteristic->getValue(); if (value.length() > 0) { int buttonState = value[0]; Serial.print("Button State: ");Serial.println(buttonState); wenn (ButtonState == 1) { myCodeCell.LED(255, 0, 0); // Rote LED, wenn die Taste 1 ist } anders { myCodeCell.LED(0, 255, 0); // Grüne LED, wenn die Schaltfläche nicht 1 ist } } } }; void setup() { Serial.begin(115200); myCodeCell.Init(LIGHT); // Initialisiert den Lichtsensor BLEDevice::init("CodeCell_BLE"); // BLE-Gerätenamen festlegen BLEServer *bleServer = BLEDevice::createServer(); bleServer->setCallbacks(neu MyServerCallbacks()); BLEService *bleService = bleServer->createService(BLEUUID("12345678-1234-5678-1234-56789abcdef0")); // BLE-Merkmal für den Schaltflächenzustand erstellen pButtonCharacteristic = bleService->createCharacteristic( BUTTON_UUID, BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_WRITE ); pButtonCharacteristic->addDescriptor(neues BLE2902()); pButtonCharacteristic->setCallbacks(neuer ButtonCallback()); bleService->start(); BLEAdvertising *pAdvertising = BLEDevice::getAdvertising(); pAdvertising->addServiceUUID("12345678-1234-5678-1234-56789abcdef0"); BLEDevice::startAdvertising(); } void-Schleife() { // Keine ständige Überprüfung erforderlich, LED-Updates nur beim BLE-Schreiben }
"CodeCell_BLE" ."CodeCell_BLE" her.
BUTTON_UUID ) und senden Sie den Wert:
1 → LED leuchtet rot 🔴0 → LED leuchtet grün 🟢Als Nächstes definieren wir eine neue BLE-Eigenschaft , die es CodeCell ermöglicht, Sensorwerte an ein verbundenes Gerät zu senden .
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
#include <BLE2902.h>
#include <CodeCell.h>
CodeCell myCodeCell;
BLECharacteristic *pSensorCharacteristic = NULL;
#define SENSOR_UUID "abcd5678-abcd-5678-abcd-56789abcdef0"
class MyServerCallbacks : public BLEServerCallbacks {
void onConnect(BLEServer *pServer) override {
Serial.println("BLE Connected");
delay(1000);
}
void onDisconnect(BLEServer *pServer) override {
Serial.println("BLE getrennt");
Verzögerung (500);
BLEDevice::startAdvertising(); // Werbung neu starten
}
};
void setup() {
Serial.begin(115200);
myCodeCell.Init(LIGHT); // Licht- und Näherungssensor initialisieren
BLEDevice::init("CodeCell_BLE"); // Benennen Sie das BLE-Gerät
BLEServer *bleServer = BLEDevice::createServer();
bleServer->setCallbacks(neu MyServerCallbacks());
BLEService *bleService = bleServer->createService(BLEUUID("12345678-1234-5678-1234-56789abcdef0"));
// BLE-Kennlinie für Sensordaten erstellen
pSensorCharacteristic = bleService->createCharacteristic(
SENSOR_UUID,
BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY
);
pSensorCharacteristic->addDescriptor(neues BLE2902());
bleService->start();
BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
pAdvertising->addServiceUUID("12345678-1234-5678-1234-56789abcdef0");
BLEDevice::startAdvertising();
}
void-Schleife() {
if (myCodeCell.Run(10)) { // Alle 100 ms (10 Hz) lesen
uint16_t Nähe = myCodeCell.Light_ProximityRead();
Serial.print("Nähe: ");
Serial.println(Nähe);
// Näherungswert in Zeichenfolge umwandeln und über BLE senden
String proximityStr = String(Nähe);
pSensorCharacteristic->setValue(proximityStr.c_str());
pSensorCharacteristic->notify(); // Verbundenes Gerät benachrichtigen
}
}
SENSOR_UUID ) ein , die Clients lesen und von der sie Echtzeit-Updates erhalten können:
Da CodeCell jetzt Näherungssensordaten über BLE sendet , können Sie diese auf einem Telefon anzeigen .
"CodeCell_BLE" suchen und verbindenSENSOR_UUID )
Bewegen Sie ein Objekt in die Nähe des Sensors und sehen Sie, wie sich die Werte ändern!
Nachdem Sie CodeCell nun über BLE steuern können, versuchen Sie:
Das CodeCell-Modul, das vom ESP32-C3 angetrieben wird, verfügt über integrierte WLAN-Funktionen, die es ermöglichen, sich mit dem Internet zu verbinden, mit anderen Geräten zu kommunizieren und sogar einen kleinen Webserver zu hosten. Egal, ob Sie Anfänger oder erfahrener Maker sind, diese Anleitung hilft Ihnen beim Einstieg in die WLAN-Nutzung auf CodeCell.
Über WLAN kann Ihre CodeCell drahtlos mit dem Internet oder einem lokalen Netzwerk verbunden werden. Das bedeutet:
Gehen wir nun Schritt für Schritt vor, um CodeCell mit dem WLAN zu verbinden.
Um Ihre CodeCell mit einem WLAN-Netzwerk zu verbinden, müssen Sie den Netzwerknamen ( SSID ) und das Passwort angeben. Schreiben wir mithilfe der Arduino IDE ein einfaches Programm, das CodeCell mit WLAN verbindet.
#include <WiFi.h>
#include <CodeCell.h>
CodeCell myCodeCell;
const char* ssid = "your_SSID"; // Replace with your Wi-Fi name
const char* password = "your_PASSWORD"; // Replace with your Wi-Fi password
void setup() {
Serial.begin(115200); // Start the Serial Monitor
myCodeCell.Init(LIGHT); // Set up CodeCell's light sensor
WiFi.begin(ssid, password); // Connect to Wi-Fi
Serial.print("Connecting to Wi-Fi");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print("."); // Print dots while connecting
}
Serial.println("\nConnected!");
Serial.print("IP Address: ");
Serial.println(WiFi.localIP()); // Drucke die zugewiesene IP-Adresse
}
void-Schleife() {
// Alle 10 Hz ausführen
wenn (myCodeCell.Run(10)) {
// Ihr Hauptschleifencode hier
}
}
WiFi.begin(ssid, password); ;.Sobald CodeCell mit dem WLAN verbunden ist, können wir es als kleinen Webserver nutzen! Das bedeutet, wir können es steuern oder Informationen über eine Webseite anzeigen.
#include <WiFi.h> #include <WebServer.h> #include <CodeCell.h> CodeCell myCodeCell; const char* ssid = "your_SSID"; const char* password = "your_PASSWORD"; WebServer server(80);void handleRoot() { int proximityValue = myCodeCell.Light_ProximityRead(); // Näherungssensor lesen String-Antwort = "Willkommen beim CodeCell Wi-Fi-Server!
"; Antwort += "Näherungswert: " + String(näherungswert) + "
"; server.send(200, "text/html", Antwort); } void setup() { Serial.begin(115200); myCodeCell.Init(LIGHT); // CodeCells Lichtsensor einrichten WiFi.begin(ssid, Passwort); während (WiFi.status() != WL_CONNECTED) { Verzögerung (500); Serial.print("."); } Serial.println("\nMit WLAN verbunden"); Serial.print("IP-Adresse: "); Serial.println(WiFi.localIP()); server.on("/", handleRoot); server.begin(); Serial.println("HTTP-Server gestartet"); } void-Schleife() { if(myCodeCell.Run(10)){ server.handleClient(); } }
CodeCell kann Daten auch an einen Webserver senden, beispielsweise einen Cloud-Dienst, der Sensorwerte sammelt.
#include <WiFi.h>
#include <HTTPClient.h>
#include <CodeCell.h>
CodeCell myCodeCell;
const char* ssid = "your_SSID";
const char* password = "your_PASSWORD";
const char* serverName = "http://example.com/data"; // Replace with your server URL
void setup() {
Serial.begin(115200);
myCodeCell.Init(LIGHT); // Set up CodeCell's light sensor
WiFi.begin(ssid, Passwort);
während (WiFi.status() != WL_CONNECTED) {
Verzögerung (500);
Serial.print(".");
}
Serial.println("Mit WLAN verbunden");
}
void-Schleife() {
if (myCodeCell.Run(10)) { // Alle 10 Hz ausführen
HTTPClient http;
http.begin(Servername);
int httpResponseCode = http.GET();
Serial.print("HTTP-Antwortcode: ");
Serial.println(httpResponseCode);
http.end();
}
}
http://example.com/data .Dank WLAN ist CodeCell besonders leistungsstark für IoT-Projekte! Beginnen Sie mit dem Experimentieren und schon bald werden Sie beeindruckende Projekte erstellen!
Haben Sie sich schon einmal gefragt, woher Ihr Telefon weiß, in welche Richtung Sie blicken? Dank eines Magnetometers! Ihre CodeCell ist mit einem 3-Achsen-Magnetometer BNO085 ausgestattet, das Magnetfelder in drei Richtungen erkennt. So können Sie die Richtung messen, magnetische Störungen erkennen und sogar einen einfachen digitalen Kompass erstellen!
Ein Magnetometer misst das Magnetfeld der Erde entlang dreier Achsen:
Mithilfe dieser Werte können wir die Kompassrichtung (0° bis 360°) berechnen und bestimmen, in welche Richtung CodeCell zeigt.
Beginnen wir mit der Initialisierung des Magnetometers und dem Ablesen der Rohwerte des Magnetfelds.
#include <CodeCell.h>
CodeCell myCodeCell;
float x = 0.0; // Magnetic field on X-axis
float y = 0.0; // Magnetic field on Y-axis
float z = 0.0; // Magnetic field on Z-axis
void setup() {
Serial.begin(115200);
myCodeCell.Init(MOTION_MAGNETOMETER); // Initialize the magnetometer
}
void loop() {
if (myCodeCell.Run(10)) { // Read at 10Hz (every 100ms)
myCodeCell.Motion_MagnetometerRead(x, y, z); // Get magnetometer readings
Serial.print("Mag X: "); Serial.print(x);
Serial.print(" Y: "); Serial.print(y);
Serial.print(" Z: "); Serial.println(z);
}
}
Sobald Sie den Code hochgeladen und den seriellen Monitor geöffnet haben, werden Werte wie die folgenden angezeigt:
Mag X: 12.4 Y: -7.8 Z: 35.2
Was bedeuten diese Werte?
Um einen digitalen Kompass zu bauen, müssen wir X- und Y-Werte mit der Funktion atan2() in einen Winkel umwandeln.
#include <CodeCell.h>
#include <math.h> // Needed for atan2 function
CodeCell myCodeCell;
float x = 0.0, y = 0.0, z = 0.0;
void setup() {
Serial.begin(115200);
myCodeCell.Init(MOTION_MAGNETOMETER); // Initialize the magnetometer
}
void loop() {
if (myCodeCell.Run(10)) { // Read at 10Hz
myCodeCell.Motion_MagnetometerRead(x, y, z); // Read magnetometer values
// Kurs berechnen (Winkel in Grad)
Float-Überschrift = atan2(y, x) * (180,0 / M_PI);
// Stellen Sie sicher, dass der Kurs im Bereich von 0° bis 360° liegt
wenn (Überschrift < 0) {
Überschrift += 360;
}
Serial.print("Kompassrichtung: ");
Serial.println(heading); // Überschrift in Grad drucken
}
}
Der Kurswert (0° bis 360°) gibt an, in welche Richtung CodeCell zeigt:
| Kurs (°) | Richtung |
|---|---|
| 0° (oder 360°) | Norden ↑ |
| 90° | Osten → |
| 180° | Süden ↓ |
| 270° | Westen ← |
Versuchen Sie, CodeCell zu drehen und beobachten Sie, wie sich die Überschrift ändert!
Wir können die LED jetzt je nach Richtung in verschiedenen Farben leuchten lassen:
#include <CodeCell.h>
#include <math.h>
CodeCell myCodeCell;
float x = 0.0, y = 0.0, z = 0.0;
void setup() {
Serial.begin(115200);
myCodeCell.Init(MOTION_MAGNETOMETER); // Initialize the magnetometer
}
void loop() {
if (myCodeCell.Run(10)) { // Read at 10Hz
myCodeCell.Motion_MagnetometerRead(x, y, z); // Read magnetometer values
// Calculate heading
float heading = atan2(y, x) * (180.0 / M_PI);
if (heading < 0) heading += 360;
Serial.print("Heading: ");
Serial.println(heading);
// Change LED color based on heading
if (heading >= 315 || heading < 45) {
myCodeCell.LED(0, 0, 255); // Blue for North
} else if (heading >= 45 && heading < 135) {
myCodeCell.LED(0, 255, 0); // Green for East
} else if (heading >= 135 && heading < 225) {
myCodeCell.LED(255, 0, 0); // Red for South
} anders {
myCodeCell.LED(255, 255, 0); // Gelb für Westen
}
}
}
Nachdem Sie nun Magnetometerdaten lesen und die Richtung berechnen können, versuchen Sie Folgendes:
Die CodeCell verfügt über ein integriertes 3-Achsen-Gyroskop BNO085, das die Winkelgeschwindigkeit messen kann – also wie schnell sich die CodeCell um jede Achse dreht – und so die Erkennung von Richtungsänderungen erleichtert.
Im Gegensatz zu einem Beschleunigungsmesser, der Bewegungen entlang einer geraden Linie misst, erkennt ein Gyroskop Rotationsbewegungen . Es zeigt Ihnen in Grad pro Sekunde (°/s) an, wie schnell sich CodeCell dreht.
Bevor wir das Gyroskop verwenden können, müssen wir es initialisieren und mit dem Lesen der Daten beginnen.
Dieser Code liest die Winkelgeschwindigkeitswerte X, Y und Z und druckt sie alle 100 ms.
#include <CodeCell.h>
CodeCell myCodeCell;
float x = 0.0; // Angular velocity around X-axis
float y = 0.0; // Angular velocity around Y-axis
float z = 0.0; // Angular velocity around Z-axis
void setup() {
Serial.begin(115200);
myCodeCell.Init(MOTION_GYRO); // Initialize the gyroscope
}
void loop() {
if (myCodeCell.Run(10)) { // Read at 10Hz (every 100ms)
myCodeCell.Motion_GyroRead(x, y, z); // Get gyro readings
Serial.print("Gyro X: "); Serial.print(x);
Serial.print(" Y: "); Serial.print(y);
Serial.print(" Z: "); Serial.println(z);
}
}
Was Sie bemerken werden:
Je höher der Wert, desto schneller die Rotation.
Lassen Sie uns nun erkennen, wann sich CodeCell nach links oder rechts dreht, und die RGB-LED-Farbe entsprechend ändern.
Dieses Programm:
#include <CodeCell.h>
CodeCell myCodeCell;
float x = 0.0, y = 0.0, z = 0.0;
const float ROTATION_THRESHOLD = 3.0; // Rotation speed threshold (°/s)
void setup() {
Serial.begin(115200);
myCodeCell.Init(MOTION_GYRO); // Initialize gyroscope
}
void loop() {
if (myCodeCell.Run(10)) { // Read at 10Hz
myCodeCell.Motion_GyroRead(x, y, z); // Get gyroscope values
Serial.print("Gyro Z: ");
Serial.println(z); // Print rotation speed
if (z > ROTATION_THRESHOLD) {
myCodeCell.LED(0, 255, 0); // LED grün schalten (nach rechts drehen)
}
sonst wenn (z < -ROTATION_THRESHOLD) {
myCodeCell.LED(255, 0, 0); // LED rot werden lassen (nach links drehen)
}
anders {
myCodeCell.LED(0, 0, 0); // LED ausschalten, wenn sie nicht rotiert
}
}
}
Das Gyroskop misst die Winkelgeschwindigkeit in Grad pro Sekunde (°/s). Überschreitet der Wert der Z-Rotation (Gierwinkel) den Schwellenwert, wird davon ausgegangen, dass CodeCell gedreht wird.
Versuchen Sie , ROTATION_THRESHOLD zu ändern, um die Empfindlichkeit zu erhöhen oder zu verringern .
Nachdem Sie nun die Rotation verfolgen können, versuchen Sie Folgendes:
In Ihrer CodeCell befindet sich ein BNO085 3-Achsen-Beschleunigungssensor, ein winziger Sensor, der Bewegungen misst. Mit nur wenigen Codezeilen können Sie Erschütterungen erkennen und bei Bewegung sogar eine LED-Leuchte auslösen! Lassen Sie uns Schritt für Schritt vorgehen.
Ein Beschleunigungsmesser misst die Beschleunigung – wie schnell etwas beschleunigt oder verlangsamt wird. Er erkennt:
Es spürt sogar die Schwerkraft! Wenn CodeCell stillsteht, zeigt die Z-Achse einen Wert nahe 9,81 m/s² an, was der Schwerkraft der Erde entspricht.
Beginnen wir zunächst mit dem Lesen der Echtzeit-Bewegungswerte vom integrierten Beschleunigungsmesser von CodeCell. Dieser Code zeigt, wie stark sich CodeCell in jede Richtung bewegt:
#include <CodeCell.h>
CodeCell myCodeCell;
float x = 0.0; // Beschleunigung der X-Achse
float y = 0.0; // Beschleunigung der Y-Achse
float z = 0.0; // Beschleunigung der Z-Achse
void setup() {
Serial.begin(115200);
myCodeCell.Init(MOTION_ACCELEROMETER); // Initialisiere den Beschleunigungsmesser
}
void-Schleife() {
if (myCodeCell.Run(10)) { // 10-mal pro Sekunde ausführen (10 Hz)
myCodeCell.Motion_AccelerometerRead(x, y, z); // Bewegungswerte lesen
Serial.print("X: "); Serial.print(x);
Serial.print(" Y: "); Serial.print(y);
Serial.print(" Z: "); Serial.println(z);
}
}
Lassen Sie uns nun erkennen, wann CodeCell geschüttelt wird, und die integrierte RGB-LED verwenden, um dies zu signalisieren.
Dieses Programm lässt die LED rot leuchten, wenn eine Erschütterung erkannt wird.
#include <CodeCell.h>
#include <math.h> // Needed for square root calculations
CodeCell myCodeCell;
float x = 0.0, y = 0.0, z = 0.0;
const float SHAKE_THRESHOLD = 15.0; // Adjust this value for sensitivity
void setup() {
Serial.begin(115200);
myCodeCell.Init(MOTION_ACCELEROMETER); // Initialize accelerometer
}
void loop() {
if (myCodeCell.Run(10)) { // Check every 100ms (10Hz)
myCodeCell.Motion_AccelerometerRead(x, y, z); // Read accelerometer data
// Calculate total movement strength (vector magnitude)
float totalAcceleration = sqrt(x * x + y * y + z * z);
Serial.print("Total Acceleration: ");
Serial.println(totalAcceleration); // Show acceleration strength
// If the acceleration is stronger than the threshold, it's a shake!
if (totalAcceleration > SHAKE_THRESHOLD) {
Serial.println("Shake detected!");
myCodeCell.LED(255, 0, 0); // Turn LED red
delay(500); // LED 0,5 Sekunden lang eingeschaltet lassen
} anders {
//Nicht zittern
}
}
}
Anstatt X, Y und Z separat zu prüfen, kombinieren wir sie zu einem einzigen Wert:
Dies gibt an , wie stark sich CodeCell insgesamt bewegt , unabhängig von der Richtung. Wenn totalAcceleration über 15,0 steigt , gehen wir davon aus, dass CodeCell geschüttelt wird. Die integrierte Die RGB-LED leuchtet 0,5 Sekunden lang rot , um das Schütteln anzuzeigen.
Jetzt, da Sie Bewegungen erkennen können, gibt es hier einige lustige Herausforderungen:
Indem Sie die Bewegungserkennung verstehen, lernen Sie dieselbe Technologie kennen, die in Smartphones, Drohnen und Raketen verwendet wird ! 🚀
Die integrierte RGB-LED auf CodeCell kann auch programmgesteuert gesteuert werden, um je nach den Anforderungen Ihres Projekts unterschiedliche Farben anzuzeigen.
Mit der integrierten Funktion von CodeCell können Sie die LED-Farbe einfach einstellen:
myCodeCell.LED(uint8_t r, uint8_t g, uint8_t b);
r → Rotanteil (0-255)g → Grünanteil (0-255)b → Blauanteil (0-255)Dies ermöglicht eine vollständige RGB-Farbsteuerung für die Anforderungen Ihres Projekts.
Neben der Farbsteuerung können Sie auch die Helligkeit der Onboard-LED mit der folgenden Funktion anpassen:
myCodeCell.LED_SetBrightness(uint16_t level);
level → Helligkeitsstufe von 0 (aus) bis 10 (maximale Helligkeit)Standardmäßig ist die Helligkeitsstufe auf 7 eingestellt.
Um die LED beispielsweise während des normalen Betriebs vollständig auszuschalten, verwenden Sie:
myCodeCell.LED_SetBrightness(0); // Turn off CodeCell LED
Hinweis: Auch wenn die Helligkeit auf 0 eingestellt ist, blinkt die LED bei niedrigem Batteriestand immer noch rot, sodass Sie keine wichtigen Warnungen zum Ladezustand verpassen.
In diesem Beispiel leuchtet die integrierte RGB-LED rot, wenn mithilfe der Näherungserkennung des Lichtsensors ein Objekt innerhalb einer bestimmten Reichweite erkannt wird.
#include <CodeCell.h>
CodeCell myCodeCell;
void setup() {
Serial.begin(115200); // Set Serial baud rate to 115200. Ensure Tools/USB_CDC_On_Boot is enabled if using Serial
myCodeCell.Init(LIGHT); // Initializes light sensing, including proximity
}
void loop() {
if (myCodeCell.Run(10)) {
// Runs every 100ms to check proximity
uint16_t proximity = myCodeCell.Light_ProximityRead();
// Check if an object is within range
wenn (Nähe > 100) {
myCodeCell.LED(0xFF, 0, 0); // LED auf Rot setzen, wenn Nähe erkannt wird
delay(1000); // LED 1 Sekunde lang anlassen
} anders {
// Keine Aktion, wenn das Objekt außerhalb des Bereichs liegt
}
}
}
Denken Sie daran, dass die integrierte RGB-LED auch zur Anzeige des Batterie- und Stromstatus verwendet wird . Bei Verwendung von myCodeCell.Run() kann die LED überschrieben werden, um den Lade- oder Batteriezustand anzuzeigen.
Wenn Sie die LED ohne Unterbrechungen steuern möchten, müssen Sie möglicherweise anpassen, wie oft myCodeCell.Run() aufgerufen wird, oder sicherstellen, dass Ihre LED-Befehle nach Systemaktualisierungen angewendet werden.
Darüber hinaus können Sie durch Anpassen der Helligkeitsstufe die Sichtbarkeit der LED in unterschiedlichen Umgebungen steuern oder sie während des Betriebs vollständig ausschalten, während kritische Warnungen bei niedrigem Batteriestand weiterhin angezeigt werden.
I2C ist ein weit verbreitetes Protokoll für die Kommunikation mit Sensoren, Displays und anderen Peripheriegeräten. CodeCell vereinfacht die I2C-Kommunikation, indem es den I2C-Bus bei der Initialisierung automatisch konfiguriert, sodass Sie ihn sofort nutzen können.
Die SDA- und SCL-Pins des I2C befinden sich auf der Unterseite der CodeCell-Platine.
CodeCell konfiguriert I2C automatisch in der Init() Funktion und diese Konfiguration kann nicht geändert werden, wenn Sie die integrierten Licht- und Bewegungssensoren verwenden möchten, da diese an denselben I2C-Bus angeschlossen sind.
Die folgenden Onboard-Sensoren verwenden bereits I2C. Achten Sie daher darauf, beim Anschließen anderer I2C-Geräte wie Displays, zusätzlicher Sensoren oder Module nicht dieselben Adressen zu verwenden :
| Sensor | Adresse |
|---|---|
| VCNL4040 (Lichtsensor) | 0x60 |
| BNO085 (IMU – Bewegungssensor) | Version: 0x4A |
Hinweis: Wenn ein neues I2C-Gerät dieselbe Adresse wie einer dieser Onboard-Sensoren hat, kommt es zu Konflikten und Sie erhalten möglicherweise falsche oder gar keine Daten.
Um eine stabile I²C-Kommunikation zu gewährleisten, verfügt CodeCell bereits über 2-kΩ-Pull-up-Widerstände, die an die SDA- und SCL-Leitungen angeschlossen sind. Das bedeutet, dass Sie bei Verwendung externer I²C-Sensoren keine externen Pull-ups hinzufügen müssen .
Verwenden Sie zur Kommunikation mit einem externen I2C-Gerät die Standardbibliothek „Wire.h“.
Im Gegensatz zu Standard-Arduino-I2C-Geräten verfügt CodeCell über mehrere integrierte Sensoren auf demselben I2C-Bus. Der Aufruf Wire.endTransmission(false); stellt sicher, dass der Bus aktiv bleibt und die integrierten Sensoren ordnungsgemäß funktionieren.
Wire.beginTransmission(SLAVE_ADDRESS); // Start communication with the device
Wire.write(SLAVE_REG); // Send the register we want to read
Wire.endTransmission(false); // Don't release the bus (needed for onboard sensors)
Wire.requestFrom(SLAVE_ADDRESS, 1); // Request 1 byte from the slave
if (Wire.available()) {
uint8_t data = Wire.read(); // Read received byte
Serial.println(data);
}
CodeCell konfiguriert den I2C-Bus automatisch, sodass keine manuelle Einrichtung erforderlich ist. Außerdem konfiguriert es automatisch die integrierten Sensoren und unterstützt zusätzliche I2C-Geräte!
Analoge Sensoren, Potentiometer und andere variable Eingänge benötigen einen Analog-Digital-Wandler (ADC), um von einem Mikrocontroller gelesen werden zu können. Mit CodeCell ist das Lesen eines analogen Signals so einfach wie der Aufruf von pinADC() .
pinADC()
Um einen analogen Wert zu lesen, verwenden Sie:
uint16_t myADC = myCodeCell.pinADC(uint8_t pin_num);
pin_num → Der ADC-Pin, von dem Sie lesen möchten ( IO1, IO2 oder IO3 ).Wenn Sie ein Potentiometer an IO2 anschließen, können Sie seine Position wie folgt ablesen:
uint16_t potValue = myCodeCell.pinADC(2);
Serial.println(potValue);
Da die maximale Spannung an den ADC-Pins von CodeCell 3,3 V nicht überschreiten sollte, sollten Sie das Potentiometer an 3V3 statt an Vo anschließen :
3V3 → One end of the potentiometer
GND → Other end of the potentiometer
IO2 → Middle pin of the potentiometer
Der integrierte Mikrocontroller verwendet eine interne Spannungsreferenz von 2,5 V. Das bedeutet:
So skalieren Sie Messwerte richtig:
float voltage = (myCodeCell.pinADC(2) / 4095.0) * 2.5;
Serial.println(voltage);
pinADC() auf
Egal, ob Sie ein Potentiometer, einen Sensor oder andere analoge Signale lesen, CodeCell macht das ADC-Lesen einfach.
Pulsweitenmodulation (PWM) ist unerlässlich für die Steuerung der LED-Helligkeit, der Motordrehzahl und sogar der Erzeugung von Audiosignalen. Mit CodeCell ist die Einrichtung von PWM dank der Funktion pinPWM() kinderleicht. Im Gegensatz zu herkömmlicher Arduino-PWM, die vordefinierte Pins und zusätzliche Einstellungen erfordert, ermöglicht CodeCell die mühelose Aktivierung von PWM auf jedem der sechs verfügbaren Pins.
pinPWM()
Um ein PWM-Signal zu erzeugen, verwenden Sie:
myCodeCell.pinPWM(uint8_t pin_num, uint16_t pin_freq, uint8_t pin_dutycycle);
pin_num → Der Pin, den Sie verwenden möchten (einer der 6 verfügbaren GPIOs von CodeCell).pin_freq → Die Frequenz des PWM-Signals (in Hz).pin_dutycycle → Der Arbeitszyklus (0–100), der den Prozentsatz der Zeit darstellt, in der das Signal HIGH bleibt.Angenommen, Sie möchten eine an Pin 3 angeschlossene LED mit einer Frequenz von 1 kHz (1000 Hz) und 50 % Helligkeit dimmen:
myCodeCell.pinPWM(3, 1000, 50);
So machen Sie die LED heller (z. B. 80 % Helligkeit):
myCodeCell.pinPWM(3, 1000, 80);
Oder zum Ausschalten (0 % Helligkeit):
myCodeCell.pinPWM(3, 1000, 0);
pinPWM() auf und schon kann es losgehen.Diese Funktion macht die PWM-Steuerung auf CodeCell flexibler und einfacher denn je. Probieren Sie sie in Ihrem nächsten Projekt aus!
Das CodeCell-Modul macht die Arbeit mit GPIO-Pins (Ein-/Ausgabe) so einfach wie nie zuvor. Während Sie weiterhin die traditionellen Arduino-Funktionen digitalWrite() und digitalRead() verwenden können, nutzt die CodeCell-Bibliothek die Funktionen pinWrite() und pinRead() , die die Pin-Initialisierung automatisch für Sie übernehmen.
Mit den optimierten Funktionen von CodeCell müssen Sie den Pin-Modus nicht manuell mit pinMode() einstellen. Rufen Sie einfach auf:
myCodeCell.pinWrite(uint8_t pin_num, bool pin_value);
So schalten Sie beispielsweise eine an Pin 5 angeschlossene LED ein:
myCodeCell.pinWrite(5, HIGH);
Oder schalten Sie es aus:
myCodeCell.pinWrite(5, LOW);
Das Auslesen eines Pin-Status ist genauso einfach:
if (myCodeCell.pinRead(5)) {
// Pin is HIGH, do something
}
Die Funktion pinRead() gibt einen Booleschen Wert zurück ( true für HIGH, false für LOW), wodurch GPIO-Interaktionen mühelos erfolgen.
pinMode() ist nicht erforderlich – es wird automatisch gehandhabt, wodurch Ihre Skizzen übersichtlicher werden.
Integrierte Fehlererkennung – wenn ein Pin auf Ihrem CodeCell-Modul nicht verfügbar ist, wird auf dem seriellen Monitor ein Fehler ausgegeben, der Ihnen bei der Fehlerbehebung hilft.
Diese Funktionen machen die GPIO-Verwaltung von CodeCell intuitiver – egal, ob Sie LEDs, Tasten und mehr steuern!