Menu 0

CoilPad

CoilPad - Creating a Magnetic Sensor

CoilPad - Creating a Magnetic Sensor

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! 

How It Works

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.

Setting Up the LC Oscillator for Metal Detection

To turn CoilPad into a metal detector, you need:

  • CoilPad (acts as the inductor)
  • A capacitor (to form the LC circuit)
  • A DriveCell to drive the coil
  • A microcontroller (such as CodeCell or an ESP32) to read the frequency changes

Circuit Setup:

  1. Connect a capacitor in parallel with CoilPad to create an LC resonant circuit.
  2. Use a microcontroller to generate a square wave at the circuit’s resonant frequency.
  3. Measure frequency shifts using a microcontroller’s input pin or frequency counter.
  4. Detect metal – When metal is placed near the coil, it alters the inductance, shifting the frequency.

Example Code

#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.

Using Two CoilPad for Wireless Transfer

CoilPad can also be used for wireless transfer by pairing two CoilPads tuned to the same resonant frequency.

How It Works:

  1. One CoilPad acts as a transmitter – driven at its resonant frequency.
  2. A second CoilPad + Capacitor – picks up the oscillating magnetic field.

Circuit Setup:

  • Transmitter: Connect a CoilPad to a DriveCell and a microcontroller to generate a PWM signal at the resonant frequency.
  • Receiver: Attach a second CoilPad with a capacitor in parallel and an LED in parallel. The value of the capacitor  will depend on the resonant frequency you use and can be calculated using this equation:

Where L is the inductance of the CoilPad which is 30.7uH 

Example DriveCell Transmitter Code:

#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!

Conclusion

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!

Read More

CoilPad - Creating a Micro-Heater

CoilPad - Creating a Micro-Heater

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.

Safety Considerations

  • Always handle CoilPad with care, as it can become hot.
  • Ensure that the surface it is attached to can withstand high temperatures.
  • Avoid direct skin contact when powered.
  • Use proper insulation if needed.

How It Works

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.

Heat Control

Several factors affect the heating performance of CoilPad:

  • Voltage Level – The maximum operating voltage is 5V. Higher voltages are not recommended as they may cause overheating or damage.
  • Duty Cycle – Adjusting the duty cycle of the PWM signal controls the heat output, allowing precise temperature regulation.
  • Thermal Dissipation – The surface to which CoilPad is attached will affect how heat is distributed and retained.

Using DriveCell to Control Heat Output

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:

  • Init() → Initializes DriveCell and sets up the input pins.
  • Drive(bool direction, uint8_t power_percent)
    • 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);
}

 

Conclusion

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!

Read More

CoilPad - Creating Vibration

CoilPad - Creating Vibration

This guide explains how the CoilPad can generate vibrations, how frequency and polarity affect its movement, and how to create its drive signals.

How it Works?

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.

Generating a Square Wave for Vibration

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.

Optimizing Vibration with PWM

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;
  }
}

Understanding the Functions:

  • 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.

Conclusion

With these techniques, you can start using CoilPad to vibrate. Check out the DriveCell GitHub Repository for more code examples and technical documentation!

Read More

Understanding CoilPad

Understanding CoilPad

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.

What is CoilPad?

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!

How Does CoilPad Work?

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.

  • Apply a voltage (5V) to one pin and ground (0V) to the other, a magnet is repelled or attracted. Reverse the polarity, makes the magnet moves in the opposite direction.
  • Use an H-Bridge or transistor to automate switching and make a CoilPad vibrate, flap or oscillate. An h-bridge like our tiny DriveCell modules, can adjust the speed of the oscillations and also the magnetic field strength of the coil, via Pulse width modulation (PWM). 
  • Adding an iron or steel plate beneath the CoilPad doubles the magnetic field strength, turning it into a very weak electromagnet.
  • When powering CoilPad at a constant 5V, can reach up to 100°C making it very useful as a micro-heater. However handle it with care to prevent injury.

    Installing CoilPad

    The CoilPad comes with a peelable adhesive back, allowing for quick and secure installation. Here’s how to apply it:

    1. Clean the surface before attaching the CoilPad for a firm grip.

    2. Peel off the adhesive cover using tweezers before powering the CoilPad.

    3. Stick it onto the surface, ensuring it stays in place during operation.

    4. 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.

    Getting Your CoilPad Moving

    To test your CoilPad:

    1. Connect one pin to 5V and the other to ground – this will create an initial magnetic attraction or repulsion.

    2. Swap the connections – reversing the polarity will switch the movement.

    3. 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.

    Keep things tiny

    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!

    Read More

    Using CoilPad to Generate Buzzing Tones

    Using CoilPad to Generate Buzzing Tones

    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.

    How CoilPad Produces Sound

    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:

    • Play basic tones → Useful for notifications
    • Play melodies → Generate melodies like the Super Mario song
    • Integrate into interactive designs → Add audible feedback to projects

    Wiring CoilPad 

    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.

    Basic Connection for Buzzing CoilPad

    Here’s how to wire CoilPad to a DriveCell module:

    1. Connect H-Bridge Output Pins to CoilPad:
      • OUT1 → CoilPad Pad 1
      • OUT2 → CoilPad Pad 2
    2. Connect H-Bridge Input Pins to the Microcontroller:
      • IN1 → Any digital pin
      • IN2 → Another digital pin
    3. Power Connections:
      • VCC → 5V maximum
      • GND → Common ground with the microcontroller


    Controlling CoilPad to Play Tones

    CoilPad can generate tones using PWM signals. Below is an example using DriveCell’s built-in functions for tone generation.

    1. Installing the Library

    1. Open Arduino IDE
    2. Go to Library Manager
    3. Search for DriveCell and install it

    2. Code Example for Playing a Tone on CoilPad

    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.

    3. Playing the Super Mario Theme on CoilPad

    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
  }

}

    Conclusion

    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!

    Read More

    CoilPad Basics: Your First Steps

    CoilPad Basics: Your First Steps

    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 and how does it work?
    • How to control its polarity, position, and speed
    • Making the CoilPad more interactive with the CodeCell sensors

    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
     

    Examples:

    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!

    Read More


    Follow

    Github

    Join our Community ~ Be the first to know about new products and get exciting deals!

    © 2025 Microbots.