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!
The FlatFlap is an incredibly thin and innovative actuator that brings motion to your projects in a compact form factor. To understand how it works, let's dive into its unique design and the principles behind its operation.
In this tutorial we will explain:
What is a FlatFlap?
It's Flat and its a Flap ~ the FlatFlap is an actuator made from a flexible PCB (printed circuit board) and aluminum stiffeners, folded together to create a low-force flapping motion. It’s magnetic system converts electrical energy into mechanical movement.
How Does It Work?
The FlatFlap features a thin 10mm N52 neodymium magnet on its back, which interacts with the planar copper coil embedded within the flexible PCB. When an electric current passes through the coil, it generates a small magnetic field that either attracts or repels the magnet, causing the flap to move. By alternating the direction of the current, you can control the flapping motion of the actuator. Applying a square wave signal makes the FlatFlap flap continuously, with speeds of up to 25Hz. For smooth organic motions, we will explore the DriveCell PWM library.
Installing FlatFlap
The FlatFlap design makes it easy to install. It comes with a peelable adhesive back and optional M1.2 screws (included) for added security, ensuring that it stays firmly attached to any surface, whether smooth or textured. The adhesive is 3M467, which provides a strong bond but can be removed with tweezers if needed.
Getting Your FlatFlap Moving
If you purchased the FlatFlap as a stand-alone actuator, you can start by pulling one of its pins to 5V and the other to ground, then switch them around. In one instance, the flap will be repelled, and in the other, it will be attracted. You can connect it to your own transistors or H-bridge module to switch these pins automatically. However, to make it even easier, you can purchase the FlatFlap directly soldered to our tiny DriveCell module. The DriveCell is a compact, pin-to-pin compatible H-bridge driver that simplifies the process of controlling actuators like the FlatFlap. Its open-source Arduino software library makes actuator control easy, especially for beginners, by providing straightforward software functions and easy-to-follow examples.
For an in-depth guide on the DriveCell Software Library, check out this article. But here’s a quick recap of how you can use its functions to enhance the FlatFlap actuation. Don’t worry, it’s quite simple! Start by downloading the "DriveCell" library from Arduino's Library Manager. Once installed, you’ll be ready to control your device. Before we start, make sure you connect the DriveCell to your microcontroller. We recommend using a CodeCell, which is pin-to-pin compatible, supports all the library functions, and can add wireless control and interactive sensing to your FlatFlap.
1. Init()
First we need a basic setup code to get you started:
#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
}
This code gives the name 'myFlatFlap' to your DriveCell and tells it to start up and initialize all the necessary peripherals.
2. Pulse(bool direction, uint8_t ms_duration)
This function sends a brief burst of power to the FlatFlap in a specified polarity. This quick energizing and de-energizing can cause a short, sharp movement of the FlatFlap, depending on the polarity.
myFlatFlap.Pulse(1, 10); // Sends a short burst for 10 milliseconds in the specified direction2. Buzz(uint16_t us_buzz)
This function makes the FlatFlap vibrate like a buzzer, which is useful for creating audible feedback.
myFlatFlap.Buzz(100); // Makes the FlatFlap buzz with a 100 microsecond pulses
3. Tone()
The Tone function makes the FlatFlap play a tone. This can be used for audible feedback or creative applications where sound is part of the interaction.
myFlatFlap.Tone(); // Plays a tone by varying the frequency
4. Toggle(uint8_t power_percent)
This function switches the FlatFlap direction, which can be useful for creating a rapid flapping movement or reversing direction quickly in your code.
myFlatFlap.Toggle(100); // Toggles direction at 100% power5. Run(bool smooth, uint8_t power_percent, uint16_t flip_speed_ms)
This function allows you to continuously flip the polarity of the FlatFlap and control its motion speed and smoothness. If smooth is set to true, the flapping will be less sharp and smoothed, which is ideal for slower, controlled movements.
myFlatFlap.Run(true, 50, 1000); // Runs the FlatFlap smoothly at 50% power, flipping every 1000 milliseconds6. Drive(bool direction, uint8_t power_percent)
This function lets you control the FlatFlap polarity and angular position of the flap by adjusting the power level, basically adjusting how strong the magnetic pull or push is.
myFlatFlap.Drive(true, 75); // Moves the FlatFlap forward at 75% power
Here's an example where we configure two FlatFlaps and flap them at different speeds:
#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);
delay(500);
FlatFlap1.Drive(0, 100);
FlatFlap2.Drive(0, 100);
delay(500);
FlatFlap1.Drive(1, 100);
FlatFlap2.Drive(1, 100);
delay(500);
FlatFlap1.Tone();
FlatFlap2.Tone();
}
}
Combining with CodeCell Sensors
To make it even more interactive you can combine the FlatFlap and DriveCell with the tiny CodeCell Sensor Module. CodeCell is pin-to-pin compatible with DriveCell, supports all library functions, and adds wireless control and interactive sensing to your project. This allows you to create more advanced, responsive elements with your FlatFlap actuators.
With this next example the CodeCell controls two FlatFlap that stops flapping when proximity is detected. Their angle gets adjusted dynamically based on how close your hands gets.
#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(proximity);
if (proximity < 100) {
FlatFlap1.Run(1, 100, 400);
FlatFlap2.Run(1, 100, 400);
} else {
proximity = proximity - 100;
proximity = proximity / 10;
if (proximity > 100) {
proximity = 100;
}
FlatFlap1.Drive(0, (proximity));
FlatFlap2.Drive(0, (proximity));
}
}
}
Feel free to tweak the code with your own creative ideas, or add motion sensing for a new reaction! With FlatFlap, you can bring your creative projects to life with motion in a sleek, compact package. Whether you're adding dynamic elements to art, experimenting with robotics, or developing interactive mechanical displays, the FlatFlap provides a versatile and easy-to-use solution. Get started today with our Arduino libraries! If you have any more question about the FlatFlap feel free to email us and we will gladly help out!
The FlatFlap is an incredibly thin and innovative actuator that brings motion to your projects in a compact form factor. To understand how it works, let's dive into the unique design and the principles behind its operation.
The Structure
The FlatFlap is designed from a flexible PCB (printed circuit board) and aluminum stiffeners. These components are carefully folded together to form the actuator.
The flexible PCB serves as the foundation of the actuator. Unlike rigid PCBs, the flexible version can bend and twist without breaking, which is essential for creating the flapping motion. The flexibility of the PCB allows the FlatFlap to move freely while still maintaining its structural integrity.
The Aluminum Stiffeners provide the necessary rigidity to hold the magnet that directs the flapping motion, ensuring that the movement is both precise and consistent.
The Magnetic System
The FlatFlap is powered by a clever magnetic system that converts electrical energy into mechanical motion. This system consists of a magnet on the back of the actuator and a planar copper coil embedded within the flexible PCB.
The FlatFlap features a 10mm N52 neodymium magnet attached to its back. This magnet plays a crucial role in the actuator's operation, interacting with the magnetic field generated by the copper coil. This coil is inside the flexible PCB, and is responsible for creating the magnetic field when an electric current is passed through it. Flapping motion is achieved by pulsing the current through the copper coil in different directions.
Depending on the direction of the current, this magnetic field interacts with the magnet on the back of the FlatFlap. By alternating the direction of the current, the magnetic field can either attract or repel the magnet, causing the flap to move. The voltage can also be varied via PWM, to control the distance of the coil from the magnet.
By rapidly pulsing the current in different directions, creating a square wave, the FlatFlap can produce a continuous flapping motion. The speed and frequency of this motion can be controlled by adjusting the rate at which the current is pulsed. In its optimal configuration. The FlatFlap can achieve a speed of up to 25Hz, creating a fast and responsive movement.
Easy Attachment and Secure Installation
Installing the FlatFlap is a breeze, thanks to its peelable adhesive back and optional screws. The adhesive provides a strong bond that keeps the actuator securely in place, while the screws offer an additional layer of security if needed. This dual installation method ensures flawless adhesion, whether you're attaching the FlatFlap to a smooth surface or something more textured.
Ultra-Thin and Compact Design
One of the standout features of the FlatFlap is its incredibly slim profile. With a flap that’s only 0.3mm thin and an actuator measuring just 2.6mm, this sleek design can integrate seamlessly into any flat surface. Its low profile ensures that it doesn't interfere with the aesthetics of your project, making it ideal for applications where space is at a limited.
The FlatFlap is perfect for a wide range of applications. It’s particularly well-suited for creating kinetic sculptures and experimenting with robotics. Its ability to add eye-catching motion to lightweight objects, such as thin 3D-printed plastic or paper origami, opens up a world of creative possibilities.
