FlatFlap is a compact actuator made to flap, however in this guide we will focuses on position control - keeping the flap in a fixed position using a controlled duty cycle. This method is useful for applications that require the flap to stay in a specific angle for long periods of time, instead of continuous oscillation.
FlatFlap operates by passing current through its coil, generating a magnetic field that interacts with its magnet. Instead of applying a short pulse or oscillating the square wave, here, we are going to use Pulse Width Modulation (PWM) to hold the flap at a desired angle.
The duty cycle of the PWM signal controls the strength of the magnetic field, thus changing the angle of the flap.
Several factors influence position accuracy and stability:
If you're using the DriveCell library, the following example demonstrates how to set different positions:
#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);
}
This code gradually adjusts the duty cycle to hold the flap at different positions.
Understanding the Functions:
Init() → Initializes DriveCell and sets up the input pinsDrive(bool direction, uint8_t power_percent)
true (north) / false (south)⚠ Note: The Drive() function uses a high-speed PWM timer, making it compatible only with CodeCell and ESP32-based devices.
If you're not using an ESP32 device, you can adjust PWM in Arduino using the following code. However, ensure that the waveform frequency is set correctly.
#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% Duty Cycle
delay(5000);
}
By using PWM the FlatFlap can maintain specific angles for long peroids of time, making this feature useful for robotics, haptics, and art. Check out the DriveCell GitHub Repository for more code examples and technical documentation!
FlatFlap is a compact actuator that can generates organic flappy movements. However this guide focuses on creating a short pulse - a single flap lasting only a few milliseconds before stopping. This method is useful for quick actuation, and applications where brief motion is required.
To generate motion, FlatFlap relies on an electric current passing through its coil, creating a magnetic field. By applying a short pulse, we induce a rapid magnetic field that repels the magnet instantaneously.
To manually generate a pulse you can use basic digitalWrite commands:
#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
}
This simple code sends a 500-millisecond pulse to FlatFlap, causing a brief movement before stopping.
Instead of an abrupt ON/OFF pulse, PWM (Pulse Width Modulation) can gradually control the intensity, reducing mechanical stress and improving performance. This is automatically handled in DriveCell:
#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
}
If you are using our DriveCell library you can directly use the Pulse function to implement this:
#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); // Wait before the next pulse
}Understanding the Function:
Pulse(bool direction, uint8_t ms_duration)
direction: true (north) / false (south)
ms_duration: Duration of the pulse in milliseconds
Using short pulses, you can control FlatFlap for quick actuation applications. Check out the DriveCell GitHub Repository for more code examples and technical documentation!
This guide explains how the FlatFlap can control its flapping motion, how frequency and polarity affect its movement, and how to generate its drive signals.
To make FlatFlap move, an electric current is applied its coil, generating a magnetic field. By reversing the polarity at a set frequency, we create a repetitive push-pull motion that causes the flap to oscillate.
The flapping frequency can be controlled within the range of 1 Hz to 25 Hz, which means FlatFlap can flap between 1 to 25 times per second depending on the input signal. It can go to higher frequencies, but usually the magnet won't have enough time to react.
A square wave signal is required to make the FlatFlap flap. An H-Bridge driver like our DriveCell, is needed to power the actuator and switch its polarity, The input signals of the square wave can be generated using a simple digitalWrite() commands in Arduino:
#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);
}
This simple code creates a square wave oscillation, making FlatFlap flap continuously. You can adjust the delay time to change the flapping frequency.
The frequency you select will depends on your project's requirements:
By adjusting the delay time in the Arduino code, you can fine-tune the frequency to match your project needs.
Several factors influence the effectiveness of the flapping motion:
The code example above generate a basic square wave, which as you might observed drives the flap in a hard manner, an on-off approach, which at slow frequencies might not be desirable. To smooth this out we need to use Pulse width modulation (PWM) on both outputs. This method gradually changes the magnetic field intensity, reducing mechanical stress on the FlatFlap actuator.
This function is automatically handled within our DriveCell library:
#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); //Square Wave mode
FlatFlap2.Run(0, 100, 100); //Square Wave mode
}
else if (flap_counter < 8000U) {
FlatFlap1.Run(1, 100, 1000); //Smooth PWM Wave mode
FlatFlap2.Run(1, 100, 1000); //Smooth PWM Wave mode
} else {
flap_counter = 0U;
FlatFlap1.Drive(0, 100); //Flap South at 100% power
FlatFlap2.Drive(1, 100); //Flap North at 100% power
delay(500);
FlatFlap1.Drive(1, 100); //Flap North at 100% power
FlatFlap2.Drive(1, 100); //Flap North at 100% power
delay(500);
FlatFlap1.Drive(1, 100); //Flap North at 100% power
FlatFlap2.Drive(0, 100); //Flap South at 100% power
delay(500);
FlatFlap1.Drive(1, 50); //Flap North at 50% power
FlatFlap2.Drive(1, 75); //Flap North at 75% power
delay(500);
FlatFlap1.Drive(0, 25); //Flap South at 25% power
FlatFlap2.Drive(0, 50); //Flap South at 50% power
}
}Understanding the Functions:
Init() → Initializes DriveCell and sets up the input pinsDrive(direction, power) → Controls actuator:
direction → 1 (north) / 0 (south)power → Magnetic-field strength (0 to 100%)Run(smooth, power, speed_ms) → Oscillate the FlatFlap in either a square wave or a smoother PWM wave.
smooth → 1 (pwm wave) / 0 (square wave)power → Magnetic-field strength (0 to 100%)power → Flipping speed in milliseconds⚠ Note: The Run() & Drive() function uses a high-speed PWM timer, making it compatible only with CodeCell and ESP32-based devices.
With these techniques, you can integrate FlatFlap into robotics, haptics and art! Check out the DriveCell GitHub Repository for more code examples and technical documentation!
FlatFlap isn’t just a flapping actuator - it can also generate buzzing tones, much like a piezo buzzer. By sending a high-frequency signal, FlatFlap can produce audible tones and vibrations, making it useful for alert systems, interactive responses, and creative sound-based installations.
While you can use any H-Bridge driver to control FlatFlap, DriveCell makes the setup compact and easy to integrate into microcontroller projects.
FlatFlap features a thin copper coil and an N52 neodymium magnet, creating motion when an electrical current flows through it. By rapidly switching the current direction at an audible frequency range (~100Hz–10kHz), FlatFlap can emit tones similar to a speaker or piezo buzzer.
By varying the frequency, you can:
To generate tones, you’ll need an H-Bridge motor driver (like DriveCell) that can rapidly switch the current direction. Using DriveCell can simplifies connections and makes the setup more compact, but any standard H-Bridge module can also be used.
Here’s how to wire FlatFlap to a DriveCell module:
FlatFlap can generate tones using PWM signals. Below is an example using DriveCell’s built-in functions for tone generation.
This example makes FlatFlap buzz like a speaker, playing a sequence of tones:
#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);
}
Understanding the Functions:
Buzz(duration) → Generates a buzzing effect at 100 microseconds, controlling the vibration speed.Tone() → Plays an audible tone, varying its frequency automatically.Tip: By adjusting the frequency and duty cycle, you can create different musical notes, alarms, or feedback sounds.
Below is another code example that plays the Super Mario song using FlatFlap:
/* 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
#define melodyPin 5
//Mario main theme melody
int melody[] = {
NOTE_E7, NOTE_E7, 0, NOTE_E7,
0, NOTE_C7, NOTE_E7, 0,
NOTE_G7, 0, 0, 0,
NOTE_G6, 0, 0, 0,
NOTE_C7, 0, 0, NOTE_G6,
0, 0, NOTE_E6, 0,
0, NOTE_A6, 0, NOTE_B6,
0, NOTE_AS6, NOTE_A6, 0,
NOTE_G6, NOTE_E7, NOTE_G7,
NOTE_A7, 0, NOTE_F7, NOTE_G7,
0, NOTE_E7, 0, NOTE_C7,
NOTE_D7, NOTE_B6, 0, 0,
NOTE_C7, 0, 0, NOTE_G6,
0, 0, NOTE_E6, 0,
0, NOTE_A6, 0, NOTE_B6,
0, NOTE_AS6, NOTE_A6, 0,
NOTE_G6, NOTE_E7, NOTE_G7,
NOTE_A7, 0, NOTE_F7, NOTE_G7,
0, NOTE_E7, 0, NOTE_C7,
NOTE_D7, NOTE_B6, 0, 0
};
//Mario main them 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,
};
//Underworld melody
int underworld_melody[] = {
NOTE_C4, NOTE_C5, NOTE_A3, NOTE_A4,
NOTE_AS3, NOTE_AS4, 0,
0,
NOTE_C4, NOTE_C5, NOTE_A3, NOTE_A4,
NOTE_AS3, NOTE_AS4, 0,
0,
NOTE_F3, NOTE_F4, NOTE_D3, NOTE_D4,
NOTE_DS3, NOTE_DS4, 0,
0,
NOTE_F3, NOTE_F4, NOTE_D3, NOTE_D4,
NOTE_DS3, NOTE_DS4, 0,
0, NOTE_DS4, NOTE_CS4, NOTE_D4,
NOTE_CS4, NOTE_DS4,
NOTE_DS4, NOTE_GS3,
NOTE_G3, NOTE_CS4,
NOTE_C4, NOTE_FS4, NOTE_F4, NOTE_E3, NOTE_AS4, NOTE_A4,
NOTE_GS4, NOTE_DS4, NOTE_B3,
NOTE_AS3, NOTE_A3, NOTE_GS3,
0, 0, 0
};
//Underwolrd 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);//buzzer
pinMode(6, OUTPUT);
digitalWrite(6, LOW);
}
void loop()
{
//sing the tunes
sing(1);
sing(1);
sing(2);
}
int song = 0;
void sing(int s) {
// iterate over the notes of the melody:
song = s;
if (song == 2) {
Serial.println(" 'Underworld Theme'");
int size = sizeof(underworld_melody) / sizeof(int);
for (int thisNote = 0; thisNote < size; thisNote++) {
// to calculate the note duration, take one second
// divided by the note type.
//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
int noteDuration = 1000 / underworld_tempo[thisNote];
buzz(melodyPin, underworld_melody[thisNote], noteDuration);
// to distinguish the notes, set a minimum time between them.
// the note's duration + 30% seems to work well:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// stop the tone playing:
buzz(melodyPin, 0, noteDuration);
}
} else {
Serial.println(" 'Mario Theme'");
int size = sizeof(melody) / sizeof(int);
for (int thisNote = 0; thisNote < size; thisNote++) {
// to calculate the note duration, take one second
// divided by the note type.
//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
int noteDuration = 1000 / tempo[thisNote];
buzz(melodyPin, melody[thisNote], noteDuration);
// to distinguish the notes, set a minimum time between them.
// the note's duration + 30% seems to work well:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// stop the tone playing:
buzz(melodyPin, 0, noteDuration);
}
}
}
void buzz(int targetPin, long frequency, long length) {
long delayValue = 1000000 / frequency / 2; // calculate the delay value between transitions
//// 1 second's worth of microseconds, divided by the frequency, then split in half since
//// there are two phases to each cycle
long numCycles = frequency * length / 1000; // calculate the number of cycles for proper timing
//// multiply frequency, which is really cycles per second, by the number of seconds to
//// get the total number of cycles to produce
for (long i = 0; i < numCycles; i++) { // for the calculated length of time...
digitalWrite(targetPin, HIGH); // write the buzzer pin high to push out the diaphram
delayMicroseconds(delayValue); // wait for the calculated delay value
digitalWrite(targetPin, LOW); // write the buzzer pin low to pull back the diaphram
delayMicroseconds(delayValue); // wait again or the calculated delay value
}
}
As we've seen, FlatFlap can also produce buzzing tones when controlled with an H-Bridge module like DriveCell. Check out the DriveCell GitHub Repository for more code examples and technical documentation!
FlatFlap is one of the thinnest flapping actuators available - its flapper just measures 0.3mm thin! Designed for low-force applications, FlatFlap can adds dynamic motion to creative and interactive projects. Whether used for artistic installations, interactive displays, or lightweight robotic applications, this compact actuator delivers eye-catching movement with minimal effort.
In this guide, we'll explore how FlatFlap works, its installation process, and how to control it.
The FlatFlap actuator is a unique flexible PCB-based actuator with an integrated aluminum stiffener, designed to create a low-force flapping motion. Its magnetic system converts electrical energy into mechanical movement, making it an ideal solution for projects requiring delicate, organic motion.
The FlatFlap actuator is made from:
When electric current flows through the coil, it generates a magnetic field that interacts with the magnet, causing the flap to attract or repel. By alternating the current direction, FlatFlap can generate a flapping motion.
Each FlatFlap kit contains:
FlatFlap is designed for easy attachment to any smooth surface using its peelable adhesive back. It can also be screwed in place using the included M1.2 screws.
Note: The reflective aluminum flap is not polished and may have minor scratches due to its manufacturing process.
If you purchased FlatFlap as a standalone actuator, you can manually test its movement:
To automate this process, you can:
Solder the CoilPad directly to our DriveCell module to keep things compact. This has a DRV8837 H-Bridge driver packed into the smallest package, designed to handle low-power DC motors and actuators.
Ready to start experimenting? Grab a FlatFlap today and bring motion to your next project!
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.
