CoilPad is a flexible, ultra-thin PCB coil that can be adapted for various applications, including metal detection. By pairing CoilPad with a capacitor, you can create an LC oscillator that responds to the presence of metal objects. Additionally, two CoilPad can be used as a poor transformer, enough to wirelessly transmit data or even wirelessly power an LED!
When a capacitor is placed in parallel with CoilPad, it forms an LC circuit (inductor-capacitor circuit). When driven at its resonant frequency, this circuit oscillates. If a metal object comes near, it disturbs the field, altering the circuit’s frequency. This change can be detected, allowing CoilPad to function as a simple metal detector.
To turn CoilPad into a metal detector, you need:
#define COIL_PIN 2
void setup() {
pinMode(COIL_PIN, INPUT);
Serial.begin(115200);
}
void loop() {
int freq = pulseIn(COIL_PIN, HIGH);
Serial.println(freq);
delay(100);
}
This code reads the frequency and prints it to the serial monitor, allowing you to observe frequency changes when metal is nearby.
CoilPad can also be used for wireless transfer by pairing two CoilPads tuned to the same resonant frequency.
Where L is the inductance of the CoilPad which is 30.7uH
#define COILPAD_PIN1 2
#define COILPAD_PIN2 3
void setup() {
pinMode(COILPAD_PIN1, OUTPUT);
pinMode(COILPAD_PIN2, OUTPUT);
}
void loop() {
digitalWrite(COILPAD_PIN1, HIGH);
digitalWrite(COILPAD_PIN2, LOW);
delayMicroseconds(5); // 100kHz Resonant Frequency - Adjust delay for desired resonant frequency
digitalWrite(COILPAD_PIN1, LOW);
digitalWrite(COILPAD_PIN2, HIGH);
delayMicroseconds(5);
}
When the receiver CoilPad is placed nearby, the LED should glow, demonstrating wireless transfer.
Beyond power transfer, you can also use CoilPad to transmit data by modulating the signal frequency on the transmitter side and detecting changes on the receiver side. How cool is that!
With these techniques, you can start using CoilPad to sense metal or even as a wireless antenna.
Ready to start experimenting? Grab a CoilPad today and bring motion to your next project!
CoilPad is a flexible, ultra-thin sticker coil intended to be used as a magnetic actuator. However it can also be hacked into a micro-heater for some specialized applications. actuator that can also function as a micro-heater.
By adjusting the PWM waveform, you can vary the heat generated.
When powered at a constant 5V, CoilPad can reach up to 100°C. This makes it suitable for applications requiring a compact and seamless heating element. Varying the input voltage, directly controls the output heat - so by powering the CoilPad with a Pulse width modulation (PWM) signal instead of constant power, we can also vary the heat. A higher duty cycle results in increased heat output, while a lower duty cycle maintains a lower temperature.
Several factors affect the heating performance of CoilPad:
If you are using the DriveCell library, you can easily control the CoilPad as a micro-heater with the following example:
#include <drivecell.h>
#define HEATER_PIN1 2
#define HEATER_PIN2 3
DriveCell Heater(HEATER_PIN1, HEATER_PIN2);
void setup() {
Heater.Init();
}
void loop() {
Heater.Drive(true, 100); // Maximum heat output
delay(5000);
Heater.Drive(true, 75); // Reduce heat to 75%
delay(5000);
Heater.Drive(true, 50); // Moderate heat at 50%
delay(5000);
Heater.Drive(true, 25); // Low heat at 25%
delay(5000);
}
Understanding the Functions:
direction
: true (activates the heating element)power_percent
: Adjusts the heat output (0 to 100%)⚠ Note: The Drive() function uses a high-speed PWM timer, making it compatible only with CodeCell and ESP32-based devices.
If you're using a standard Arduino, you can control the heat output using the following code. However, ensure that the waveform frequency is set correctly ideally ~20kHz
#define HEATER_PIN 2
void setup() {
pinMode(HEATER_PIN, OUTPUT);
}
void loop() {
analogWrite(HEATER_PIN, 255); // Maximum heat output
delay(5000);
analogWrite(HEATER_PIN, 191); // 75% Heat
delay(5000);
analogWrite(HEATER_PIN, 127); // 50% Heat
delay(5000);
analogWrite(HEATER_PIN, 63); // 25% Heat
delay(5000);
}
As we've learned by utilizing PWM control, CoilPad can be hacked into a micro-heater! Check out the DriveCell GitHub Repository for more code examples and technical documentation!
This guide explains how the CoilPad can generate vibrations, how frequency and polarity affect its movement, and how to create its drive signals.
To make CoilPad vibrate, an electric current is applied to its coil, generating a magnetic field. By reversing the polarity at a set frequency, we create a repetitive push-pull motion that causes vibrations.
The vibration frequency can be controlled within the range of 1 Hz to 25 Hz, which means CoilPad can oscillate 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.
If you attach it to something, you can adjust it to match its new resonant frequency and make the whole thing shake.
A square wave signal is required to make the CoilPad vibrate. An H-Bridge driver like our DriveCell is needed reverse its polarity and switch its polarity to make it vibrate. The input signals of the square wave can be generated using simple digitalWrite()
commands in Arduino:
#define VIB_PIN1 2
#define VIB_PIN2 3
void setup() {
pinMode(VIB_PIN1, OUTPUT);
pinMode(VIB_PIN2, OUTPUT);
}
void loop() {
digitalWrite(VIB_PIN1, HIGH);
digitalWrite(VIB_PIN2, LOW);
delay(100); // Adjust delay for desired vibration speed
digitalWrite(VIB_PIN1, LOW);
digitalWrite(VIB_PIN2, HIGH);
delay(100);
}
This simple code creates a square wave oscillation, making the CoilPad vibrate continuously. You can adjust the delay time to change the vibration frequency.
The code example above generates a basic square wave, which drives the coil in an abrupt on-off manner. At low frequencies, this might not be desirable. To smooth this out, we can use Pulse Width Modulation (PWM) on both outputs. This method gradually changes the magnetic field intensity, reducing mechanical stress on the CoilPad.
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 CoilPad1(IN1_pin1, IN1_pin2);
DriveCell CoilPad2(IN2_pin1, IN2_pin2);
uint16_t vibration_counter = 0;
void setup() {
CoilPad1.Init();
CoilPad2.Init();
CoilPad1.Tone();
CoilPad2.Tone();
}
void loop() {
delay(1);
vibration_counter++;
if (vibration_counter < 2000U) {
CoilPad1.Run(0, 100, 100); // Square Wave mode
CoilPad2.Run(0, 100, 100); // Square Wave mode
}
else if (vibration_counter < 8000U) {
CoilPad1.Run(1, 100, 1000); // Smooth PWM Wave mode
CoilPad2.Run(1, 100, 1000); // Smooth PWM Wave mode
} else {
vibration_counter = 0U;
}
}
Init()
→ Initializes DriveCell and sets up the input pins.
Run(smooth, power, speed_ms)
→ Oscillates the CoilPad in either a square wave or a smoother PWM wave.
smooth
→ 1
(PWM wave) / 0
(square wave)power
→ Magnetic-field strength (0 to 100%)speed_ms
→ Vibration 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 start using CoilPad to vibrate. Check out the DriveCell GitHub Repository for more code examples and technical documentation!
When working on projects that require movement or actuation, traditional motors can be bulky and challenging to integrate into compact designs. This is where CoilPad stands out - an incredibly thin coil designed to bring motion to your projects without taking any additional area.
In this post, we’ll explore the CoilPad’s fundamentals, functionality, and integration into your projects.
The CoilPad is a magnetic sticker actuator - just 0.1mm thin, flexible, and designed to stick onto flat or curved surfaces with a maximum bending radius of 18mm.
By adding a magnet, you can create oscillating motion, turning it into a tiny actuator, converting electrical energy into mechanical movement. You can also hack it into the thin buzzer, micro-heater, or metal-detector!
When an electric current flows through its ultra-thin coil, it generates a magnetic field that interacts with external magnets. Depending on the current's direction, the magnet will either be attracted or repelled, creating movement.
By applying a square wave signal, the CoilPad can also vibrate, flap or oscillate continuously with adjustable speed and intensity.
The CoilPad comes with a peelable adhesive back, allowing for quick and secure installation. Here’s how to apply it:
Clean the surface before attaching the CoilPad for a firm grip.
Peel off the adhesive cover using tweezers before powering the CoilPad.
Stick it onto the surface, ensuring it stays in place during operation.
Solder the terminals to your control circuit to start actuation.
Note: Always remove the adhesive cover before powering on the CoilPad to prevent damage to the adhesive layer.
To test your CoilPad:
Connect one pin to 5V and the other to ground – this will create an initial magnetic attraction or repulsion.
Swap the connections – reversing the polarity will switch the movement.
For continuous operation, use an H-Bridge circuit to automate the polarity switching. An H-Bridge is a circuit configuration composed of four transistors arranged in an "H" shape, allowing for bidirectional control of an actuator by reversing the current flow.
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 CoilPad today and bring motion to your next project!
CoilPad isn’t just a flexible coil actuator – it can also generate buzzing tones, much like a piezo buzzer. By sending a high-frequency signal, CoilPad 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 CoilPad, DriveCell makes the setup compact and easy to integrate into microcontroller projects.
CoilPad uses 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), CoilPad 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 CoilPad to a DriveCell module:
CoilPad can generate tones using PWM signals. Below is an example using DriveCell’s built-in functions for tone generation.
This example makes CoilPad buzz like a speaker, playing a sequence of tones:
#include <DriveCell.h>
#define IN1_pin1 2
#define IN1_pin2 3
DriveCell myCoilPad(IN1_pin1, IN1_pin2);
void setup() {
myCoilPad.Init(); /* Initialize FlatFlap with DriveCell */
myCoilPad.Tone(); /* Play a fixed tone with varying frequencies */
delay(500);
}
void loop() {
myCoilPad.Buzz(100); /* Buzz at 100 microseconds */
}
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 CoilPad:
/* 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, CoilPad 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!
The CoilPad 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 CoilPad?
The CoilPad is an actuator made from a flexible planar coil that adheres seamlessly to any smooth surface. By adding a magnet, it transforms into a device capable of magnetic movement, buzzing, or even heating. It’s designed to convert electrical energy into mechanical movement with ease.
How Does It Work?
The CoilPad features a flat, ultra-thin coil that interacts with external magnets. When an electric current passes through the coil, it generates a magnetic field that either attracts or repels the magnet, causing movement. By alternating the direction of the current, you can control the motion of the CoilPad. Applying a square wave signal makes the CoilPad oscillate continuously, with adjustable speed and intensity. For smooth organic motions, we will explore the DriveCell PWM library.
Installing CoilPad
The CoilPad design makes it easy to install. It comes with a peelable adhesive back, ensuring that it stays firmly attached to any smooth surface.
Getting Your CoilPad Moving
You can start testing it, by pulling one of its pins to 5V and the other to ground, then switch them around. In one instance, the magnet 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 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 CoilPad. 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 CoilPad 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 CoilPad.
1. Init()
First, we need a basic setup code to get you started:
#include <DriveCell.h> // This line includes the DriveCell library
DriveCell myCoilPad(IN1, IN2); // Replace IN1 and IN2 with your specific pins
void setup() {
myCoilPad.Init(); // Initializes your DriveCell connected to a CoilPad
}
This code gives the name 'myCoilPad' 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 CoilPad in a specified polarity. This quick energizing and de-energizing can cause a short, sharp movement of the CoilPad, depending on the polarity.
myCoilPad.Pulse(1, 10); // Sends a short burst for 10 milliseconds in the specified direction
3. Buzz(uint16_t us_buzz)
This function makes the CoilPad vibrate like a buzzer, which is useful for creating audible feedback.
myCoilPad.Buzz(100); // Makes the CoilPad buzz with a 100 microsecond pulses
4. Tone()
The Tone
function makes the CoilPad play a tone. This can be used for audible feedback or creative applications where sound is part of the interaction.
myCoilPad.Tone(); // Plays a tone by varying the frequency
5. Toggle(uint8_t power_percent)
This function toggles the CoilPad polarity, which can be useful for creating a rapid flapping movement or reversing direction quickly in your code.
myCoilPad.Toggle(100); // Toggles direction at 100% power
6. Run(bool smooth, uint8_t power_percent, uint16_t flip_speed_ms)
This function allows you to continuously flip the polarity of the CoilPad and control its motion speed and smoothness. If smooth
is set to true
, the actuation will be less sharp and smoothed, which is ideal for slower, controlled movements.
myCoilPad.Run(true, 50, 1000); // Runs the CoilPad smoothly at 50% power, flipping every 1000 milliseconds
7. Drive(bool direction, uint8_t power_percent)
This function lets you control the CoilPad polarity and its magnetic field strength by adjusting the power level.
myCoilPad.Drive(true, 75); // Moves the CoilPad forward at 75% power
Here's an example where we configure two CoilPads and actuate them at two different speeds:
#include <DriveCell.h>
#define IN1_pin1 2
#define IN1_pin2 3
#define IN2_pin1 5
#define IN2_pin2 6
DriveCell CoilPad1(IN1_pin1, IN1_pin2);
DriveCell CoilPad2(IN2_pin1, IN2_pin2);
uint16_t c_counter = 0;
void setup() {
CoilPad1.Init();
CoilPad2.Init();
CoilPad1.Tone();
CoilPad2.Tone();
}
void loop() {
delay(1);
c_counter++;
if (c_counter < 2000U) {
CoilPad1.Run(0, 100, 100);
CoilPad2.Run(0, 100, 100);
}
else if (c_counter < 8000U) {
CoilPad1.Run(1, 100, 1000);
CoilPad2.Run(1, 100, 1000);
} else {
c_counter = 0U;
}
}
Combining with CodeCell Sensors
To make it even more interactive you can combine the CoilPad and DriveCell with the tiny CodeCell Sensor Module. CodeCell is pin-to-pin compatible with DriveCell, supports all library functions, and can adds wireless control and interactive sensing to your project. This allows you to create more advanced, responsive elements with your CoilPad actuators.
With this next example the CodeCell controls two CoilPad that stops flapping when proximity is detected. Their magnetic field gets adjusted dynamically based on how close your hands gets. If no hand is detected it flips the CoilPad polarity every 400 milliseconds.
#include <CodeCell.h>
#include <DriveCell.h>
#define IN1_pin1 2
#define IN1_pin2 3
#define IN2_pin1 5
#define IN2_pin2 6
DriveCell CoilPad1(IN1_pin1, IN1_pin2);
DriveCell CoilPad2(IN2_pin1, IN2_pin2);
CodeCell myCodeCell;
void setup() {
Serial.begin(115200);
/* Set Serial baud rate to 115200. Ensure Tools/USB_CDC_On_Boot is enabled if using Serial. */
myCodeCell.Init(LIGHT); /*Initializes Light Sensing*/
CoilPad1.Init();
CoilPad2.Init();
CoilPad1.Tone();
CoilPad2.Tone();
}
void loop() {
if (myCodeCell.Run()) {
/*Runs every 100ms*/
uint16_t proximity = myCodeCell.Light_ProximityRead();
Serial.println(proximity);
if (proximity < 100) {
CoilPad1.Run(1, 100, 400);
CoilPad2.Run(1, 100, 400);
} else {
proximity = proximity - 100;
proximity = proximity / 10;
if (proximity > 100) {
proximity = 100;
}
CoilPad1.Drive(0, (proximity));
CoilPad2.Drive(0, (proximity));
}
}
}
Feel free to tweak the code with your own creative ideas, or add motion sensing for a new reaction! Get started today with our Arduino libraries! If you have any more question about the CoilPad feel free to email us and we will gladly help out!
Join our Community ~ Be the first to know about new products and get exciting deals!
© 2025 Microbots.