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!
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 die Gefahr 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 gelöst, 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.
Wie richten Sie Ihre CodeCell ein und verwenden sie?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!
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!
Das CoilPad ist ein unglaublich dünner und innovativer Aktuator, der in einem kompakten Formfaktor Bewegung in Ihre Projekte bringt. Um zu verstehen, wie es funktioniert, tauchen wir in sein einzigartiges Design und die Prinzipien hinter seiner Funktionsweise ein.
In diesem Tutorial erklären wir:
Was ist ein CoilPad?
Das CoilPad ist ein Aktuator aus einer flexiblen Planarspule, die nahtlos an jeder glatten Oberfläche haftet. Durch Hinzufügen eines Magneten verwandelt es sich in ein Gerät, das magnetische Bewegungen, Summen oder sogar Heizen ermöglicht. Es ist so konzipiert, dass es elektrische Energie mühelos in mechanische Bewegung umwandelt.
Wie funktioniert es?
Das CoilPad verfügt über eine flache, ultradünne Spule, die mit externen Magneten interagiert. Wenn ein elektrischer Strom durch die Spule fließt, erzeugt sie ein Magnetfeld, das den Magneten entweder anzieht oder abstößt und so eine Bewegung verursacht. Durch Ändern der Stromrichtung können Sie die Bewegung des CoilPads steuern. Durch Anlegen eines Rechtecksignals schwingt das CoilPad kontinuierlich mit einstellbarer Geschwindigkeit und Intensität. Für sanfte, organische Bewegungen werden wir die DriveCell PWM-Bibliothek erkunden.
CoilPad installieren
Das CoilPad -Design erleichtert die Installation. Es verfügt über eine abziehbare Kleberückseite, die sicherstellt, dass es fest auf jeder glatten Oberfläche haftet.
Bringen Sie Ihr CoilPad in Bewegung
Sie können mit dem Testen beginnen, indem Sie einen seiner Pins auf 5 V und den anderen auf Masse ziehen und sie dann umschalten. In einem Fall wird der Magnet abgestoßen, im anderen angezogen. Sie können es an Ihre eigenen Transistoren oder Ihr H-Brückenmodul anschließen, um diese Pins automatisch umzuschalten. Um es noch einfacher zu machen, können Sie unser kleines DriveCell- Modul kaufen. DriveCell ist ein kompakter, Pin-zu-Pin-kompatibler H-Brückentreiber, der die Steuerung von Aktuatoren wie dem CoilPad vereinfacht. Seine Open-Source-Arduino-Softwarebibliothek macht die Aktuatorsteuerung besonders für Anfänger einfach, indem sie unkomplizierte Softwarefunktionen und leicht verständliche Beispiele bietet.
Eine ausführliche Anleitung zur DriveCell- Softwarebibliothek finden Sie in diesem Artikel . Hier ist jedoch eine kurze Zusammenfassung, wie Sie deren Funktionen nutzen können, um die CoilPad -Betätigung zu verbessern. Keine Sorge, es ist ganz einfach! Laden Sie zunächst die Bibliothek „DriveCell“ aus dem Bibliotheksmanager von Arduino herunter. Nach der Installation können Sie Ihr Gerät steuern. Bevor wir beginnen, stellen Sie sicher, dass Sie die DriveCell an Ihren Mikrocontroller anschließen. Wir empfehlen die Verwendung einer CodeCell, die Pin-zu-Pin-kompatibel ist, alle Bibliotheksfunktionen unterstützt und Ihrem CoilPad drahtlose Steuerung und interaktive Sensorik hinzufügen kann.
1. Init()
Zunächst benötigen wir einen grundlegenden Setup-Code, damit Sie loslegen können:
#include <DriveCell.h> // This line includes the DriveCell library
DriveCell myCoilPad(IN1, IN2); // Replace IN1 and IN2 with your specific pins
void setup() {
myCoilPad.Init(); // Initializes your DriveCell connected to a CoilPad
}
Dieser Code gibt Ihrer DriveCell den Namen „myCoilPad“ und weist sie an, alle erforderlichen Peripheriegeräte zu starten und zu initialisieren.
2. Puls (bool Richtung, uint8_t ms_Dauer)
Diese Funktion sendet einen kurzen Stromstoß mit einer bestimmten Polarität an das CoilPad . Dieses schnelle Aktivieren und Deaktivieren kann je nach Polarität eine kurze, heftige Bewegung des CoilPads verursachen.
myCoilPad.Pulse(1, 10); // Sends a short burst for 10 milliseconds in the specified direction3. Buzz (uint16_t us_buzz)
Diese Funktion lässt das CoilPad wie einen Summer vibrieren, was zur Erzeugung einer akustischen Rückmeldung nützlich ist.
myCoilPad.Buzz(100); // Makes the CoilPad buzz with a 100 microsecond pulses
4. Ton()
Mit der Tone -Funktion kann das CoilPad einen Ton abspielen. Dies kann für akustisches Feedback oder kreative Anwendungen verwendet werden, bei denen Ton Teil der Interaktion ist.
myCoilPad.Tone(); // Plays a tone by varying the frequency
5. Umschalten (uint8_t power_percent)
Diese Funktion schaltet die CoilPad- Polarität um, was nützlich sein kann, um in Ihrem Code eine schnelle Schlagbewegung zu erzeugen oder die Richtung schnell umzukehren.
myCoilPad.Toggle(100); // Toggles direction at 100% power
6. Ausführen (bool glatt, uint8_t Leistungsprozentsatz, uint16_t Flip-Geschwindigkeit_ms)
Mit dieser Funktion können Sie die Polarität des CoilPads kontinuierlich umkehren und seine Bewegungsgeschwindigkeit und -glätte steuern. Wenn smooth auf true eingestellt ist, ist die Betätigung weniger scharf und sanfter, was ideal für langsamere, kontrollierte Bewegungen ist.
myCoilPad.Run(true, 50, 1000); // Runs the CoilPad smoothly at 50% power, flipping every 1000 milliseconds
7. Antrieb (bool Richtung, uint8_t Leistung_Prozent)
Mit dieser Funktion können Sie die Polarität des CoilPads und seine magnetische Feldstärke durch Anpassen des Leistungspegels steuern.
myCoilPad.Drive(true, 75); // Moves the CoilPad forward at 75% power
Hier ist ein Beispiel, bei dem wir zwei CoilPads konfigurieren und sie mit zwei verschiedenen Geschwindigkeiten betätigen:
#include <DriveCell.h>
#define IN1_pin1 2
#define IN1_pin2 3
#define IN2_pin1 5
#define IN2_pin2 6
DriveCell CoilPad1(IN1_pin1, IN1_pin2);
DriveCell CoilPad2(IN2_pin1, IN2_pin2);
uint16_t c_counter = 0;
void setup() {
CoilPad1.Init();
CoilPad2.Init();
CoilPad1.Tone();
CoilPad2.Tone();
}
void loop() {
delay(1);
c_counter++;
if (c_counter < 2000U) {
CoilPad1.Run(0, 100, 100);
CoilPad2.Run(0, 100, 100);
}
else if (c_counter < 8000U) {
CoilPad1.Run(1, 100, 1000);
CoilPad2.Run(1, 100, 1000);
} anders {
c_Zähler = 0U;
}
}
Kombination mit CodeCell-Sensoren
Um es noch interaktiver zu machen, können Sie CoilPad und DriveCell mit dem winzigen CodeCell-Sensormodul kombinieren. CodeCell ist Pin-zu-Pin-kompatibel mit DriveCell , unterstützt alle Bibliotheksfunktionen und kann Ihrem Projekt drahtlose Steuerung und interaktive Sensorik hinzufügen. Auf diese Weise können Sie mit Ihren CoilPad- Aktuatoren fortgeschrittenere, reaktionsfähigere Elemente erstellen.
Mit diesem nächsten Beispiel steuert die CodeCell zwei CoilPads , die aufhören zu flattern, wenn eine Annäherung erkannt wird. Ihr Magnetfeld wird dynamisch angepasst, je nachdem, wie nahe Ihre Hände kommen. Wenn keine Hand erkannt wird, wechselt die CoilPad- Polarität alle 400 Millisekunden.
#include <CodeCell.h>
#include <DriveCell.h>
#define IN1_pin1 2
#define IN1_pin2 3
#define IN2_pin1 5
#define IN2_pin2 6
DriveCell CoilPad1(IN1_pin1, IN1_pin2);
DriveCell CoilPad2(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); /*Initialisiere die Lichterkennung*/
CoilPad1.Init();
CoilPad2.Init();
CoilPad1.Tone();
CoilPad2.Tone();
}
void schleife() {
wenn (myCodeCell.Run()) {
/*Läuft alle 100 ms*/
uint16_t Nähe = myCodeCell.Light_ProximityRead();
Serial.println(Nähe);
wenn (Nähe < 100) {
CoilPad1.Run(1, 100, 400);
CoilPad2.Run(1, 100, 400);
} anders {
Nähe = Nähe - 100;
Nähe = Nähe / 10;
wenn (Nähe > 100) {
Nähe = 100;
}
CoilPad1.Drive(0, (Nähe));
CoilPad2.Drive(0, (Nähe));
}
}
}
Passen Sie den Code gerne Ihren eigenen kreativen Ideen an oder fügen Sie Bewegungssensoren für eine neue Reaktion hinzu! Beginnen Sie noch heute mit unseren Arduino-Bibliotheken! Wenn Sie weitere Fragen zum CoilPad haben, schreiben Sie uns einfach eine E-Mail und wir helfen Ihnen gerne weiter!
Der FlatFlap ist ein unglaublich dünner und innovativer Aktuator, der in einem kompakten Formfaktor Bewegung in Ihre Projekte bringt. Um zu verstehen, wie er funktioniert, tauchen wir in sein einzigartiges Design und die Prinzipien hinter seiner Funktionsweise ein.
In diesem Tutorial erklären wir:
Was ist eine FlatFlap?
Es ist flach und es ist eine Klappe ~ die FlatFlap ist ein Aktuator aus einer flexiblen Leiterplatte und Aluminiumversteifungen, die zusammengefaltet sind, um eine Schlagbewegung mit geringer Kraft zu erzeugen. Sein Magnetsystem wandelt elektrische Energie in mechanische Bewegung um.
Wie funktioniert es?
Die FlatFlap verfügt auf ihrer Rückseite über einen dünnen 10-mm-N52-Neodym-Magneten, der mit der planaren Kupferspule interagiert, die in die flexible Leiterplatte eingebettet ist. Wenn ein elektrischer Strom durch die Spule fließt, erzeugt sie ein kleines Magnetfeld, das den Magneten entweder anzieht oder abstößt, wodurch die Klappe bewegt wird. Durch Ändern der Stromrichtung können Sie die Schlagbewegung des Aktuators steuern. Durch Anlegen eines Rechteckwellensignals schlägt die FlatFlap kontinuierlich mit Geschwindigkeiten von bis zu 25 Hz. Für sanfte organische Bewegungen werden wir die DriveCell PWM-Bibliothek erkunden.
FlatFlap installieren
Das FlatFlap -Design erleichtert die Installation. Es verfügt über eine abziehbare Kleberückseite und optionale M1.2-Schrauben (im Lieferumfang enthalten) für zusätzliche Sicherheit und sorgt dafür, dass es fest auf jeder Oberfläche haftet, egal ob glatt oder strukturiert. Der Klebstoff ist 3M467, der eine starke Bindung bietet, aber bei Bedarf mit einer Pinzette entfernt werden kann.
Bringen Sie Ihren FlatFlap in Bewegung
Wenn Sie die FlatFlap als eigenständigen Aktuator gekauft haben, können Sie beginnen, indem Sie einen ihrer Pins auf 5 V und den anderen auf Masse ziehen und sie dann umschalten. In einem Fall wird die Klappe abgestoßen, im anderen angezogen. Sie können sie an Ihre eigenen Transistoren oder Ihr H-Brückenmodul anschließen, um diese Pins automatisch umzuschalten. Um es noch einfacher zu machen, können Sie die FlatFlap direkt an unser kleines DriveCell- Modul gelötet kaufen. Die DriveCell ist ein kompakter, Pin-zu-Pin-kompatibler H-Brückentreiber, der die Steuerung von Aktuatoren wie der FlatFlap vereinfacht. Seine Open-Source-Arduino-Softwarebibliothek macht die Aktuatorsteuerung besonders für Anfänger einfach, indem sie unkomplizierte Softwarefunktionen und leicht verständliche Beispiele bietet.
Eine ausführliche Anleitung zur DriveCell- Softwarebibliothek finden Sie in diesem Artikel . Hier ist jedoch eine kurze Zusammenfassung, wie Sie deren Funktionen nutzen können, um die FlatFlap -Betätigung zu verbessern. Keine Sorge, es ist ganz einfach! Laden Sie zunächst die Bibliothek „DriveCell“ aus dem Bibliotheksmanager von Arduino herunter. Nach der Installation können Sie Ihr Gerät steuern. Bevor wir beginnen, stellen Sie sicher, dass Sie die DriveCell an Ihren Mikrocontroller anschließen. Wir empfehlen die Verwendung einer CodeCell, die Pin-zu-Pin-kompatibel ist, alle Bibliotheksfunktionen unterstützt und Ihrem FlatFlap drahtlose Steuerung und interaktive Sensorik hinzufügen kann.
1. Init()
Zuerst benötigen wir einen grundlegenden Setup-Code, damit Sie loslegen können:
#include <DriveCell.h> // This line includes the DriveCell library
DriveCell myFlatFlap(IN1, IN2); // Replace IN1 and IN2 with your specific pins
void setup() {
myFlatFlap.Init(); // Initializes your DriveCell connected to a FlatFlap
}
Dieser Code gibt Ihrer DriveCell den Namen „myFlatFlap“ und weist sie an, alle erforderlichen Peripheriegeräte zu starten und zu initialisieren.
2. Puls (bool Richtung, uint8_t ms_Dauer)
Diese Funktion sendet einen kurzen Stromstoß mit einer bestimmten Polarität an die FlatFlap . Dieses schnelle Ein- und Ausschalten kann je nach Polarität eine kurze, heftige Bewegung der FlatFlap auslösen.
myFlatFlap.Pulse(1, 10); // Sends a short burst for 10 milliseconds in the specified direction
2. Buzz (uint16_t us_buzz)
Diese Funktion lässt die FlatFlap wie einen Summer vibrieren, was nützlich ist, um eine akustische Rückmeldung zu erzeugen.
myFlatFlap.Buzz(100); // Makes the FlatFlap buzz with a 100 microsecond pulses
3. Ton()
Mit der Tone -Funktion kann FlatFlap einen Ton abspielen. Dies kann für akustisches Feedback oder kreative Anwendungen genutzt werden, bei denen Ton Teil der Interaktion ist.
myFlatFlap.Tone(); // Plays a tone by varying the frequency
4. Umschalten (uint8_t power_percent)
Diese Funktion wechselt die FlatFlap -Richtung, was nützlich sein kann, um in Ihrem Code eine schnelle Schlagbewegung zu erzeugen oder die Richtung schnell umzukehren.
myFlatFlap.Toggle(100); // Toggles direction at 100% power
5. Ausführen (bool glatt, uint8_t Leistungsprozentsatz, uint16_t Flip-Geschwindigkeit_ms)
Mit dieser Funktion können Sie die Polarität des FlatFlap kontinuierlich umkehren und seine Bewegungsgeschwindigkeit und -glätte steuern. Wenn smooth auf true gesetzt ist, ist das Flattern weniger scharf und sanfter, was ideal für langsamere, kontrollierte Bewegungen ist.
myFlatFlap.Run(true, 50, 1000); // Runs the FlatFlap smoothly at 50% power, flipping every 1000 milliseconds
6. Antrieb (bool Richtung, uint8_t Leistung_Prozent)
Mit dieser Funktion können Sie die Polarität und Winkelposition der FlatFlap- Klappe durch Anpassen des Leistungspegels steuern und damit grundsätzlich die Stärke des magnetischen Zugs oder Drucks einstellen.
myFlatFlap.Drive(true, 75); // Moves the FlatFlap forward at 75% power
Hier ist ein Beispiel, bei dem wir zwei FlatFlaps konfigurieren und sie mit unterschiedlicher Geschwindigkeit flattern lassen:
#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);
uint16_t flap_counter = 0;
void setup() {
FlatFlap1.Init();
FlatFlap2.Init();
FlatFlap1.Tone();
FlatFlap2.Tone();
}
void loop() {
delay(1);
flap_counter++;
if (flap_counter < 2000U) {
FlatFlap1.Run(0, 100, 100);
FlatFlap2.Run(0, 100, 100);
}
else if (flap_counter < 8000U) {
FlatFlap1.Run(1, 100, 1000);
FlatFlap2.Run(1, 100, 1000);
} else {
flap_counter = 0U;
FlatFlap1.Drive(0, 100);
FlatFlap2.Drive(1, 100);
delay(500);
FlatFlap1.Drive(1, 100);
FlatFlap2.Drive(1, 100);
delay(500);
FlatFlap1.Drive(1, 100);
FlatFlap2.Drive(0, 100);
delay(500);
FlatFlap1.Drive(1, 100);
FlatFlap2.Drive(1, 100);
Verzögerung (500);
FlatFlap1.Laufwerk(0, 100);
FlatFlap2.Drive(0, 100);
Verzögerung (500);
FlatFlap1.Drive(1, 100);
FlatFlap2.Drive(1, 100);
Verzögerung (500);
FlatFlap1.Tone();
FlatFlap2.Tone();
}
}
Kombination mit CodeCell-Sensoren
Um es noch interaktiver zu machen, können Sie FlatFlap und DriveCell mit dem winzigen CodeCell-Sensormodul kombinieren. CodeCell ist Pin-zu-Pin-kompatibel mit DriveCell , unterstützt alle Bibliotheksfunktionen und fügt Ihrem Projekt drahtlose Steuerung und interaktive Sensorik hinzu. Auf diese Weise können Sie mit Ihren FlatFlap- Aktuatoren fortschrittlichere, reaktionsfähigere Elemente erstellen.
Mit diesem nächsten Beispiel steuert die CodeCell zwei FlatFlaps , die aufhören zu flattern, wenn eine Annäherung erkannt wird. Ihr Winkel wird dynamisch angepasst, je nachdem, wie nahe Ihre Hände kommen.
#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 loop() {
if (myCodeCell.Run()) {
/*Runs every 100ms*/
uint16_t proximity = myCodeCell.Light_ProximityRead();
Serial.println(Nähe);
wenn (Nähe < 100) {
FlatFlap1.Run(1, 100, 400);
FlatFlap2.Run(1, 100, 400);
} anders {
Nähe = Nähe - 100;
Nähe = Nähe / 10;
wenn (Nähe > 100) {
Nähe = 100;
}
FlatFlap1.Drive(0, (Nähe));
FlatFlap2.Drive(0, (Nähe));
}
}
}
Passen Sie den Code nach Belieben an, indem Sie ihn mit Ihren eigenen kreativen Ideen optimieren, oder fügen Sie Bewegungssensoren für eine neue Reaktion hinzu! Mit FlatFlap können Sie Ihre kreativen Projekte mit Bewegung in einem schlanken, kompakten Paket zum Leben erwecken. Egal, ob Sie dynamische Elemente zur Kunst hinzufügen, mit Robotik experimentieren oder interaktive mechanische Displays entwickeln, FlatFlap bietet eine vielseitige und benutzerfreundliche Lösung. Beginnen Sie noch heute mit unseren Arduino-Bibliotheken! Wenn Sie weitere Fragen zu FlatFlap haben, schreiben Sie uns einfach eine E-Mail und wir helfen Ihnen gerne weiter!
CoilCell ist eine kompakte Planarspule, die für verschiedene DIY-Projekte entwickelt wurde. Egal, ob Sie gerade erst anfangen oder ein erfahrener Hersteller sind, CoilCell bietet eine einfache Integration, um Ihre Kreationen zu vereinfachen. In diesem Tutorial erklären wir:
Was ist CoilCell?
CoilCell ist eine dünne, planare Spule auf einer mehrschichtigen Leiterplatte mit integriertem Treiber, der die Steuerung der magnetischen Polarität und Stärke vereinfacht. Sie ist in zwei Konfigurationen erhältlich:
Magnetische Anwendungen
Sicherheitstipps
Bei Verwendung der 2,5 W 200-Windungen -Spulenzelle kann es zu einer Erhitzung von bis zu 110 °C kommen, insbesondere in Kombination mit der Eisenrückplatte. Befolgen Sie diese Vorsichtsmaßnahmen:
Wie funktioniert CoilCell?
CoilCell verwendet einen integrierten DRV8837-H-Brückenchip zur Steuerung des Stromflusses durch die Spule, wodurch die magnetische Polarität gewechselt werden kann:
Der DRV8837-Chip verfügt über Überstromschutz, Unterspannungssperre und thermische Abschaltungsfunktionen und gewährleistet so einen sicheren Betrieb.
Erste Schritte mit CoilCell
Wenn Sie einen der Eingangspins mit VCC verbinden, wird die CoilCell sofort eingeschaltet. Um es noch intelligenter zu machen, haben wir auch eine Arduino-Softwarebibliothek entwickelt, die Ihnen den Einstieg erleichtert.
Sie müssen einen einfachen Code schreiben, um CoilCell mitzuteilen, was zu tun ist. Keine Sorge, das ist ganz einfach! Laden Sie zunächst die Bibliothek „CoilCell“ aus dem Bibliotheksmanager von Arduino herunter. Sobald diese installiert ist, können wir Ihr Gerät steuern. Es gibt mehrere Beispiele, die Ihnen den Einstieg erleichtern können, aber als Nächstes werden wir alle Funktionen aufschlüsseln und verstehen:
Bevor wir beginnen, stellen Sie sicher, dass Sie die CoilCell an Ihren Mikrocontroller anschließen. Wir empfehlen die Verwendung einer CodeCell , die Pin-zu-Pin-kompatibel ist, die gleiche Größe hat, alle Bibliotheksfunktionen unterstützt und drahtlose Steuerung und interaktive Sensorik hinzufügen kann.
1. CoilCell initialisieren
#include <CoilCell.h>
CoilCell myCoilCell(IN1, IN2); // Ersetzen Sie IN1 und IN2 durch Ihre spezifischen Pins
void setup() {
myCoilCell.Init(); // Initialisiert die CoilCell
}
Dieser Code konfiguriert die CoilCell und richtet sie basierend auf den von Ihnen ausgewählten Pins und dem Mikrocontroller für die magnetische Steuerung ein.
2. Bounce (bool Richtung, uint8_t ms_Dauer) Die Funktion Bounce() lässt einen Magneten auf und ab hüpfen. Der erste Parameter legt die Polarität der CoilCell fest und delay_ms legt die Dauer fest, für die der Magnet abgestoßen wird./
myCoilCell.Bounce(true, 20); //Bounce the magnet up for 20ms
3. Buzz (uint16_t us_buzz)
Erzeugen Sie ein summendes Geräusch, indem Sie die Polarität der Spule schnell ändern. Passen Sie „us_buzz“ an, um die Frequenz des Summens zu steuern.
myCoilCell.Buzz(80); // Generates a buzzing effect at 80 microseconds intervals
4. Ton()
Diese Funktion spielt einen Standardton ab, indem sie die CoilCell mit verschiedenen gespeicherten Frequenzen vibrieren lässt.
myCoilCell.Tone(); // Plays varying tones
5. Antrieb (bool Richtung, uint8_t Leistung_Prozent)
Mithilfe der CodeCell oder eines anderen ESP32-Mikrocontrollers können Sie mit dieser Funktion die magnetische Polarität und Stärke der Spule steuern. Die magnetische Stärke wird durch „power_percent“ eingestellt, das steuert, wie weit der Magnet von der Spule weggeschoben wird.
myCoilCell.Drive(true, 75); // Drive the coil north with 75% strength
6. Umschalten (uint8_t power_percent)
Durch die Verwendung der CodeCell oder eines anderen ESP32-Mikrocontrollers schaltet diese Funktion die Polarität der Spule bei einem festgelegten Leistungsniveau um, was für einfache magnetische Umklappaktionen nützlich ist.
myCoilCell.Toggle(60); // Toggle polarity at 60% power
Bei anderen Arduino-Geräten bewirkt dieser Befehl, dass die Spulenzelle bei voller Leistung ihre Richtung ändert.
myCoilCell.Toggle(); // Toggle polarity at 100% power
7. Vibrieren (bool glatt, uint8_t Leistung_Prozent, uint16_t vib_Geschwindigkeit_ms)
Diese Funktion kehrt die Polarität der Spule mit einer bestimmten Geschwindigkeit und Leistung um. Wenn Sie „smooth“ auf „true“ setzen, entstehen sanftere Bewegungen, ideal für langsame Frequenzen unter 2 Hz.
myCoilCell.Vibrate(true, 50, 1000); // Smooth vibration at 50% power every 1000 ms
Bei anderen Arduino-Geräten bewirkt dieser Befehl, dass die Spulenzelle bei voller Leistung ihre Polarität umkehrt.
myCoilCell.Vibrate(100); // Vibrate at 100% power every 100 ms
Hier ist ein Beispiel, bei dem wir eine CoilCell initialisieren, um einen Kugelmagneten mit 5 mm Durchmesser hüpfen zu lassen. In diesem Beispiel wird die CoilCell mit den Pins 5 und 6 initialisiert. Die Funktion setup() ruft myCoilCell.Init() auf, um die CoilCell zu konfigurieren. In loop() wird die Funktion Bounce() verwendet, um den Magneten 20 Millisekunden lang nach oben hüpfen zu lassen, gefolgt von einer Verzögerung von 600 Millisekunden, die den Magneten wieder nach unten zieht.
#include <CoilCell.h>
#define IN1_pin1 5
#define IN1_pin2 6
CoilCell myCoilCell(IN1_pin1, IN1_pin2);
void setup() {
myCoilCell.Init(); /*Initialize the CoilCell*/
}
void loop() {
myCoilCell.Bounce(0, 20); /*Bounce the magnet up for 20ms*/
delay(600); /*Attract the magnet back down for 600ms*/
}
Im nächsten Beispiel verwenden wir den Bewegungssensor der CodeCell, um ein Antippen zu erkennen. Wenn ein erneutes Antippen erkannt wird, wechselt die CoilCell ihre magnetische Polarität und stellt eine Verzögerung von 1 Sekunde ein, damit die integrierte LED gelb blinkt.
#include <CodeCell.h> #include <CoilCell.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); /*Initialisiere die Tipperkennung*/ meineCoilCell.Init(); meineCoilCell.Tone(); } void schleife() { wenn (myCodeCell.Run()) { /*Läuft alle 100 ms*/ wenn (myCodeCell.Motion_TapRead()) { /*Wenn ein Antippen erkannt wird, leuchtet die LED 1 Sekunde lang gelb und die Polarität der CoilCell wird umgekehrt*/ myCodeCell.LED(0XA0, 0x60, 0x00U); meineCoilCell.Toggle(100); Verzögerung (1000); } } }
Mit diesen Grundfunktionen können Sie mit CoilCell in Ihren Projekten experimentieren. Egal, ob Sie Magnete steuern, interaktive Displays erstellen oder mit magnetischen Kräften experimentieren, CoilCell bietet eine einfache und effektive Lösung.
Wenn Sie weitere Fragen zur CoilCell haben, senden Sie uns einfach eine E-Mail und wir helfen Ihnen gerne weiter!
DriveCell ist ein kleines, aber leistungsstarkes Gerät, mit dem Sie Motoren, Aktuatoren und Hochleistungs-LED-Leuchten für Ihre Heimwerkerprojekte ganz einfach steuern können. DriveCell macht die Steuerung dieser Komponenten einfach, selbst wenn Sie keine Erfahrung mit Programmierung oder Elektronik haben.
In diesem Tutorial erklären wir:
Was ist DriveCell?
Stellen Sie sich vor, Sie möchten einen kleinen Roboter bauen und die Geschwindigkeit und Richtung seines Motors steuern. Dies kann für Anfänger komplex sein und erfordert normalerweise sperrige Module. DriveCell vereinfacht diesen Prozess, weil:
Wie funktioniert DriveCell?
DriveCell verwendet einen integrierten DRV8837-H-Brückenchip zur Steuerung des Stromflusses durch die Ausgangspins, der durch den Zustand der Eingangspins gesteuert wird:
Der DRV8837-Chip verfügt über Überstromschutz, Unterspannungssperre und thermische Abschaltungsfunktionen und gewährleistet so einen sicheren Betrieb.
Erste Schritte mit DriveCell
Bevor Sie DriveCell verwenden können, müssen Sie es einrichten und mit Ihrem Projekt verbinden. Hier ist eine einfache Anleitung für den Einstieg:
1. Init()
Zuerst benötigen wir einen grundlegenden Setup-Code, damit Sie loslegen können:
#include <DriveCell.h> // This line includes the DriveCell library
DriveCell myDriveCell(IN1, IN2); // Replace IN1 and IN2 with your specific pins
void setup() {
myDriveCell.Init(); // Initializes the DriveCell
}
Dieser Code weist die DriveCell an, zu starten und sich für die Steuerung Ihres Motors oder Aktuators vorzubereiten. Die Init-Funktion stellt sicher, dass alle erforderlichen Peripheriegeräte konfiguriert sind.
2. Puls (bool Richtung, uint8_t ms_Dauer)
Dieser Befehl sendet einen kurzen Stromstoß mit einer bestimmten Polarität, um den Aktuator schnell mit Strom zu versorgen und wieder auszuschalten.
myDriveCell.Pulse(true, 10); // Short burst for 10 milliseconds
3. Buzz (uint16_t us_buzz)
Dadurch vibriert der Aktuator wie ein Summer. Dies eignet sich hervorragend zum Erzeugen von Feedback-Tönen.
myDriveCell.Buzz(100); // Creates a 100us buzzing sound
4. Ton()
Diese Funktion spielt einen Standardton ab, indem sie den Aktuator mit verschiedenen gespeicherten Frequenzen vibrieren lässt.
myDriveCell.Tone(); // Plays varying tones
5. Umschalten (uint8_t power_percent)
Diese Funktion schaltet einfach die Richtung bei voller Leistung von 100 % um, was nützlich sein kann, um die Drehrichtung eines Bürstenmotors umzukehren oder einfache Schlagbewegungen zu erzeugen.
myDriveCell.Toggle(); // Switches direction
Mithilfe der CodeCell oder eines anderen ESP32-Mikrocontrollers können Sie auch den Arbeitszyklus „power_percent“ anpassen. Bei magnetischen Aktuatoren steuert „power_percent“ die magnetische Stärke, während es bei Bürstenmotoren die Geschwindigkeit anpasst.
6. Ausführen (bool glatt, uint8_t Leistungsprozentsatz, uint16_t Flip-Geschwindigkeit_ms)
Mithilfe der CodeCell oder eines anderen ESP32-Mikrocontrollers können Sie mit dieser Funktion alle „flip_speed_ms“ die Polarität eines Aktuators umkehren oder einen Motor umkehren, und zwar im Arbeitszyklus „power_percent“. Wenn Sie „smooth“ auf 1 setzen, wird die Bewegung geglättet, was ideal ist, wenn Sie FlatFlap oder CoilPad mit langsamen Bewegungen (weniger als 2 Hz) antreiben.
myDriveCell.Run(true, 50, 1000); // Smooth drive at 50% power every 1000 ms
Bei anderen Arduino-Geräten bewirkt dieser Befehl, dass der Motor/Aktuator seine Richtung (vorwärts und rückwärts) bei voller Geschwindigkeit ändert. Beispiel:
myDriveCell.Run(500); // Motor changes direction every 500 milliseconds
7. Antrieb (bool Richtung, uint8_t Leistung_Prozent)
Mithilfe der CodeCell oder eines anderen ESP32-Mikrocontrollers können Sie mit dieser Funktion die Geschwindigkeit und Richtung Ihres Motors steuern. Sie können den Motor vorwärts oder rückwärts laufen lassen und die Geschwindigkeit einstellen.
myDriveCell.Drive(true, 75); // Moves forward at 75% power
Beispiele:
Indem Sie eine dieser Funktionen in einer Schleife verwenden, können Sie die gewünschte Sequenz für Ihren Motor, Aktuator oder Ihre Hochleistungs-LEDs erstellen. Hier ist ein Beispiel, in dem wir zwei Gleichstrommotoren initialisieren und sie mit unterschiedlichen Geschwindigkeiten antreiben:
#include <DriveCell.h>
#define IN1_pin1 2
#define IN1_pin2 3
#define IN2_pin1 5
#define IN2_pin2 6
DriveCell Motor1(IN1_pin1, IN1_pin2);
DriveCell Motor2(IN2_pin1, IN2_pin2);
uint8_t mode = 0;
uint8_t speed_percentage = 0;
void setup() {
Motor1.Init();
Motor2.Init();
speed_percentage = 80; /* Motor auf 80 % Leistung einstellen */
}
void schleife() {
Verzögerung (3000);
Modus++;
Schalter (Modus) {
Fall 1:
/* Vorwärts gehen */
Motor1.Antrieb(1, Geschwindigkeitsprozentsatz);
Motor2.Drive(1, Geschwindigkeitsprozentsatz);
brechen;
Fall 2:
/* Rückwärts bewegen */
Motor1.Drive(0, Geschwindigkeitsprozentsatz);
Motor2.Drive(0, Geschwindigkeitsprozentsatz);
brechen;
Fall 3:
/* Biegen Sie links ab */
Motor1.Antrieb(1, Geschwindigkeitsprozentsatz);
Motor2.Drive(0, Geschwindigkeitsprozentsatz);
brechen;
Fall 4:
/* Biegen Sie rechts ab */
Motor1.Drive(0, Geschwindigkeitsprozentsatz);
Motor2.Drive(1, Geschwindigkeitsprozentsatz);
brechen;
Fall 5:
/* Schalte beide Motoren aus */
Motor1.Antrieb(1, 0);
Motor2.Antrieb(1, 0);
wenn (Geschwindigkeitsprozentsatz < 95) {
speed_percentage += 5; /* Geschwindigkeit erhöhen */
} anders {
speed_percentage = 50; /* Auf 50 % Leistung zurücksetzen */
}
Modus = 0;
brechen;
}
}
Im nächsten Beispiel verwenden wir den Näherungssensor von CodeCell , um die Motoren zu aktivieren. Dieser Sensor fungiert als Gestenschalter und wird aktiviert, wenn sich eine Hand im Umkreis von 5 cm befindet.
#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);
uint8_t speed_percentage = 0;
bool on_flag = 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(LIGHT); /*Initializes Light Sensing*/
Motor1.Init();
Motor2.Init();
speed_percentage = 100;
}
void loop() {
if (myCodeCell.Run()) {
/*Runs every 100ms - Put your code here*/
if (myCodeCell.Light_ProximityRead() > 3000) {
/*Wenn ein Tippen erkannt wird, leuchtet die LED 1 Sekunde lang gelb*/
myCodeCell.LED(0XA0, 0x60, 0x00U);
Motor1.Antrieb(0, 0);
Motor2.Antrieb(0, 0);
Verzögerung (1000);
ein_Flagge = !ein_Flagge;
}
wenn (on_flag) {
/*Vorwärts gehen*/
Motor1.Antrieb(1, Geschwindigkeitsprozentsatz);
Motor2.Drive(1, Geschwindigkeitsprozentsatz);
} anders {
Motor1.Antrieb(0, 0);
Motor2.Antrieb(0, 0);
}
}
}
Wenn Sie weitere Fragen zur DriveCell haben, senden Sie uns einfach eine E-Mail und wir helfen Ihnen gerne weiter!
Der FlatFlap ist ein unglaublich dünner und innovativer Aktuator, der in einem kompakten Formfaktor Bewegung in Ihre Projekte bringt. Um zu verstehen, wie er funktioniert, tauchen wir in das einzigartige Design und die Prinzipien hinter seiner Funktionsweise ein.
Die Struktur
Die FlatFlap besteht aus einer flexiblen Leiterplatte und Aluminiumversteifungen. Diese Komponenten werden sorgfältig zusammengefaltet, um den Aktuator zu bilden.
Die flexible Leiterplatte dient als Grundlage des Aktuators. Im Gegensatz zu starren Leiterplatten kann sich die flexible Version biegen und verdrehen, ohne zu brechen, was für die Erzeugung der Schlagbewegung unerlässlich ist. Die Flexibilität der Leiterplatte ermöglicht es der FlatFlap, sich frei zu bewegen und gleichzeitig ihre strukturelle Integrität beizubehalten.
Die Aluminiumversteifungen bieten die nötige Stabilität, um den Magneten zu halten, der die Schlagbewegung steuert, und stellen sicher, dass die Bewegung sowohl präzise als auch gleichmäßig ist.
Das magnetische System
Die FlatFlap wird von einem intelligenten Magnetsystem angetrieben, das elektrische Energie in mechanische Bewegung umwandelt. Dieses System besteht aus einem Magneten auf der Rückseite des Aktuators und einer planaren Kupferspule, die in die flexible Leiterplatte eingebettet ist.
An der Rückseite des FlatFlap ist ein 10 mm N52 Neodym-Magnet angebracht. Dieser Magnet spielt eine entscheidende Rolle bei der Funktion des Aktuators, da er mit dem von der Kupferspule erzeugten Magnetfeld interagiert. Diese Spule befindet sich innerhalb der flexiblen Leiterplatte und ist für die Erzeugung des Magnetfelds verantwortlich, wenn ein elektrischer Strom durch sie hindurchfließt. Die Schlagbewegung wird dadurch erreicht, dass der Strom in verschiedene Richtungen durch die Kupferspule pulsiert.
Je nach Stromrichtung interagiert dieses Magnetfeld mit dem Magneten auf der Rückseite der FlatFlap. Durch Änderung der Stromrichtung kann das Magnetfeld den Magneten entweder anziehen oder abstoßen, wodurch sich die Klappe bewegt. Die Spannung kann auch über PWM variiert werden, um den Abstand der Spule zum Magneten zu steuern.
Durch schnelles Pulsieren des Stroms in verschiedene Richtungen, wodurch eine Rechteckwelle entsteht, kann die FlatFlap eine kontinuierliche Schlagbewegung erzeugen. Die Geschwindigkeit und Frequenz dieser Bewegung können durch Anpassen der Pulsrate des Stroms gesteuert werden. In der optimalen Konfiguration kann die FlatFlap eine Geschwindigkeit von bis zu 25 Hz erreichen und so eine schnelle und reaktionsschnelle Bewegung erzeugen.
Einfache Befestigung und sichere Installation
Dank der abziehbaren Kleberückseite und optionalen Schrauben ist die Installation des FlatFlap ein Kinderspiel. Der Kleber sorgt für eine starke Verbindung, die den Aktuator sicher an Ort und Stelle hält, während die Schrauben bei Bedarf eine zusätzliche Sicherheitsebene bieten. Diese doppelte Installationsmethode gewährleistet einwandfreie Haftung, egal ob Sie den FlatFlap an einer glatten oder einer strukturierteren Oberfläche anbringen.
Ultradünnes und kompaktes Design
Eines der herausragenden Merkmale der FlatFlap ist ihr unglaublich schlankes Profil. Mit einer nur 0,3 mm dünnen Klappe und einem nur 2,6 mm großen Aktuator lässt sich dieses schlanke Design nahtlos in jede flache Oberfläche integrieren. Sein niedriges Profil stellt sicher, dass es die Ästhetik Ihres Projekts nicht beeinträchtigt, und macht es ideal für Anwendungen mit begrenztem Platzangebot.
FlatFlap eignet sich perfekt für eine Vielzahl von Anwendungen. Es eignet sich besonders gut zum Erstellen kinetischer Skulpturen und zum Experimentieren mit Robotik. Seine Fähigkeit, leichten Objekten wie dünnem 3D-gedrucktem Kunststoff oder Origami-Papier auffällige Bewegung zu verleihen, eröffnet eine Welt kreativer Möglichkeiten.
Ein PCB-Motor ist eine innovative Lösung, die die Mechanik des Motors in die elektronischen Komponenten integriert und dabei die PCB selbst als Struktur des Motors nutzt.
Was ist ein PCB-Motor?
Ein PCB-Motor ist ein einzigartiger Motortyp, der die Kupferspuren auf einer Leiterplatte (PCB) nutzt, um ein Magnetfeld zu erzeugen, das den Motor antreibt. Dieses Konzept ist davon inspiriert, wie Funksysteme PCB-Spuren als Antennen verwenden. Dasselbe Prinzip wird angewendet, um ein Magnetfeld zu erzeugen, das stark genug ist, um einen Rotor zu drehen. Dieser Motortyp ist als bürstenloser Axialflussmotor bekannt, bei dem der PCB-Stator und der Rotor parallel ausgerichtet sind.
Entwurf und Aufbau eines PCB-Motors
Der erste Schritt bei der Entwicklung eines PCB-Motors ist die Entwicklung der PCB-Statorspulen. Bei herkömmlichen Motoren bestehen diese Spulen häufig aus Draht, der zu dichten, dreidimensionalen Formen gewickelt ist. Bei einem PCB-Motor werden die Spulen stattdessen als flache Spiralbahnen hergestellt, die auf die Schichten einer PCB gedruckt werden.
Eine der Herausforderungen dieser Planarmotoren besteht darin, genügend Windungen in den kleinen verfügbaren Raum zu bringen, um einen ausreichenden magnetischen Fluss zu erzeugen. Diese Spulen müssen in einer Stern- oder Dreieckkonfiguration verbunden werden, um ein dreiphasiges System zu erzeugen. In unserem 6-schlitzigen, sternkonfigurierten MotorCell- Design konnten wir die Spulen auf vier Schichten stapeln und zwei zusätzliche Schichten für den Controller nutzen, um das erforderliche Magnetfeld zum Drehen des Rotors zu erzeugen.
Im Laufe der Jahre haben wir auch gelernt, dass das Design des Rotors entscheidend für die Verbesserung der Motoreffizienz ist. Es ist wichtig, hochwertige Keramikkugellager zu verwenden und die Lager präzise auszurichten, um die optimale mechanische Lösung zu erreichen. Dies erfordert normalerweise Spezialwerkzeuge, daher bieten wir den Rotor der MotorCell auch einzeln an, sodass Sie ihn problemlos in Ihre benutzerdefinierte Leiterplatte integrieren können.
Synchronisierung im PCB-Motor erreichen
Einer der wichtigsten Aspekte beim Antrieb eines bürstenlosen Motors ist die Sicherstellung, dass der Rotor mit dem elektromagnetischen Feld des Stators synchronisiert bleibt. Bei herkömmlichen Motoren mit Bürsten wird die Synchronisation mechanisch durch die Bürsten selbst gesteuert. Bei einem dreiphasigen bürstenlosen Motor wie einem PCB-Motor ist jedoch eine sensorische Rückmeldung erforderlich, damit der Motor reibungslos läuft.
Die Gegen-EMK wird normalerweise als Rückkopplung verwendet, um die Motordrehzahl zu steuern. Die Gegen-EMK ist die Spannung, die vom rotierenden Motor selbst erzeugt wird und die gemessen werden kann, um die Rotordrehzahl zu bestimmen. Diese Informationen werden dann in die Steuerelektronik des Motors eingespeist und stellen sicher, dass die Statorspulen synchron mit der Rotorbewegung angetrieben werden. Bei der MotorCell wird all dies direkt vom integrierten Chip gehandhabt, was den Prozess vereinfacht.
Erfahren Sie als Erster von neuen Projekten und sichern Sie sich spannende Angebote!
