FlatFlap ist ein kompakter Klappenantrieb. In dieser Anleitung konzentrieren wir uns jedoch auf die Positionsregelung – das Halten der Klappe in einer festen Position mithilfe eines kontrollierten Arbeitszyklus. Diese Methode eignet sich für Anwendungen, bei denen die Klappe über längere Zeit in einem bestimmten Winkel verharren muss, anstatt kontinuierlich zu schwingen.
FlatFlap funktioniert, indem Strom durch die Spule geleitet wird, wodurch ein Magnetfeld erzeugt wird, das mit dem Magneten interagiert. Anstatt einen kurzen Impuls zu erzeugen oder die Rechteckwelle zu schwingen, verwenden wir hier Pulsweitenmodulation (PWM), um die Klappe im gewünschten Winkel zu halten.
Der Arbeitszyklus des PWM-Signals steuert die Stärke des Magnetfelds und verändert so den Winkel der Klappe.
Mehrere Faktoren beeinflussen die Positionsgenauigkeit und -stabilität:
Wenn Sie die DriveCell-Bibliothek. Das folgende Beispiel zeigt, wie verschiedene Positionen eingestellt werden:
#include <drivecell.h>
#define IN1_pin1 2
#define IN1_pin2 3
DriveCell FlatFlap1(IN1_pin1, IN1_pin2);
void setup() {
FlatFlap1.Init();
}
void loop() {
FlatFlap1.Drive(true, 100); // Maximum hold strength
delay(3000);
FlatFlap1.Drive(true, 75); // Hold with 75% power
delay(3000);
FlatFlap1.Drive(true, 50); // Hold with 50% power
delay(3000);
FlatFlap1.Drive(true, 25); // Hold with 25% power
delay(3000);
}
Dieser Code passt den Arbeitszyklus schrittweise an, um die Klappe in verschiedenen Positionen zu halten.
Die Funktionen verstehen:
Init() → Initialisiert DriveCell und richtet die Eingangspins einDrive(bool direction, uint8_t power_percent)
true (Norden) / false (Süden)⚠ Hinweis: Die Drive()-Funktion verwendet einen Hochgeschwindigkeits-PWM-Timer und ist daher nur mit CodeCell- und ESP32-basierten Geräten kompatibel.
Wenn Sie kein ESP32-Gerät verwenden, können Sie PWM in Arduino mit dem folgenden Code anpassen. Stellen Sie jedoch sicher, dass die Wellenformfrequenz korrekt eingestellt ist.
#define FLAP_PIN1 2
#define FLAP_PIN2 3
void setup() {
pinMode(FLAP_PIN1, OUTPUT);
pinMode(FLAP_PIN2, OUTPUT);
digitalWrite(FLAP_PIN2, LOW);
}
void loop() {
analogWrite(FLAP_PIN1, 191); // 75% Duty Cycle (191/255)
digitalWrite(FLAP_PIN2, LOW);
delay(5000); // Hold for 5 seconds
analogWrite(FLAP_PIN1, 127); // 50% Duty Cycle
delay(5000);
analogWrite(FLAP_PIN1, 63); // 25 % Arbeitszyklus
Verzögerung (5000);
}
Durch PWM kann die FlatFlap bestimmte Winkel über lange Zeiträume halten, was diese Funktion für Robotik, Haptik und Kunst nützlich macht. Weitere Codebeispiele und technische Dokumentation finden Sie im DriveCell GitHub Repository !
FlatFlap ist ein kompakter Aktuator, der organische, flatternde Bewegungen erzeugen kann. Diese Anleitung konzentriert sich jedoch auf die Erzeugung eines kurzen Impulses – eines einzelnen Flatterns, das nur wenige Millisekunden dauert und dann stoppt. Diese Methode eignet sich für schnelle Betätigungen und Anwendungen, bei denen kurze Bewegungen erforderlich sind.
Um Bewegung zu erzeugen, benötigt FlatFlap einen elektrischen Strom, der durch die Spule fließt und ein Magnetfeld erzeugt. Durch einen kurzen Impuls induzieren wir ein schnelles Magnetfeld, das den Magneten augenblicklich abstößt.
Um manuell einen Impuls zu erzeugen, können Sie grundlegende DigitalWrite-Befehle verwenden:
#define FLAP_PIN1 2
#define FLAP_PIN2 3
void setup() {
pinMode(FLAP_PIN1, OUTPUT);
pinMode(FLAP_PIN2, OUTPUT);
}
void loop() {
digitalWrite(FLAP_PIN1, HIGH);
digitalWrite(FLAP_PIN2, LOW);
delay(500); // Pulse duration in milliseconds
digitalWrite(FLAP_PIN1, LOW);
digitalWrite(FLAP_PIN2, LOW); // Stop motion
delay(3000); // Stop for 3 sec
}
Dieser einfache Code sendet einen 500-Millisekunden-Impuls an FlatFlap, der eine kurze Bewegung auslöst, bevor er stoppt.
Anstelle eines abrupten Ein-/Aus-Impulses kann die Intensität durch PWM (Pulsweitenmodulation) schrittweise gesteuert werden, wodurch die mechanische Belastung reduziert und die Leistung verbessert wird. Dies wird in DriveCell automatisch geregelt:
#include <drivecell.h>
#define IN1_pin1 2
#define IN1_pin2 3
DriveCell FlatFlap1(IN1_pin1, IN1_pin2);
void setup() {
FlatFlap1.Init();
}
void loop() {
FlatFlap1.Pulse(true, 10); // Pulse forward for 10ms
delay(500); // Wait before the next pulse
}
Wenn Sie unsere DriveCell-Bibliothek verwenden, können Sie dies direkt mit der Pulse-Funktion implementieren:
#include <drivecell.h>
#define IN1_pin1 2
#define IN1_pin2 3
DriveCell FlatFlap1(IN1_pin1, IN1_pin2);
void setup() {
FlatFlap1.Init();
}
void loop() {
FlatFlap1.Pulse(true, 100); // Pulse for 100ms
delay(3000); // Wait before the next pulse
FlatFlap1.Pulse(true, 1000); // Pulse for 1000ms
delay(3000); // Wait before the next pulse
FlatFlap1.Pulse(true, 500); // Pulse for 500ms
delay(3000); // Warten vor dem nächsten Impuls
}
Die Funktion verstehen:
Pulse(bool direction, uint8_t ms_duration)
Richtung : true (Norden) / false (Süden)
ms_duration : Dauer des Impulses in Millisekunden
Mit kurzen Impulsen können Sie FlatFlap für Anwendungen mit schneller Betätigung steuern. Weitere Codebeispiele und technische Dokumentation finden Sie im DriveCell GitHub Repository !
In dieser Anleitung wird erklärt, wie die FlatFlap ihre Schlagbewegung steuern kann, wie Frequenz und Polarität ihre Bewegung beeinflussen und wie ihre Antriebssignale erzeugt werden.
Um die FlatFlap zu bewegen, wird ein elektrischer Strom an die Spule angelegt, wodurch ein Magnetfeld erzeugt wird. Durch Umkehren der Polarität mit einer festgelegten Frequenz erzeugen wir eine wiederholte Gegentaktbewegung, die die Klappe zum Schwingen bringt.
Die Schlagfrequenz lässt sich im Bereich von 1 Hz bis 25 Hz steuern. Das bedeutet, dass FlatFlap je nach Eingangssignal 1 bis 25 Mal pro Sekunde schlagen kann. Höhere Frequenzen sind möglich, aber der Magnet hat in der Regel nicht genügend Zeit, um zu reagieren.
A Für die FlatFlap-Klappe wird ein Rechtecksignal benötigt. Ein H-Brücken-Treiber wie unsere DriveCell wird benötigt, um den Aktuator mit Strom zu versorgen und seine Polarität umzuschalten. Die Eingangssignale der Rechteckwelle können mit einem einfachen digitalWrite()- Befehl in Arduino erzeugt werden:
#define FLAP_PIN1 2
#define FLAP_PIN2 3
void setup() {
pinMode(FLAP_PIN1, OUTPUT);
pinMode(FLAP_PIN2, OUTPUT);
}
void loop() {
digitalWrite(FLAP_PIN1, HIGH);
digitalWrite(FLAP_PIN2, LOW);
delay(100); // Adjust delay for desired flapping speed
digitalWrite(FLAP_PIN1, LOW);
digitalWrite(FLAP_PIN2, HIGH);
delay(100);
}
Dieser einfache Code erzeugt eine Rechteckschwingung, die FlatFlap kontinuierlich flattern lässt. Sie können die Verzögerungszeit anpassen, um die Schlagfrequenz zu ändern.
Die von Ihnen gewählte Häufigkeit hängt von den Anforderungen Ihres Projekts ab:
Durch Anpassen der Verzögerungszeit im Arduino-Code können Sie die Frequenz an die Anforderungen Ihres Projekts anpassen.
Mehrere Faktoren beeinflussen die Wirksamkeit der Schlagbewegung:
Das obige Codebeispiel erzeugt eine einfache Rechteckwelle, die, wie Sie vielleicht bemerkt haben, die Klappe hart antreibt, ein Ein-Aus-Ansatz, der bei langsamen Frequenzen möglicherweise nicht wünschenswert ist. Um dies zu glätten, müssen wir an beiden Ausgängen Pulsweitenmodulation (PWM) verwenden. Diese Methode Die Intensität des Magnetfelds wird schrittweise geändert, wodurch die mechanische Belastung des FlatFlap-Aktuators verringert wird.
Diese Funktion wird automatisch in unserer DriveCell-Bibliothek verarbeitet:
# include <DriveCell.h>
# define IN1_pin1 2
# definieren IN1_pin2 3
# definieren IN2_pin1 5
# definieren IN2_pin2 6
Antriebszelle FlatFlap1 ( IN1_pin1 , IN1_pin2 ) ;
Antriebszelle FlatFlap2 ( IN2_pin1 , IN2_pin2 ) ;
uint16_t Klappenzähler = 0 ;
void setup ( ) {
FlatFlap1 .Init ( ) ;
FlatFlap2 .Init ( ) ;
FlatFlap1 . Tone ( ) ;
FlatFlap2 . Tone ( ) ;
}
void -Schleife ( ) {
Verzögerung ( 1 ) ;
Klappenzähler ++ ;
wenn ( Klappenzähler < 2000U ) {
FlatFlap1 . Run ( 0 , 100 , 100 ) ; //Rechteckwellenmodus
FlatFlap2.Run ( 0 , 100 , 100 ) ; // Rechteckwellenmodus
}
sonst wenn ( Klappenzähler < 8000U ) {
FlatFlap1.Run ( 1 , 100 , 1000 ) ; // Glatter PWM-Wellenmodus
FlatFlap2.Run ( 1 , 100 , 1000 ) ; // Glatter PWM-Wellenmodus
} anders {
Klappenzähler = 0U ;
FlatFlap1.Drive ( 0 , 100 ) ; //Klappe nach Süden mit 100 % Leistung
FlatFlap2.Drive ( 1 , 100 ) ; // Klappe nach Norden mit 100 % Leistung
Verzögerung ( 500 ) ;
FlatFlap1.Drive ( 1 , 100 ) ; // Klappe nach Norden mit 100 % Leistung
FlatFlap2.Drive ( 1 , 100 ) ; // Klappe nach Norden mit 100 % Leistung
Verzögerung ( 500 ) ;
FlatFlap1.Drive ( 1 , 100 ) ; // Klappe nach Norden mit 100 % Leistung
FlatFlap2.Drive ( 0 , 100 ) ; //Klappe nach Süden mit 100 % Leistung
Verzögerung ( 500 ) ;
FlatFlap1.Drive ( 1 , 50 ) ; // Klappe nach Norden mit 50 % Leistung
FlatFlap2.Drive ( 1 , 75 ) ; //Klappe nach Norden mit 75 % Leistung
Verzögerung ( 500 ) ;
FlatFlap1.Drive ( 0 , 25 ) ; //Klappe nach Süden mit 25 % Leistung
FlatFlap2.Drive ( 0 , 50 ) ; //Klappe nach Süden mit 50 % Leistung
}
}
Die Funktionen verstehen:
Init() → Initialisiert DriveCell und richtet die Eingangspins einDrive(direction, power) → Steuert den Aktuator:
direction → 1 (Norden) / 0 (Süden)power → Magnetische Feldstärke (0 bis 100%)Run(smooth, power, speed_ms) → Lassen Sie die FlatFlap entweder in einer Rechteckwelle oder einer sanfteren PWM-Welle oszillieren.
smooth → 1 (PWM-Welle) / 0 (Rechteckwelle)power → Magnetische Feldstärke (0 bis 100%)power → Flipping-Geschwindigkeit in Millisekunden⚠ Hinweis: Die Run() & Drive() Funktion verwendet eine Hochgeschwindigkeits-PWM-Timer, wodurch er nur mit CodeCell- und ESP32-basierten Geräten kompatibel ist.
Mit diesen Techniken können Sie FlatFlap in Robotik, Haptik und Kunst integrieren! Weitere Codebeispiele und technische Dokumentation finden Sie im DriveCell GitHub Repository !
FlatFlap ist nicht nur ein Schlagaktor – er kann auch summende Töne erzeugen, ähnlich einem Piezo-Summer. Durch das Senden eines Hochfrequenzsignals kann FlatFlap hörbare Töne und Vibrationen erzeugen und eignet sich daher für Alarmsysteme, interaktive Reaktionen und kreative Klanginstallationen.
Während Sie jeden H-Bridge-Treiber zur Steuerung von FlatFlap verwenden können, macht DriveCell das Setup kompakt und einfach in Mikrocontroller-Projekte zu integrieren.
FlatFlap verfügt über eine dünne Kupferspule und einen N52-Neodym-Magneten. Fließt elektrischer Strom durch die Spule, erzeugt die Spule Bewegung. Durch schnelles Umschalten der Stromrichtung in einem hörbaren Frequenzbereich (~100 Hz–10 kHz) kann FlatFlap Töne ähnlich einem Lautsprecher oder Piezo-Summer erzeugen.
Durch Variieren der Frequenz können Sie:
Zur Tonerzeugung benötigen Sie einen H-Brücken-Motortreiber (wie DriveCell), der die Stromrichtung schnell umschalten kann. Die Verwendung von DriveCell vereinfacht die Anschlüsse und macht den Aufbau kompakter. Alternativ können Sie auch jedes Standard-H-Brücken-Modul verwenden.
So verdrahten Sie FlatFlap mit einem DriveCell-Modul:
FlatFlap kann Töne mithilfe von PWM-Signalen erzeugen. Unten sehen Sie ein Beispiel mit den integrierten Funktionen von DriveCell zur Tonerzeugung.
Dieses Beispiel macht FlatFlap summt wie ein Lautsprecher und spielt eine Tonfolge ab:
#include <DriveCell.h>
#define IN1_pin1 2
#define IN1_pin2 3
DriveCell myFlatFlap(IN1_pin1, IN1_pin2);
void setup() {
myFlatFlap.Init(); /* Initialize FlatFlap with DriveCell */
}
void loop() {
myFlatFlap.Buzz(100); /* Buzz at 100 microseconds */
delay(500);
myFlatFlap.Tone(); /* Play a fixed tone with varying frequencies */
delay(500);
}
Die Funktionen verstehen:
Buzz(duration) → Erzeugt einen Summeneffekt von 100 Mikrosekunden und steuert die Vibrationsgeschwindigkeit.Tone() → Spielt ein hörbarer Ton, dessen Frequenz automatisch variiert. Tipp: Durch die Anpassung der Durch die Frequenz und den Arbeitszyklus können Sie verschiedene Musiknoten, Alarme oder Feedback-Töne erzeugen.
Unten sehen Sie ein weiteres Codebeispiel, das das Super Mario-Lied mit FlatFlap abspielt:
/* Arduino Mario Bros Tunes With Piezo Buzzer and PWM
by : ARDUTECH
Connect the positive side of the Buzzer to pin 3,
then the negative side to a 1k ohm resistor. Connect
the other side of the 1 k ohm resistor to
ground(GND) pin on the Arduino.
*/
#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978
#Melodie definierenPin 5
//Mario-Hauptthemamelodie
int Melodie[] = {
HINWEIS_E7, HINWEIS_E7, 0, HINWEIS_E7,
0, HINWEIS_C7, HINWEIS_E7, 0,
HINWEIS_G7, 0, 0, 0,
HINWEIS_G6, 0, 0, 0,
HINWEIS_C7, 0, 0, HINWEIS_G6,
0, 0, HINWEIS_E6, 0,
0, HINWEIS_A6, 0, HINWEIS_B6,
0, HINWEIS_AS6, HINWEIS_A6, 0,
HINWEIS_G6, HINWEIS_E7, HINWEIS_G7,
HINWEIS_A7, 0, HINWEIS_F7, HINWEIS_G7,
0, HINWEIS_E7, 0, HINWEIS_C7,
HINWEIS_D7, HINWEIS_B6, 0, 0,
HINWEIS_C7, 0, 0, HINWEIS_G6,
0, 0, HINWEIS_E6, 0,
0, HINWEIS_A6, 0, HINWEIS_B6,
0, HINWEIS_AS6, HINWEIS_A6, 0,
HINWEIS_G6, HINWEIS_E7, HINWEIS_G7,
HINWEIS_A7, 0, HINWEIS_F7, HINWEIS_G7,
0, HINWEIS_E7, 0, HINWEIS_C7,
HINWEIS_D7, HINWEIS_B6, 0, 0
};
//Mario spielt das Tempo
int tempo[] = {
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
9, 9, 9,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
9, 9, 9,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
};
//Unterweltmelodie
int underworld_melody[] = {
NOTE_C4, NOTE_C5, NOTE_A3, NOTE_A4,
HINWEIS_AS3, HINWEIS_AS4, 0,
0,
NOTE_C4, NOTE_C5, NOTE_A3, NOTE_A4,
HINWEIS_AS3, HINWEIS_AS4, 0,
0,
HINWEIS_F3, HINWEIS_F4, HINWEIS_D3, HINWEIS_D4,
HINWEIS_DS3, HINWEIS_DS4, 0,
0,
HINWEIS_F3, HINWEIS_F4, HINWEIS_D3, HINWEIS_D4,
HINWEIS_DS3, HINWEIS_DS4, 0,
0, HINWEIS_DS4, HINWEIS_CS4, HINWEIS_D4,
HINWEIS_CS4, HINWEIS_DS4,
HINWEIS_DS4, HINWEIS_GS3,
HINWEIS_G3, HINWEIS_CS4,
NOTE_C4, NOTE_FS4, NOTE_F4, NOTE_E3, NOTE_AS4, NOTE_A4,
HINWEIS_GS4, HINWEIS_DS4, HINWEIS_B3,
HINWEIS_AS3, HINWEIS_A3, HINWEIS_GS3,
0, 0, 0
};
//Unterwelt-Tempo
int underworld_tempo[] = {
12, 12, 12, 12,
12, 12, 6,
3,
12, 12, 12, 12,
12, 12, 6,
3,
12, 12, 12, 12,
12, 12, 6,
3,
12, 12, 12, 12,
12, 12, 6,
6, 18, 18, 18,
6, 6,
6, 6,
6, 6,
18, 18, 18, 18, 18, 18,
10, 10, 10,
10, 10, 10,
3, 3, 3
};
void setup(void)
{
pinMode(5, OUTPUT);//Summer
pinMode(6, AUSGABE);
digitalWrite(6, LOW);
}
void-Schleife ()
{
//sing die Melodien
singen(1);
singen(1);
singen(2);
}
int Lied = 0;
void sing(int s) {
// über die Noten der Melodie iterieren:
Lied = s;
wenn (Lied == 2) {
Serial.println(" 'Unterwelt-Thema'");
int-Größe = Größe von (Underworld_Melody) / Größe von (int);
für (int thisNote = 0; thisNote < Größe; thisNote++) {
// Um die Notendauer zu berechnen, nehmen Sie sich eine Sekunde Zeit
// geteilt durch den Notentyp.
//z. B. Viertelnote = 1000 / 4, Achtelnote = 1000/8 usw.
int noteDuration = 1000 / underworld_tempo[dieseNote];
Buzz (MelodyPin, Unterweltmelodie [diese Note], Notendauer);
// Um die Noten zu unterscheiden, legen Sie eine Mindestzeit zwischen ihnen fest.
// die Dauer der Note + 30 % scheint gut zu funktionieren:
int pauseBetweenNotes = Notendauer * 1,30;
Verzögerung (Pause zwischen den Noten);
// Tonwiedergabe stoppen:
Buzz (Melodie-Pin, 0, Notendauer);
}
} anders {
Serial.println(" 'Mario-Thema'");
int-Größe = Größe von (Melodie) / Größe von (int);
für (int thisNote = 0; thisNote < Größe; thisNote++) {
// Um die Notendauer zu berechnen, nehmen Sie sich eine Sekunde Zeit
// geteilt durch den Notentyp.
//z. B. Viertelnote = 1000 / 4, Achtelnote = 1000/8 usw.
int noteDuration = 1000 / tempo[dieseNote];
Buzz (MelodyPin, Melodie [diese Note], Notendauer);
// Um die Noten zu unterscheiden, legen Sie eine Mindestzeit zwischen ihnen fest.
// die Dauer der Note + 30 % scheint gut zu funktionieren:
int pauseBetweenNotes = Notendauer * 1,30;
Verzögerung (Pause zwischen den Noten);
// Tonwiedergabe stoppen:
Buzz (Melodie-Pin, 0, Notendauer);
}
}
}
void buzz(int targetPin, lange Frequenz, lange Länge) {
long delayValue = 1000000 / Frequenz / 2; // Berechnen Sie den Verzögerungswert zwischen den Übergängen
//// 1 Sekunde im Wert von Mikrosekunden, geteilt durch die Frequenz, dann in zwei Hälften geteilt, da
//// Jeder Zyklus besteht aus zwei Phasen
long numCycles = Frequenz * Länge / 1000; // Berechnen Sie die Anzahl der Zyklen für das richtige Timing
//// multiplizieren Sie die Frequenz, die tatsächlich Zyklen pro Sekunde entspricht, mit der Anzahl der Sekunden, bis
//// Holen Sie sich die Gesamtzahl der zu produzierenden Zyklen
for (long i = 0; i < numCycles; i++) { // für die berechnete Zeitspanne...
digitalWrite(targetPin, HIGH); // schreibe den Summer-Pin auf High, um die Membran herauszudrücken
delayMicroseconds(delayValue); // warte auf den berechneten Verzögerungswert
digitalWrite(targetPin, LOW); // schreibe den Summer-Pin auf Low, um die Membran zurückzuziehen
delayMicroseconds(delayValue); // erneut warten oder den berechneten Verzögerungswert
}
}
Wie wir gesehen haben, kann FlatFlap auch Summtöne erzeugen, wenn es mit einem H-Bridge-Modul wie DriveCell gesteuert wird. Weitere Codebeispiele und technische Dokumentation finden Sie im DriveCell GitHub Repository !
FlatFlap ist einer der dünnsten Klappenaktuatoren auf dem Markt – seine Klappe ist nur 0,3 mm dünn! FlatFlap wurde für Anwendungen mit geringem Kraftaufwand entwickelt und verleiht kreativen und interaktiven Projekten dynamische Bewegung. Ob für künstlerische Installationen, interaktive Displays oder leichte Roboteranwendungen – dieser kompakte Aktuator sorgt mit minimalem Kraftaufwand für auffällige Bewegungen.
In dieser Anleitung erfahren Sie, wie FlatFlap funktioniert, wie es installiert wird und wie es gesteuert wird.
Der Der FlatFlap-Aktuator ist ein einzigartiger, flexibler PCB-basierter Aktuator mit integrierter Aluminiumversteifung, der eine leichte Schlagbewegung erzeugt. Sein Magnetsystem wandelt elektrische Energie in mechanische Bewegung um und ist somit die ideale Lösung für Projekte, die eine feine, organische Bewegung erfordern.
Der FlatFlap-Antrieb besteht aus:
Fließt elektrischer Strom durch die Spule, erzeugt diese ein Magnetfeld, das mit dem Magneten interagiert und die Klappe anzieht oder abstößt. Durch Wechsel der Stromrichtung kann FlatFlap eine Schlagbewegung erzeugen.
Jedes FlatFlap-Kit enthält:
FlatFlap ist Dank der abziehbaren Kleberückseite lässt es sich einfach auf jeder glatten Oberfläche befestigen. Alternativ kann es mit den mitgelieferten M1.2-Schrauben festgeschraubt werden.
Hinweis: Die reflektierende Aluminiumklappe ist nicht poliert und kann herstellungsbedingt leichte Kratzer aufweisen.
Wenn Sie FlatFlap als eigenständigen Aktuator erworben haben, können Sie seine Bewegung manuell testen:
Um diesen Prozess zu automatisieren, können Sie:
Löten Sie das CoilPad direkt an unser DriveCell-Modul um die Dinge kompakt zu halten. Dies hat einen DRV8837 H-Brücken-Treiber im kleinsten Paket, der für den Umgang mit Gleichstrommotoren und -aktoren mit geringer Leistung ausgelegt ist.
Bereit zum Experimentieren? Schnapp dir noch heute einen FlatFlap und bring Bewegung in dein nächstes Projekt!
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.Drive(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!
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.
