MotorCell ist ein ultrakompakter, wellenloser PCB-Motor, der für Anwendungen mit hoher Geschwindigkeit und niedrigem Drehmoment entwickelt wurde. Mit seinem innovativen Pfannkuchendesign und den planaren PCB-Wicklungen ist MotorCell perfekt für Robotik, Kunstinstallationen und Heimwerkerprojekte geeignet. Dieser Motor vereinfacht die Integration durch sensorlose Steuerung mit PWM-Geschwindigkeitsanpassungen.
In diesem Tutorial behandeln wir:
Was ist MotorCell?
Die MotorCell erfindet das Motordesign neu, indem Rotor, Stator und Treiber in einer einzigen flachen Leiterplatte integriert werden. Diese einzigartige Struktur:
MotorCell ist ideal für Anwendungen, die kleine, leichte und kompakte Motoren erfordern, wie etwa kleine Roboter, kinetische Kunst oder sogar tragbare Geräte.
Einrichten Ihres Motors
Führen Sie zunächst die folgenden Schritte aus:
Pins:
Öffnen Sie die Arduino IDE, gehen Sie zu Sketch > Include Library > Manage Libraries , suchen Sie nach „MotorCell“ und installieren Sie es. Fügen Sie es dann in Ihren Code ein und richten Sie Ihre Pins ein:
#include "MotorCell.h"
#define IN_PIN 2
#define OUT_PIN 3
#define FR_PIN 1
MotorCell myMotorCell(IN_PIN, OUT_PIN, FR_PIN);
void setup() {
myMotorCell.Init(); // Initialize the MotorCell
}
Funktionen der MotorCell-Bibliothek
Hier sind die Kernfunktionen der MotorCell-Bibliothek:
myMotorCell.Init(); uint16_t rpm = myMotorCell.Spin(50); // Spin at 50% speed
uint16_t rpm = myMotorCell.SpinPID(12000); // Maintain 12,000 RPM
myMotorCell.ReverseSpin();
Pulse(uint8_t p_pin, uint8_t ms_duration): Sendet einen kurzen Impuls für eine bestimmte Dauer (in Millisekunden) an den angegebenen Pin. Nützlich für schnelle Bewegungsausbrüche oder kurzzeitige Signale.
myMotorCell.Pulse(FR_PIN, 50); // Sends a 50ms pulse to the FR_PIN
uint16_t currentRPM = myMotorCell.RPMRead();
myMotorCell.MaxSpin();
Beispielprojekt: Drehzahlüberwachung
Hier ist ein einfaches Projekt für den Einstieg:
#include "MotorCell.h"
#define IN_PIN 2
#define OUT_PIN 3
#define FR_PIN 4
MotorCell myMotorCell(IN_PIN, OUT_PIN, FR_PIN);
void setup() {
Serial.begin(115200);
myMotorCell.Init();
}
void loop() {
uint16_t rpm = myMotorCell.Spin(50); // Spin at 50% speed
}
Weitere Beispiele sind auf GitHub verfügbar. Wenn Sie jedoch Fragen zu MotorCell haben, können Sie sich gerne an uns wenden !
Wenn Sie gerade die CodeCell in die Hände bekommen haben, erwartet Sie ein echter Leckerbissen. Dieses winzige Modul vereinfacht Ihre DIY-Projekte mit zahlreichen Funktionen auf einer winzigen Platine. In dieser Anleitung führen wir Sie durch :
CodeCell ist ein kompaktes und vielseitiges Modul mit dem ESP32-C3, verschiedenen Stromversorgungsoptionen und integrierten Sensoren – und das alles in einem winzigen, nur 1,85 cm breiten Formfaktor. 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 .
ESP32C3-Modul
Das Herzstück der CodeCell ist das ESP32C3-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. Diese Integration bietet die gängigsten Konnektivitätsoptionen bei gleichzeitig geringem Formfaktor.
Die PCB-Antenne des ESP32C3-Moduls ist seitlich, abseits von anderen Komponenten, positioniert, um Störungen zu minimieren und Signalübertragung und -empfang 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. Die Komponenten auf der Unterseite befinden sich innerhalb des empfohlenen Abstands zur Antenne. Tests haben gezeigt, dass die Leistung der Antenne durch die minimalen Störungen eines USB-C-Kabels unbeeinflusst bleibt, da diese Kabel typischerweise abgeschirmt sind.
Der ESP32-C3 bietet mit 4 MB Flash und 400 KB SRAM ausreichend Speicher und ist damit für die meisten gängigen Anwendungen geeignet. Sein 32-Bit-RISC-V-Single-Core-Prozessor mit bis zu 160 MHz bewältigt 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 neu flashen und serielle Daten zur Kommunikation und zum Debuggen senden können.
Energieverwaltung
Die CodeCell bietet flexible Stromversorgungsoptionen. Sie kann über den LiPo-Akkuanschluss, 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 dient sowohl der Stromversorgung als auch der Neuprogrammierung des Geräts. Diese Multi-Power-Option wird durch den Batteriemanagement-Chip BQ24232 ermöglicht. Dieser verfügt über dynamisches Power-Path-Management (DPPM), das das System mit Strom versorgt und gleichzeitig den Akku unabhängig lädt. Der Ladevorgang erfolgt in drei Phasen: Konditionierungsvorladung, Konstantstrom und Konstantspannung. Zum Schutz des Akkus wird die Ausgangsspannung (Vo) durch den BQ24232-Chip geregelt. Dieser Ausgang unterstützt einen maximalen Ausgangsstrom von 1500 mA bei Versorgung über den LiPo-Akku und 450 mA bei Versorgung über USB.
Der Ladestrom des LiPo-Akkus ist standardmäßig auf 90 mA eingestellt, was eine ausgewogene und sichere Laderate für den optionalen 170-mAh-LiPo-Akku gewährleistet. Um die Laderate anzupassen, muss der 0402-Widerstand R12 abgelötet und durch einen neuen Widerstand nach der Formel (R = 870/Ichrg) ersetzt werden. Dies ist nur für Lötprofis zu empfehlen, die sich nicht vor dem Umgang mit winzigen 0402-Bauteilen scheuen! 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 geben:
Die Leistungsregelung wird zusätzlich durch mehrere Entkopplungskondensatoren unterstützt, darunter bis zu zwei Bulk-Kondensatoren mit je 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), die andere die Ausgangsspannung (Vo). Diese TVS-Dioden bieten Schutz vor elektrostatischen Entladungen (ESD) und können wiederholte ESD-Störungen über dem in der internationalen Norm IEC 61000-4-2 festgelegten Höchstwert sicher und ohne Leistungseinbußen absorbieren.
Die Platine verfügt außerdem über einen integrierten 3,3-V-Low-Dropout-Regler (LDO), der eine stabile Stromversorgung der Niederspannungskomponenten gewährleistet. Dieser winzige NCP177-LDO-Chip kann einen Ausgangsstrom von bis zu 500 mA mit einer typischerweise niedrigen Dropout-Spannung von 200 mV bei 500 mA ausgeben.
GPIO- und Stromanschlüsse
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-Bereiche unterteilt haben. Zusätzlich haben wir Stromanschlüsse an den Modulrändern angebracht, um den Anschluss an verschiedene Stromquellen zu erleichtern. So können Sie weitere Module, Sensoren und Aktoren an verschiedenen Seiten anschließen.
Auf der Unterseite werden drei von fünf Pins für die Stromversorgung verwendet: ein Masse-Pin (GD), ein 3,3-V-Logikpegel-Stromversorgungs-Pin (3V3) und ein 5-V-Ladeeingangs-Pin (5V0). Dieser 5V0-Pin ist mit der USB-Eingangsspannung verbunden. Das bedeutet, dass Sie ihn nutzen können, um 5 V Strom zu beziehen, wenn USB angeschlossen ist, oder ihn als Stromeingang zum Laden anstelle von USB verwenden können. Die anderen beiden Pins sind die I2C-SDA- und SCL-Pins zum Anschluss externer digitaler Sensoren. Wenn Sie keine externen Sensoren und keine Licht-/Bewegungssensoren verwenden, können diese I2C-Pins als GPIOs eingerichtet werden.
Die anderen beiden Seiten verfügen jeweils über einen Masseanschluss (GD) und einen Spannungsausgangsanschluss (VO). Jede Seite verfügt außerdem über drei programmierbare GPIO-Anschlüsse (IO1, IO2, IO3, IO5, IO6, IO7), die alle als PWM-Anschlüsse 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-Anschlüsse verwendet werden.
Die ADC-Pins unterstützen Spannungen bis zu 3,3 V. Die Referenzspannung des ADC ist standardmäßig auf 2,5 V eingestellt. Dies kann nicht geändert werden.
Sensorfunktionen
Zu den herausragenden Merkmalen der CodeCell gehören die integrierten Sensoren. Jede Einheit ist mit einem integrierten Lichtsensor ausgestattet. Optional ist ein Bewegungssensor erhältlich, der die Bewegungserkennung Ihres Projekts verbessert – besonders nützlich für Robotik 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. Dadurch benötigt die CodeCell keine dedizierten RST- oder BOOT-Tasten, was uns ermöglichte, sie so klein zu gestalten.
Sollte Ihre CodeCell einfrieren oder eine Ausnahme auftreten (was zu einem ständigen Reset führt), können Sie sie manuell in den Boot-Modus zwingen, um die Firmware neu zu flashen. Gehen Sie dazu folgendermaßen vor:
Wenn Sie diese Schritte befolgen, wird Ihre CodeCell wieder zum Leben erweckt.
Um die Programmierung noch einfacher zu machen, CodeCell Die Bibliothek bietet umfangreiche Funktionen zum Initialisieren, Lesen und Verwalten von Sensoren und Stromversorgung. In diesem Abschnitt erklären wir Ihnen alles, was Sie zur Einrichtung Ihres Geräts und seiner Bibliothek wissen müssen.
Auspacken Ihrer CodeCell
Beginnen wir mit dem Inhalt der Box. 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 Anschließen 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 eingerichtet ist, können wir nun die Bibliothek „CodeCell“ installieren. 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 ständig 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“. Dort finden Sie zahlreiche Beispiele, die Sie für Ihre Projekte verwenden und anpassen können. Wir empfehlen, mit dem Beispiel „Erste Schritte“ zu beginnen. Es enthält nur wenige Codezeilen, erklärt aber alle Sensorfunktionen von CodeCell .
Nachdem Sie eine Beispielskizze ausgewählt haben, klicken Sie auf „Hochladen“, um den Code auf Ihre CodeCell zu übertragen. Öffnen Sie nach dem Hochladen den seriellen Monitor unter „Tools > Serieller Monitor“, um die seriellen Daten 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 Verwendung des CodeCell besteht darin, es zu initialisieren. Dies geschieht mit der Funktion `myCodeCell.Init()`, mit der Sie die zu aktivierenden Sensoren angeben können.
Verfügbare Sensormakros:
Sie können mehrere Makros mit dem Operator „+“ kombinieren, um mehrere Sensoren gleichzeitig zu initialisieren.
Energiemanagement
Rufen Sie die Funktion myCodeCell.Run(frequency) in loop() auf, um den Energiestatus zu verwalten. Diese Funktion verwaltet auch die integrierte LED zur Anzeige des Energiestatus.
Verhalten der Funktion Run():
Während des Ladevorgangs beendet die CodeCell die Anwendung, lässt die LED blau leuchten und wartet, bis der Akku vollständig geladen ist. Sobald der Akku vollständig geladen ist, leuchtet die LED grün. Sobald das Kabel getrennt wird, beginnt eine grüne Lichtanimation mit einer Geschwindigkeit, die der Entfernung entspricht. Die Animation leuchtet grün, wenn der Akku mit Strom versorgt wird, und blau, wenn er über USB mit Strom versorgt wird.
Sensordaten lesen
Nach der Initialisierung der Sensoren können Sie deren Daten mithilfe verschiedener Funktionen der Bibliothek auslesen. Hier ist ein kurzer Überblick über die verfügbaren Funktionen:
Lichtsensorfunktionen:
Bewegungssensorfunktionen:
Anwendungsbeispiel:
Schlaf-, Energiespar-, Diagnose- und LED-Funktionen
Die CodeCell umfasst mehrere Funktionen zur Verwaltung des Ruhe- und Energiesparmodus:
Sie haben nun 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!
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!