FlatFlap - Schlagbewegung erzeugen

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.

Wie funktioniert es?

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.

Generieren einer Rechteckwelle zum Flattern

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.

Schlagbewegung und Frequenz

Die von Ihnen gewählte Häufigkeit hängt von den Anforderungen Ihres Projekts ab:

• Niedrige Frequenzen (1–10 Hz): Langsame, kontrollierte Bewegung, geeignet für empfindliche Anwendungen
• Mittlere Frequenzen (10–18 Hz): Moderate Schlaggeschwindigkeit für natürliche Bewegungseffekte
• Hohe Frequenzen (18–25 Hz): Schnelle Schwingungen für Vibration oder schnelle Betätigung

Durch Anpassen der Verzögerungszeit im Arduino-Code können Sie die Frequenz an die Anforderungen Ihres Projekts anpassen.

Faktoren, die die Bewegung von FlatFlap beeinflussen

Mehrere Faktoren beeinflussen die Wirksamkeit der Schlagbewegung:

1. Versorgungsspannung – Eine höhere Spannung erhöht die Stärke des Magnetfelds, was zu stärkeren Klappen führt.
2. Stromfluss – Konstante Stromquelle sorgt für stabile Bewegung
3. Mechanische Belastung – Obwohl FlatFlap nur etwa 2 g heben kann, wirkt sich jedes zusätzliche Gewicht an der Klappe auf ihre Reaktionszeit, die maximal erreichbare Frequenz und die Resonanzfrequenz aus.

Optimierung des Flapping-PWM

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 ein
• Drive(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.

Abschluss

Mit diesen Techniken können Sie FlatFlap in Robotik, Haptik und Kunst integrieren! Weitere Codebeispiele und technische Dokumentation finden Sie im DriveCell GitHub Repository !