Energieeffizienz ist für viele eingebettete Anwendungen entscheidend, insbesondere für solche, die Batteriestrom benötigen. In dieser Anleitung erfahren Sie, wie Sie CodeCell in den Energiesparmodus versetzen und mithilfe eines Näherungssensors aktivieren.
Für Anwendungen, die eine vollständige Stromabschaltung erfordern, können Sie einen Schalter in Reihe mit der Batterie schalten. So können Sie das Gerät manuell ein- und ausschalten. Alternativ können Sie CodeCell in den Ruhemodus versetzen und bei Sensoraktivität aktivieren.
CodeCell hat einen durchschnittlichen Ruhestrom von 689 μA. Obwohl dieser Wert höher sein kann als für manche Ultra-Low-Power-Anwendungen erforderlich, arbeiten wir aktiv daran, den Stromverbrauch in der nächsten Version zu optimieren und gleichzeitig die Größe beizubehalten.
Aufgrund der geringen Größe und der begrenzten Anzahl an Pins des ESP32C3 konnten wir keinen dedizierten Interrupt-Pin für die Sensoren zum Aufwecken des Geräts integrieren. Ein echter Hardware-Interrupt wäre zwar ideal, Sie können CodeCell jedoch auch in den Ruhemodus versetzen, indem Sie vor dem Aufwecken regelmäßig die Sensoraktivität prüfen.
Der folgende Code veranschaulicht, wie CodeCell in den Ruhemodus wechselt und aufwacht, wenn eine Nähe erkannt wird.
#include <CodeCell.h>
CodeCell myCodeCell;
void setup() {
Serial.begin(115200);
delay(60); // Waking up from Sleep - add a small delay for Serial
if (myCodeCell.WakeUpCheck()) {
// Initialize light sensor
while (myCodeCell.Light_Init() == 1) {
delay(1);
myCodeCell.LightReset(); // If sensor not responding, reset it
}
delay(40);
myCodeCell.Light_Read(); // Read value from light sensor
if (myCodeCell.Light_ProximityRead() < 10) {
myCodeCell.Sleep(1); // Wenn immer noch keine Nähe erkannt wird, gehe zurück in den Ruhezustand und überprüfe nach 1 Sekunde erneut
}
}
myCodeCell.Init(LIGHT); // Zeit zum Aufwachen – Initialisiert alle CodeCell-Peripheriegeräte
}
void-Schleife() {
if (myCodeCell.Run(10)) { // Alle 10 Hz ausführen
wenn (myCodeCell.Light_ProximityRead() < 10) {
myCodeCell.Sleep(1); // Wenn keine Nähe erkannt wird, gehe in den Ruhezustand und überprüfe nach 1 Sekunde erneut
}
}
}
So funktioniert es:
Beim Booten initialisiert CodeCell den Lichtsensor und prüft die Nähe.
Wenn keine Nähe erkannt wird, wechselt CodeCell für 1 Sekunde in den Ruhemodus.
Jede Sekunde wird CodeCell kurz aktiviert, prüft die Nähe und geht bei Bedarf wieder in den Ruhezustand.
Wenn eine Nähe erkannt wird, wird CodeCell vollständig aktiviert und initialisiert alle Peripheriegeräte.
Mit diesem Beispiel können Sie CodeCell deutlich stromsparender gestalten und es so für batteriebetriebene Anwendungen optimieren. Wir arbeiten kontinuierlich daran, CodeCell für Anwendungen mit geringem Stromverbrauch zu optimieren. Bleiben Sie dran für Updates und Verbesserungen!
In dieser Anleitung erfahren Sie, wie Sie mit der CodeCell die Rotation direkt messen, indem Sie den Roll-, Nick- und Gierwinkel ablesen. Das Verständnis dieser Winkel ist entscheidend für Anwendungen wie Robotik, Drohnen und Bewegungsverfolgung, bei denen präzise Orientierungsdaten benötigt werden.
CodeCell ist mit einem Bewegungssensor BNO085 ausgestattet, der Daten von Beschleunigungsmesser, Gyroskop und Magnetometer zur Berechnung von Rotationsvektoren kombiniert. Diese Vektoren helfen dabei, die Ausrichtung des Geräts im Raum in Bezug auf Roll-, Nick- und Gierbewegungen zu bestimmen:
Durch die kontinuierliche Überwachung dieser Werte bietet CodeCell Orientierungsfeedback in Echtzeit und ist daher für eine Vielzahl bewegungsbasierter Anwendungen nützlich.
Um die Drehwinkel zu lesen, folgen Sie diesem einfachen Beispiel. Dieser Code initialisiert den Bewegungssensor von CodeCell und gibt kontinuierlich die Roll-, Nick- und Gierwerte auf dem seriellen Monitor aus.
#include <CodeCell.h>
CodeCell myCodeCell;
float Roll = 0.0;
float Pitch = 0.0;
float Yaw = 0.0;
void setup() {
Serial.begin(115200); // Set Serial baud rate to 115200. Ensure Tools/USB_CDC_On_Boot is enabled if using Serial.
myCodeCell.Init(MOTION_ROTATION); // Initializes Rotation Sensing
}
void loop() {
if (myCodeCell.Run(10)) { // Run every 10Hz
myCodeCell.Motion_RotationRead(Roll, Pitch, Yaw);
Serial.printf("Roll: %.2f°, Pitch: %.2f°, Yaw: %.2f°\n", Roll, Pitch, Yaw);
}
}
Erläuterung des Codes:
Initialisieren Sie den CodeCell-Bewegungssensor, um Rotationswerte zu lesen.
Lassen Sie den Sensor mit 10 Hz (alle 100 ms) laufen, um aktuelle Daten zu erhalten.
Drucken Sie die Roll-, Nick- und Gierwinkel in Grad auf dem seriellen Monitor.
Dies bietet eine genaue Möglichkeit, die Ausrichtung von CodeCell in Echtzeit zu messen.
Eine praktische Anwendung des Auslesens von Roll-, Nick- und Gierwinkel ist die Steuerung eines Servomotors basierend auf der Ausrichtung von CodeCell. Das folgende Beispiel bildet den Nickwinkel auf die Position des Servos ab.
#include <CodeCell.h>
#include <ESP32Servo.h>
CodeCell myCodeCell;
Servo myservo;
float Roll = 0.0;
float Pitch = 0.0;
float Yaw = 0.0;
int servo_angle = 0;
void setup() {
Serial.begin(115200); // Set Serial baud rate to 115200
myCodeCell.Init(MOTION_ROTATION); // Initializes rotation sensing
myservo.attach(1); // Attaches the servo on pin 1 to the servo object
}
void loop() {
if (myCodeCell.Run(10)) {
// Read rotation angles from the BNO085 sensor
myCodeCell.Motion_RotationRead(Roll, Pitch, Yaw);
// Convert the pitch angle to a servo angle
servo_angle = abs((int)Pitch);
servo_angle = (180 - servo_angle);
// 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
}
}
Erläuterung:
Ordnet den Nickwinkel zu, um die Servoposition zu steuern.
Begrenzt den Servowinkel auf einen sicheren Bereich (0–60 Grad), um übermäßige Bewegungen zu vermeiden.
Verwendet 10-Hz-Updates, um eine gleichmäßige Reaktion zu gewährleisten.
Durch das direkte Auslesen von Roll-, Nick- und Gierbewegungen können Sie mit CodeCell erweiterte bewegungsbasierte Anwendungen freischalten. Passen Sie die Beispiele an und integrieren Sie sie in Ihre eigenen Projekte. Weitere Beispiele und technische Dokumentation finden Sie im CodeCell GitHub Repository !
Die CodeCell bietet flexible Stromversorgungsoptionen und kann entweder über den LiPo-Akkuanschluss, ein USB-C-Kabel oder beide gleichzeitig mit Strom versorgt werden. Dies gewährleistet die Anpassungsfähigkeit an verschiedene Anwendungsfälle.
Die Energieverwaltung übernimmt der Batteriemanagement-Chip BQ24232 , der Dynamic Power-Path Management (DPPM) unterstützt. Dadurch kann die CodeCell mit externer Stromversorgung betrieben und gleichzeitig der Akku geladen werden. Der Ladevorgang erfolgt in drei Hauptphasen:
Der BQ24232-Chip regelt die Ausgangsspannung und unterstützt eine maximale Leistung von 1500 mA bei Stromversorgung über den LiPo-Akku und 450 mA bei Stromversorgung über USB.
Der Ladestrom des LiPo-Akkus ist standardmäßig auf 90 mA eingestellt. Dies ist für den optionalen 170 mAh LiPo-Akku optimiert und gewährleistet eine sichere und ausgewogene Laderate.
Fortgeschrittene Anwender, die den Ladestrom ändern möchten, können dies durch den Austausch des 0402-Widerstands R12 tun. Diese Änderung erfordert jedoch präzise Lötkenntnisse, da 0402-Komponenten extrem klein sind. Weitere Details finden Sie im Datenblatt des BQ24232.
Die CodeCell-Bibliothek bietet mithilfe der integrierten RGB-LED visuelles Feedback zum Lade- und Stromstatus:
Um den Energiestatus der CodeCell zu lesen, können Benutzer die Funktion PowerStateRead() verwenden:
Hinweis: Diese Funktion ist ab Softwareversion v1.2.8 verfügbar. Stellen Sie daher sicher, dass Sie die Firmware aktualisiert haben. Die CodeCell bleibt während des Ladevorgangs betriebsbereit. Wenn Sie den Betrieb unterbrechen möchten, empfehlen wir Ihnen, den Ladezustand abzufragen.
Zum Lesen der Batteriespannung können Sie die Funktion BatteryVoltageRead() oder BatteryLevelRead() verwenden, um den Batterieprozentsatz zu lesen.
Bei BatteryLevelRead() liegt der zurückgegebene Wert zwischen 1 und 100 % . Wenn der Akku geladen wird, wird 101 zurückgegeben. Wenn die CodeCell nur über USB ohne Akku mit Strom versorgt wird, wird 102 zurückgegeben.
Mit diesen Informationen haben Sie nun ein umfassendes Verständnis der Funktionsweise des Ladesystems von CodeCell, einschließlich seines Standardverhaltens und seiner Anpassungsoptionen!
CodeCell ist ein kompaktes Modul mit dem ESP32-C3, verschiedenen Stromversorgungsoptionen und integrierten Sensoren – und das alles in einem winzigen Formfaktor von 1,85 cm Breite. Diese Eigenschaften machen es zu einem leistungsstarken Werkzeug für eine Vielzahl von Anwendungen.
In diesem ersten Abschnitt machen wir uns zunächst mit der Schaltung der CodeCell vertraut. Anschließend führen wir Sie durch die einfachen Schritte zur Einrichtung Ihrer CodeCell.
Um die Schaltkreise genauer zu verfolgen, sehen Sie sich hier die CodeCell-Schaltpläne an .
Das Herzstück der CodeCell ist das ESP32-C3-Modul, ein kompakter Mikrocontroller, der für seine Maker-freundliche Bauweise im IoT-Bereich bekannt ist. Er kombiniert eine Arduino-kompatible Architektur mit integrierten WLAN- und Bluetooth Low Energy (BLE)-Funktionen.
Die PCB-Antenne des ESP32-C3-Moduls ist seitlich, abseits von anderen Komponenten, positioniert, um Störungen zu minimieren und die Signalübertragung und den Signalempfang zu verbessern. Diese Platzierung trägt dazu bei, den Einfluss von Masseflächen oder anderen leitfähigen Oberflächen, die die Antennenleistung beeinträchtigen könnten, zu reduzieren. Tests haben gezeigt, dass die Leistung der Antenne bei batteriebetriebenen Anwendungen unbeeinträchtigt bleibt. Beim Anschließen des USB-C-Kabels zum Laden treten nur minimale Störungen auf, da diese Kabel typischerweise abgeschirmt sind.
Der ESP32-C3 bietet 4 MB Flash und 400 KB SRAM und ist damit für die meisten Anwendungen geeignet. Sein 32-Bit-RISC-V-Single-Core-Prozessor mit bis zu 160 MHz bewältigt effizient verschiedene Aufgaben. Der ESP32-C3 verfügt außerdem über einen USB-Seriell/JTAG-Controller, der das erneute Flashen von CodeCell über den USB-C-Anschluss ermöglicht und die serielle Kommunikation sowie das Debugging erleichtert.
Die CodeCell bietet flexible Stromversorgungsoptionen. Sie kann über den LiPo-Akkuanschluss, ein USB-C-Kabel oder beides mit Strom versorgt werden.
Die Energieverwaltung übernimmt der Batteriemanagement-Chip BQ24232, der Dynamic Power-Path Management (DPPM) unterstützt. Dadurch kann CodeCell mit Strom versorgt und gleichzeitig der Akku geladen werden. Der Ladevorgang erfolgt in drei Phasen:
Die Ausgangsspannung wird über den BQ24232-Chip geregelt und unterstützt bis zu 1500 mA bei Stromversorgung über den LiPo-Akku und 450 mA über USB.
Der Ladestrom des LiPo-Akkus ist standardmäßig auf 90 mA eingestellt, um eine sichere Laderate für den optionalen 170-mAh-LiPo-Akku zu gewährleisten. Fortgeschrittene Benutzer können diese Rate anpassen, indem sie den 0402-Widerstand R12 nach der Formel R = 870/Ichrg ersetzen. Diese Änderung wird nur für Personen empfohlen, die Erfahrung mit dem Löten von 0402-Komponenten haben. Weitere Informationen finden Sie im Datenblatt des BQ24232.
Die CodeCell-Bibliothek bietet visuelles Feedback zum Stromstatus über die integrierte adressierbare RGB-LED:
Die Platine enthält außerdem 100-µF-Kondensatoren für eine stabile Stromversorgung und TVS-Dioden zum ESD-Schutz. Ein 3,3-V-Low-Dropout-Regler (LDO) (NCP177) liefert einen stabilen 500-mA-Ausgang mit einem Dropout von 200 mV bei maximalem Strom.
Das kompakte Design der CodeCell erforderte eine sorgfältige Platzierung der GPIO- und Stromversorgungsanschlüsse. Die Platine ist in Funktionsbereiche unterteilt:
Die CodeCell ist mit integrierten Sensoren ausgestattet, um ihre Funktionalität zu verbessern:
VCNL4040 Lichtsensor:
Optionaler 9-Achsen-Bewegungssensor BNO085:
Unsere CodeCell-Bibliothek vereinfacht die Sensorkonfiguration und das Lesen jedes Sensors.
Viele ESP32-Entwicklungsboards verfügen über RST- (Reset) und BOOT- Tasten. Der ESP32-C3 auf CodeCell kann jedoch automatisch über die Arduino IDE in den Boot-Modus wechseln, wodurch diese Tasten überflüssig werden und ein kleinerer Formfaktor möglich wird.
Wenn bei der CodeCell eine Ausnahme auftritt (die zu kontinuierlichen Zurücksetzungen führt), kann sie zum erneuten Flashen manuell in den Bootmodus gezwungen werden:
Wenn Sie diese Schritte befolgen, wird die CodeCell wieder zum Leben erweckt.
Jedes CodeCell-Paket enthält:
Wenn Sie gerade erst die CodeCell in die Hände bekommen haben, erwartet Sie ein Leckerbissen. Dieses winzige Modul wurde entwickelt, um Ihre DIY-Projekte mit zahlreichen Funktionen auf einer pfenniggroßen Platine zu vereinfachen. In dieser Anleitung führen wir Sie durch :
CodeCell ist ein kompaktes und vielseitiges Modul mit dem ESP32-C3, mehreren Stromversorgungsoptionen und integrierten Sensoren – und das alles in einem winzigen Formfaktor von 1,85 cm Breite. Diese Funktionen machen es zu einem leistungsstarken Werkzeug für eine Vielzahl von Anwendungen.
In diesem ersten Abschnitt machen wir uns zunächst mit der Schaltung vertraut, aus der die CodeCell besteht. Danach gehen wir die einfachen Schritte zum Einrichten Ihrer CodeCell durch.
ESP32C3-Modul
Das Herzstück der CodeCell ist das ESP32C3-Modul, ein kompakter Mikrocontroller, der für seine Maker-Freundlichkeit im IoT-Bereich bekannt ist. Er kombiniert eine Arduino-kompatible Architektur mit integrierten Wi-Fi- und Bluetooth Low Energy (BLE)-Funktionen. Diese Integration bietet die gängigsten Konnektivitätsoptionen bei gleichzeitig kleinem Formfaktor.
Die PCB-Antenne des ESP32C3-Moduls ist auf einer Seite, entfernt von anderen Komponenten, positioniert, um Störungen zu minimieren und die Signalübertragung und den Signalempfang zu verbessern. Diese Platzierung trägt dazu bei, den Einfluss von Masseflächen oder anderen leitfähigen Oberflächen zu reduzieren, die die Antennenleistung beeinträchtigen könnten. Die Komponenten auf der Unterseite befinden sich innerhalb des empfohlenen Abstands für die Antenne. Beim Testen haben wir festgestellt, dass die Leistung der Antenne durch die minimalen Störungen eines USB-C-Kabels nicht beeinträchtigt wird, da diese Kabel normalerweise abgeschirmt sind.
Der ESP32-C3 bietet mit 4 MB Flash und 400 KB SRAM reichlich Speicher und kann damit die meisten typischen Anwendungen ausführen. Sein 32-Bit-RISC-V-Single-Core-Prozessor mit bis zu 160 MHz erledigt verschiedene Aufgaben effizient. Diese Kombination aus Speicher und Rechenleistung macht den ESP32-C3 für ein breites Anwendungsspektrum geeignet.
Das ESP32C3-Modul unterstützt auch einen USB-Seriell-/JTAG-Controller, sodass wir die CodeCell über den USB-C-Anschluss erneut flashen und serielle Daten zur Kommunikation und zum Debuggen senden können.
Energieverwaltung
Die CodeCell bietet Flexibilität bei den Stromversorgungsoptionen. Sie kann über den LiPo-Batterieanschluss, ein USB-C-Kabel oder beides mit Strom versorgt werden.
Mit dem LiPo-Batterieanschluss ist es einfacher als je zuvor, die Batterie sicher anzuschließen, ohne dass Lötarbeiten erforderlich sind oder das Risiko eines versehentlichen Kurzschlusses besteht.
Der USB-C-Anschluss dient zwei Zwecken: Er wird sowohl zum Betreiben des Geräts als auch zum Neuprogrammieren verwendet. Diese Multi-Power-Option wird durch den Batteriemanagement-Chip BQ24232 ermöglicht, der über dynamisches Power-Path-Management (DPPM) verfügt, das das System mit Strom versorgen und gleichzeitig und unabhängig die Batterie laden kann. Der Ladevorgang der Batterie wird in drei Phasen gesteuert: Konditionierungsvorladung, konstanter Strom und konstante Spannung. Zum Schutz der Batterie wird die Ausgangsspannung (Vo) durch den BQ24232-Chip geregelt. Dieser Ausgang unterstützt einen maximalen Ausgangsstrom von 1500 mA bei Stromversorgung durch die LiPo-Batterie und 450 mA bei Stromversorgung über USB.
Standardmäßig ist der Ladestrom des LiPo-Akkus auf 90 mA eingestellt, was eine ausgewogene und sichere Laderate für den optionalen 170-mAh-LiPo-Akku gewährleistet. Darüber hinaus muss der 0402-Widerstand R12 abgelötet und durch einen neuen Widerstand gemäß der Formel (R = 870/Ichrg) ersetzt werden, wenn man die Laderate anpassen möchte. Dies wird nur Lötprofis empfohlen, die sich nicht davor scheuen, mit winzigen 0402-Komponenten zu kämpfen! Weitere Informationen zum Laden des Akkus finden Sie im Datenblatt des BQ24232.
Die CodeCell- Bibliothek kann über die integrierte adressierbare RGB-LED visuelles Feedback zum Batterie-/USB-Stromstatus liefern:
Die Leistungsregelung wird zusätzlich durch mehrere Entkopplungskondensatoren unterstützt, darunter bis zu zwei Massenkondensatoren mit jeweils 100 µF, die neben dem Batterieanschluss platziert sind. Diese Kondensatoren sind mit den 3,3-V- und den Vo-Ausgangspins verbunden, um eine stabile Stromversorgung zu gewährleisten. Zusätzlich verfügt die Platine über zwei TVS-Dioden zum Schutz; eine schützt die 5-V-USB-Eingangsspannung (Vin) und die andere die Ausgangsspannung (Vo). Diese TVS-Dioden bieten Schutz vor elektrostatischen Entladungen (ESD) und können wiederholte ESD-Schläge über dem im internationalen Standard IEC 61000-4-2 festgelegten Höchstwert sicher absorbieren, ohne dass es zu Leistungseinbußen kommt.
Die Platine enthält außerdem einen integrierten 3,3-V-Low-Dropout-Regler (LDO), der eine stabile Stromversorgung für die Niederspannungskomponenten gewährleistet. Dieser winzige NCP177-LDO-Chip kann bis zu 500 mA Ausgangsstrom mit einer typisch niedrigen Dropout-Spannung von 200 mV bei 500 mA ausgeben.
GPIO- und Stromversorgungspins
Angesichts des kompakten Designs bestand die größte Herausforderung darin, die GPIO-Pins optimal zu nutzen. Wir haben dies erreicht, indem wir jede der drei verfügbaren Seiten der CodeCell je nach Anwendung in verschiedene E/A-Abschnitte unterteilt haben. Außerdem haben wir Stromanschlüsse an den Kanten des Moduls platziert, um den Anschluss an verschiedene Stromquellen zu erleichtern. So können Sie andere Module, Sensoren und Aktoren an verschiedenen Seiten anschließen.
Auf der Unterseite werden 3 von 5 Pins für die Stromversorgung verwendet: ein Erdungspin (GD), ein 3,3-V-Logikpegel-Stromversorgungspin (3V3) und ein 5-V-Eingangsladepin (5V0). Dieser 5V0-Pin ist mit der USB-Eingangsspannung verbunden. Das bedeutet, dass Sie ihn verwenden können, um 5 V Strom zu erhalten, wenn USB angeschlossen ist, oder Sie können ihn als Stromeingang zum Laden verwenden, anstatt USB zu verwenden. Die anderen 2 Pins sind die I2C-SDA- und SCL-Pins zum Hinzufügen externer digitaler Sensoren. Wenn Sie keine externen Sensoren und die Licht-/Bewegungssensoren verwenden, können diese I2C-Pins als GPIOs eingerichtet werden.
Die anderen beiden Seiten verfügen jeweils über einen Erdungsstift (GD) und einen Spannungsausgangsstift (VO). Jede Seite verfügt außerdem über 3 programmierbare GPIO-Pins (IO1, IO2, IO3, IO5, IO6, IO7), die alle als PWM-Pins konfiguriert werden können ( ideal für den direkten Anschluss einer H-Brücke zur Aktuator-/Motorsteuerung ). IO1, IO2 und IO3 können auch als ADC-Pins verwendet werden.
Sensorfunktionen
Zu den herausragenden Merkmalen der CodeCell gehören die integrierten Sensoren. Jede Einheit ist mit einem integrierten Lichtsensor ausgestattet. Außerdem ist ein optionaler Bewegungssensor erhältlich, um die Bewegungserkennung Ihres Projekts zu verbessern – besonders nützlich für Roboter und Wearables!
Als Nächstes werden wir uns damit befassen, wie die CodeCell -Bibliothek sowohl die Konfiguration dieser Sensoren als auch das Lesen ihrer Daten vereinfacht.
Was ist mit dem BOOT-Pin?
Einige ESP32-Entwicklungsboards verfügen sowohl über eine RST-Taste (Reset) als auch eine BOOT -Taste, um das Gerät manuell in den Programmiermodus zu versetzen. Der ESP32-C3, wie beispielsweise der auf dem CodeCell-Modul, kann jedoch bei Verwendung der Arduino IDE automatisch über die serielle Schnittstelle in den Bootmodus wechseln. Das bedeutet, dass die CodeCell keine dedizierten RST- oder BOOT-Tasten benötigt, wodurch wir sie so klein machen konnten.
In dem seltenen Fall, dass Ihre CodeCell einfriert oder eine Ausnahme auftritt (was dazu führt, dass sie kontinuierlich zurückgesetzt wird), können Sie sie manuell in den Bootmodus zwingen, um die Firmware neu zu flashen. Befolgen Sie dazu einfach diese Schritte:
Wenn Sie diese Schritte befolgen, wird Ihre CodeCell wieder zum Leben erweckt.
Um die Programmierung noch einfacher zu machen, CodeCell Die Bibliothek bietet eine breite Palette an Funktionen zum Initialisieren, Lesen und Verwalten von Sensoren und Strom. In diesem Abschnitt erklären wir alles, was Sie über die Einrichtung Ihres Geräts und seiner Bibliothek wissen müssen.
Auspacken Ihrer CodeCell
Beginnen wir mit dem, was Sie in der Box finden. Abhängig von den Optionen, die Sie beim Bezahlvorgang ausgewählt haben, finden Sie in der Box:
CodeCell zum ersten Mal einschalten
Beginnen wir mit dem Einstecken eines USB-C-Kabels! Sobald Ihre CodeCell mit Strom versorgt wird, sollte sie:
Einrichten Ihrer CodeCell
Der nächste Schritt besteht darin, die CodeCell mit der Arduino IDE zu verbinden und eine Skizze auszuführen:
Nachdem Ihre IDE vollständig eingerichtet ist, können wir nun mit der Installation der Bibliothek „CodeCell“ fortfahren. Gehen Sie dazu zu „Sketch > Bibliothek einbinden > Bibliotheken verwalten“ – der „Bibliotheksmanager“ sollte sich öffnen. Geben Sie einfach „CodeCell“ ein und klicken Sie auf „Installieren“, um die neueste Version von CodeCell herunterzuladen.
Wir aktualisieren diese Bibliothek kontinuierlich und fügen neue Funktionen hinzu. Stellen Sie daher sicher, dass Sie die neueste Version verwenden.
Um sich schnell mit dieser Bibliothek vertraut zu machen, gehen Sie zu „Datei > Beispiele > CodeCell“, wo Sie mehrere Beispiele finden, die Sie für Ihre Projekte verwenden und ändern können. Wir empfehlen, mit dem Beispiel „GettingStarted“ zu beginnen, das nur wenige Codezeilen enthält, aber alle mit CodeCell verfügbaren Sensorfunktionen erklärt.
Sobald Sie eine Beispielskizze ausgewählt haben, klicken Sie auf die Schaltfläche „Hochladen“, um den Code auf Ihre CodeCell zu flashen. Öffnen Sie nach dem Hochladen den seriellen Monitor „Tools > Serieller Monitor“, um serielle Daten von Ihrer CodeCell anzuzeigen.
Hier sind einige zusätzliche CodeCell- Tutorials, die Ihnen den Einstieg in verschiedene Anwendungen erleichtern:
CodeCell-Bibliotheksfunktionen
Um den Code genauer zu untersuchen, wollen wir alle Funktionen aufschlüsseln und erklären, was jede einzelne macht:
CodeCell initialisieren
Der erste Schritt bei der Nutzung der CodeCell besteht darin, es zu initialisieren. Dies geschieht mit der Funktion `myCodeCell.Init()`, mit der Sie die Sensoren angeben können, die Sie aktivieren möchten.
Verfügbare Sensormakros:
Sie können mehrere Makros mit dem Operator „+“ kombinieren, um mehrere Sensoren gleichzeitig zu initialisieren.
Energiemanagement
Die Funktion `myCodeCell.Run()` ist für die Energieverwaltung von entscheidender Bedeutung. Diese Funktion sollte innerhalb der Funktion `loop()` aufgerufen werden, um den Batteriestatus zu verwalten und eine optimale Energienutzung sicherzustellen.
Funktionsverhalten:
Sensordaten auslesen
Nach der Initialisierung der Sensoren können Sie deren Daten mithilfe verschiedener von der Bibliothek bereitgestellter Funktionen lesen. Hier ist ein kurzer Überblick über die verfügbaren Funktionen:
Lichtsensorfunktionen:
Funktionen des Bewegungssensors:
Anwendungsbeispiel:
Ruhezustand, Energiesparen, Diagnose- und LED-Funktionen
Die CodeCell umfasst mehrere Funktionen zur Verwaltung des Ruhe- und Energiesparmodus:
Sie haben jetzt Ihre ersten Schritte mit CodeCell gemacht. Tauchen Sie tiefer in die Bibliotheksbeispiele ein, erkunden Sie Sensorintegrationen und beginnen Sie, Ihre innovativen Projekte mit CodeCell zum Leben zu erwecken!
Am einfachsten verbinden Sie CodeCell mit einer Fernbedienung über unsere MicroLink Bluetooth-App . Mit dieser können Sie Ihrem Projekt schnell Schaltflächen, Schieberegler und einen Joystick hinzufügen. Dies wird hier alles erklärt. In dieser Anleitung konzentrieren wir uns jedoch auf die Konfiguration des ESP32-C3 von CodeCell als WLAN-Fernbedienung, die die Kommunikation zwischen zwei Geräten ermöglicht.
Der ESP32-C3 von CodeCell ist WLAN-fähig und ermöglicht so die drahtlose Kommunikation. Mit ESP-NOW können wir mit minimalem Aufwand eine direkte Gerätekommunikation herstellen. Diese Anleitung zeigt, wie man zwei Geräte koppelt, wobei eines als sensorbasierte Fernbedienung und das andere zum Empfangen und Verarbeiten der übertragenen Daten verwendet wird.
In diesem Beispiel koppeln wir zwei CodeCell -Geräte. Gerät 1 erfasst 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 von Gerät 1 die integrierte LED von Gerät 2 steuert. Im zweiten Beispiel sendet Gerät 1 Winkeldaten, und Gerät 2 verarbeitet diese, um die Motordrehzahl anzupassen.
Bevor Sie die Kommunikation zwischen den beiden CodeCell- Geräten herstellen können, benötigen Sie zunächst die MAC-Adresse des Empfängers. Diese MAC-Adresse wird im Code des Senders verwendet, um sicherzustellen, dass das richtige Gerät die Daten empfängt.
Gehen Sie folgendermaßen vor, um die MAC-Adresse des Empfängers zu erhalten:
XX:XX:XX:XX:XX:XX ausgegeben. Kopieren Sie diese Adresse, da Sie sie für den Absendercode benötigen. 
Ersetzen Sie die Platzhalter-MAC-Adresse im Code des Absenders (Gerät 1) durch die MAC-Adresse, die Sie gerade von Gerät 2 erhalten haben. Dadurch wird sichergestellt, dass Gerät 1 Daten an den richtigen Empfänger sendet.Dieses Beispiel zeigt, wie Näherungssensordaten von Gerät 1 an Gerät 2 gesendet werden, das die Daten zum Ein- oder Ausschalten seiner integrierten LED verwendet.
#include <esp_now.h>
#include <WiFi.h>
#include <CodeCell.h>
CodeCell myCodeCell;
uint8_t receiverMAC[] = { 0xXX, 0xXX, 0xXX, 0xXX, 0xXX, 0xXX }; // Ersetzen durch die MAC-Adresse des Empfängers
void setup() {
Serial.begin(115200);
myCodeCell.Init(LIGHT); // Initialisiert die Lichterkennung
// WLAN 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 PeerInfo;
memcpy(peerInfo.peer_addr, receiverMAC, 6);
peerInfo.channel = 0;
peerInfo.encrypt = falsch;
if (esp_now_add_peer(&peerInfo) != ESP_OK) {
Serial.println("Peer konnte nicht hinzugefügt werden");
zurückkehren;
}
}
void-Schleife() {
wenn (myCodeCell.Run(10)) {
uint16_t ProxRead = (myCodeCell.Light_ProximityRead()) >> 4; // Näherungswert ermitteln 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_Value;
memcpy(&Remote_Value, incomingData, sizeof(Remote_Value));
Serial.println(Remote_Value);
myCodeCell.LED(0, Remote_Value, 0); // Control onboard LED brightness
}
void loop() {
// Nothing to do here
}
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 zweier 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 myCodeCell;
uint8_t receiverMAC[] = {0xXX, 0xXX, 0xXX, 0xXX, 0xXX, 0xXX}; // Replace with receiver's MAC address
int Roll_Control = 0;
float Roll = 0.0;
float Pitch = 0.0;
float Yaw = 0.0;
void setup() {
Serial.begin(115200);
myCodeCell.Init(MOTION_ROTATION); // Initialize motion sensing
// Initialize WiFi in Station mode
WiFi.mode(WIFI_STA);
Serial.println(WiFi.macAddress());
// Initialize ESP-NOW
wenn (esp_now_init() != ESP_OK) {
Serial.println("Fehler beim Initialisieren von ESP-NOW");
zurückkehren;
}
// Peer registrieren
esp_now_peer_info_t PeerInfo;
memcpy(peerInfo.peer_addr, receiverMAC, 6);
peerInfo.channel = 0;
peerInfo.encrypt = falsch;
if (esp_now_add_peer(&peerInfo) != ESP_OK) {
Serial.println("Peer konnte nicht hinzugefügt werden");
zurückkehren;
}
}
void-Schleife() {
wenn (myCodeCell.Run(10)) {
myCodeCell.Motion_RotationRead(Rollen, Neigen, Gieren);
Rollen = Rollen + 180;
Wurf = (Wurf * 100) / 180;
Rollen = beschränken(Rollen, 0, 200) / 2;
Roll_Control = (uint8_t)Roll;
Serial.println(Roll_Control);
esp_now_send(receiverMAC, (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); // Lichtsensor initialisieren
Motor1.Init();
Motor2.Init();
// WLAN 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;
}
// Den Empfangs-Callback registrieren
esp_now_register_recv_cb(onDataRecv);
}
void onDataRecv(const esp_now_recv_info *recvInfo, const uint8_t *incomingData, int len) {
int Rollgeschwindigkeit = 0;
memcpy(&Roll_Speed, eingehende Daten, Größe von(Roll_Speed));
wenn (Rollgeschwindigkeit > 50) {
Motor1.Antrieb(1, Rollgeschwindigkeit);
Motor2.Drive(1, Roll_Speed);
} anders {
Rollgeschwindigkeit = 100 - Rollgeschwindigkeit;
Motor1.Antrieb(0, Rollgeschwindigkeit);
Motor2.Drive(0, Roll_Speed);
}
Serial.println(Roll_Speed);
}
void-Schleife() {
wenn (myCodeCell.Run(10)) {}
}
Anhand dieser Beispiele können Sie zwei CodeCell -Geräte für die WLAN-Kommunikation mit ESP-NOW konfigurieren. Die Beispiele zeigen, wie Sie Näherungs- und Winkeldaten zwischen Geräten senden und diese für die Echtzeitsteuerung von LEDs und Motoren nutzen.
Sie können diese Projekte gerne erweitern, indem Sie weitere Sensoren oder zusätzliche Funktionen integrieren, 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 AI. 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 diesen 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(10)) {
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); // Set Serial baud rate to 115200. Ensure Tools/USB_CDC_On_Boot is enabled if using Serial.
myCodeCell.Init(LIGHT); // Initializes Light Sensing
FlatFlap1.Init();
FlatFlap2.Init();
FlatFlap1.Tone();
FlatFlap2.Tone();
}
void schleife() {
wenn (myCodeCell.Run(10)) {
// 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 dieser Anleitung erfahren Sie, wie Sie den integrierten Bewegungssensor der CodeCell so konfigurieren, dass er Ihre persönliche Aktivität errät und auf einem OLED-Bildschirm anzeigt. Er dient zur Erfassung verschiedener Zustände wie Gehen, Laufen, Radfahren, Treppensteigen und Autofahren!
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 gerade 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 eignet sich ideal für tragbare 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, da dies hauptsächlich von der Ausrichtung der CodeCell und ihrem Montageort abhängt.
Unten finden Sie den Beispielcode für den Einstieg. Stellen Sie sicher, dass Ihre CodeCell über USB-C angeschlossen ist und Ihr OLED-Display über die Masse-, 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 // Address of the OLED display
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, 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.
if (!display.begin(SSD1306_SWITCHCAPVCC, BILDSCHIRMADRESSE)) {
Serial.println(F("SSD1306-Zuweisung fehlgeschlagen"));
}
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(SSD1306_WHITE);
Anzeige.Anzeige();
Verzögerung (2000);
}
void-Schleife() {
wenn (myCodeCell.Run(10)) {
wenn (Lesetimer < 10) {
lese_timer++;
} anders {
// Alle 1 Sekunde aktualisieren
Lesetimer = 0;
display.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 der Bewegungssensor der CodeCell persönliche Aktivitäten überwacht und die Ergebnisse auf einem OLED-Bildschirm anzeigt. Dieser grundlegende Aufbau bildet die Grundlage für die Entwicklung fortschrittlicherer Aktivitätsüberwachungssysteme.
Experimentieren Sie mit dem Code und den Einstellungen, um Ihr eigenes personalisiertes Wearable zu erstellen!
In dieser Anleitung erfahren Sie, wie Sie mit dem integrierten Bewegungssensor von CodeCell die Schrittzahl messen und diese auf einem OLED-Display anzeigen können. So können Sie CodeCell ganz einfach in Ihren eigenen Schrittzähler oder sogar Fitness-Tracker verwandeln!
CodeCell ist mit einem BNO085-Bewegungssensor ausgestattet, der die Daten eines Beschleunigungsmessers, eines Gyroskops und eines Magnetometers kombiniert, um bestimmte Bewegungsmuster zu verfolgen und festzustellen, ob ein Schritt ausgeführt wurde. Jeder Schritt wird einem Zähler hinzugefügt, und die CodeCell- Bibliothek erleichtert das Auslesen dieser Schrittzahlen.
In diesem Beispiel überwacht die CodeCell kontinuierlich die Anzahl der Schritte und aktualisiert diese. Diese wird dann mithilfe der Adafruit SSD1306-Bibliothek auf einem OLED-Bildschirm angezeigt.
Unten finden Sie den Beispielcode für den Einstieg. Stellen Sie sicher, dass Ihre CodeCell ordnungsgemäß über USB-C angeschlossen ist und Ihr OLED-Display korrekt mit der Unterseite der CodeCell verdrahtet 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 myCodeCell; /* Configure the OLED Display */ #define SCREEN_WIDTH 64 // 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 // Address of the OLED display Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET); uint16_t step_counter = 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 die Schrittzählung und Aktivitätserkennung. if (!display.begin(SSD1306_SWITCHCAPVCC, BILDSCHIRMADRESSE)) { Serial.println("Anzeigefehler"); } display.clearDisplay(); display.setTextSize(1); display.setTextColor(SSD1306_WHITE); Anzeige.Anzeige(); Verzögerung (2000); } void-Schleife() { if (myCodeCell.Run(10)) { //Alle 10 Hz ausführen
step_counter = myCodeCell.Motion_StepCounterRead(); //Schrittzähler lesen
display.clearDisplay();
display.setCursor(32, 16); // In der oberen linken Ecke beginnen
display.print(F("Schritte: "));
display.print(Schrittzähler);
display.display(); //Anzeige aktualisieren
} }
Dieses Projekt zeigt, wie Sie den Bewegungssensor von CodeCell als Schrittzähler nutzen und die Schrittzahl auf einem OLED-Bildschirm anzeigen können. Experimentieren Sie mit dem Code, um Ihr eigenes tragbares Fitnessgerät zu erstellen. Weitere Codebeispiele und technische Dokumentation finden Sie im CodeCell GitHub Repository !
In dieser Anleitung erfahren Sie, wie Sie mit der CodeCell einen Servomotor steuern. Außerdem erfahren Sie, wie Sie die Winkelposition des Servos mithilfe der CodeCell steuern können. Dies ist besonders nützlich für Roboteranwendungen wie Kardanringe oder die Winkelstabilitätskontrolle.
Ein Servomotor ist ein Drehantrieb, der eine präzise Steuerung der Winkelposition ermöglicht. Er besteht aus einem Motor mit Getriebe und einem Sensor zur Positionsrückmeldung und wird häufig in der Robotik, Automatisierung und Stabilisierung eingesetzt.
CodeCell ist mit einem BNO085-Bewegungssensor ausgestattet, der Daten von Beschleunigungsmesser, Gyroskop und Magnetometer kombiniert, um Rotationsvektoren zu berechnen. Diese Vektoren werden von CodeCell verarbeitet, um Roll-, Nick- und Gierwinkel basierend auf der räumlichen Ausrichtung des Geräts zu ermitteln.
In diesem Beispiel überwacht unsere CodeCell kontinuierlich den Neigungswinkel, um die Position eines Servomotors zu steuern und dynamisch auf Ausrichtungsänderungen zu reagieren. Der Neigungswert dient zur Einstellung der Servomotorposition, sodass dieser sich je nach Neigung des Geräts drehen kann.
Unten finden Sie einen Beispiel-Codeausschnitt für den Einstieg. Stellen Sie sicher, dass Ihre CodeCell ordnungsgemäß über USB-C angeschlossen ist. Überprüfen Sie außerdem, ob Ihr Servomotor über USB-C mit Strom versorgt werden kann (CodeCell kann über USB-C bis zu 500 mA und über eine Batterie bis zu 1500 mA liefern). Passen Sie die Winkelgrenzen im Code entsprechend an.
Für dieses Beispiel müssen Sie die Bibliothek „ESP32Servo“ installieren, um den Servomotor mit Ihrer CodeCell zu steuern. Folgen Sie den Kommentaren im Code, um die einzelnen Schritte 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. Enable Tools/USB_CDC_On_Boot 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(10)) {
// Read rotation angles from the BNO085 sensor
myCodeCell.Motion_RotationRead(Roll, Pitch, Yaw);
// Convert the pitch angle to a servo angle
servo_angle = abs((int)Pitch);
servo_angle = (180 - servo_angle);
// Limit the servo angle to the range 0-60 degrees
if (servo_angle > 60) {
Servowinkel = 60;
} sonst wenn (Servowinkel < 0) {
Servowinkel = 0;
}
anders{
//Überspringen
}
Serial.println(servo_angle); // Drucke den Servowinkel zum Debuggen
myservo.write(servo_angle); // Servoposition einstellen
}
}
Diese grundlegende Funktionalität kann erweitert werden, um komplexere Interaktionen zu erstellen, wie zum Beispiel:
servo_angle festgelegten Grenzwerte anpassen. In diesem Beispiel verwenden wir einen Mikroservo mit einem 60-Grad-Bereich. Einige Servomotoren sind mechanisch nicht linear, daher müssen Sie möglicherweise Winkelfehler kompensieren.Dieses Projekt zeigt, wie Sie einen Servomotor mit CodeCell und dessen Bewegungssensorfunktionen steuern. Experimentieren Sie mit dem Code, erstellen Sie eigene Projekte und besuchen Sie das CodeCell GitHub Repository für weitere Codebeispiele und technische Dokumentation!