Cellule de conduite

DriveCell isn’t just for driving motors and actuators—it can also make them generate sound and vibrations. By sending a signal through the audible frequency range, DriveCell can create different tones that can be played on devices like piezo buzzers, CoilPads, FlatFlaps, and even motors. Making it useful for alert systems or interactive responses. In this guide, we’ll explore how DriveCell can generate buzzing tones, how to wire it, and how to use it for various applications, from piezo buzzers to CoilPad and motor vibrations.

How Buzzing Works with DriveCell

Buzzing is achieved by sending rapid electrical pulses to a device, causing it to oscillate within the audible frequency range (~20Hz–20kHz). DriveCell allows control over these pulses using PWM (Pulse Width Modulation), letting you generate tones, alerts and vibrations.

Wiring a Buzzer or Actuator to DriveCell

Basic Connection for a Buzzer or Actuator

Here’s how to wire a buzzer, CoilPad, or FlatFlap to DriveCell:

1. Connect DriveCell Output Pins to the Device:
   • OUT1 → Device Positive (+)
   • OUT2 → Device Negative (-)
2. Connect DriveCell 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 Buzzing with DriveCell Library

To generate buzzing tones, DriveCell provides Arduino-compatible functions for buzzing tones.

1. Installing the Library

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

2. Code Example for Generating a Buzzing 

The following example makes a buzzer, CoilPad, or FlatFlap buzz using DriveCell's library built-in function:

#include <DriveCell.h>

#define IN1_pin1 2
#define IN1_pin2 3

DriveCell myDriveCell(IN1_pin1, IN1_pin2);

void setup() {
  myDriveCell.Init(); /* Initialize DriveCell */
}

void loop() {
  myDriveCell.Buzz(100);  /* Buzz at 100 microseconds */
  delay(500);
  myDriveCell.Tone();  /* Play a fixed tone with varying frequencies */
  delay(500);
}

3. Understanding the Functions

• Buzz(duration) → Generates a buzzing effect:
  • duration → Tone frequency in microseconds (adjust to change intensity)
• Tone() → Plays a fixed tone built into the library

⚠ Note: Some sounds can also be played on DC motors, but check the datasheet and avoid running high-frequency buzzing on brushed motors continuously, as it may cause excessive wear.

Conclusion

The tiny DriveCell module makes buzzing simple! Check out the DriveCell GitHub Repository for more code examples and technical documentation!

High-power LEDs are widely used in lighting projects, from flashlights to light strips and signal indicators. Typically, a single transistor is used to switch or dim high-power LEDs, but DriveCell, a tiny H-Bridge module which is packaged into the smallest module, can provide an alternative while handling up to 1.8A of continuous current.

In this guide, we’ll explore how DriveCell can be used to control high-power LEDs or single-color LED strips, discuss wiring configurations, and demonstrate a fading effect using its library.

Why Use DriveCell for High-Power LEDs?

DriveCell is built around the DRV8837 H-Bridge which has four transistors in the shape of an 'H' to allow bi-directional current. You only require one transistor to dim the brightness of high-power LEDs - But if you're looking for a tiny solution DriveCell can handles up to 1.8A continuous current with an easy integration with microcontrollers.

DriveCell Specifications for High-Power LED Control

Before connecting your LED, it's essential to understand DriveCell’s electrical limitations:

• Operating Voltage: 1.8V to 5V (suitable for LED applications)
• Maximum Continuous Current: 1.8A (sufficient for most high-power LEDs or small LED strips)
• Built-in Protections: Overcurrent, undervoltage lockout, and thermal shutdown

Note: When it comes to lighting, DriveCell is only ideal for controlling the brightness of single-color LED strips or individual high-power LEDs.

Wiring a High-Power LED to DriveCell

Basic Connection for One LED

Here’s how to wire a single LED or LED strip to DriveCell:

1. Connect DriveCell Output Pins to the LED:
   • LED Positive (+) → OUT1
   • LED Negative (-) → Connect to Ground or OUT2 (while forcing it to ground with the input pin)
2. Connect DriveCell Input Pins to the Microcontroller:
   • IN1 → Connect to your Microcontroller (any digital PWM-capable pin)
   • IN2 → Connect to your Microcontroller (any digital PWM-capable pin)
3. Power Connections:
   • VCC → LED Voltage (e.g. 5V)
   • GND → Common ground with the Microcontroller

Controlling LED Brightness with DriveCell

To adjust LED brightness dynamically, DriveCell provides a software library. Below is an example of a fading effect.

1. Installing the Library

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

2. Code Example for LED Brightness Control

The following example demonstrates how to fade an LED in and out using DriveCell:

#include <DriveCell.h>

#define IN1_pin1 2
#define IN1_pin2 3

DriveCell LED(IN1_pin1, IN1_pin2); /* Pin2 will output the PWM signal, and Pin3 will be connected to 0V */

uint16_t led_brightness = 0;
bool led_brightness_flag = 1;

void setup() {
  LED.Init(); /* Initialize the LED */
}

void loop() {
  delay(10); /* Adjust this delay to change the fading speed */
  
  if (led_brightness_flag == 1) {
    if (led_brightness < 100U) {
      led_brightness++;
    } else {
      led_brightness_flag = 0;
    }
  } else {
    if (led_brightness > 1U) {
      led_brightness--;
    } else {
      led_brightness_flag = 1;
    }
  }
  
  LED.Drive(0, led_brightness); /* Output the new brightness level */
}

3. Understanding the Code

• Init() → Initializes DriveCell and sets up the input pins
• Drive(direction, brightness) → Controls LED brightness:
  • direction → 0 (fixed polarity for LEDs)
  • brightness → Dimming level (0 to 100%)

This code gradually increases and decreases the brightness of the LED, creating a smooth fading effect.

⚠ Note: The Drive() function is only compatible with ESP32 and CodeCell, as it uses a high-speed PWM timer.

Below is another example that can be used with other microcontrollers like the Arduino Uno:

#include <DriveCell.h>

#define IN1_pin1 2
#define IN1_pin2 3

DriveCell myLED(IN1_pin1, IN1_pin2);

void setup() {
  myLED.Init();
}

void loop() {
    myLED.Run(1000); // Blink LED on and off every 1 second
}

This example simply turns the LED on and off every second.

Conclusion

The tiny DriveCell module makes high-power LED control simple and easy to use! Check out the DriveCell GitHub Repository for more code examples and technical documentation!

Magnetic actuators, like the CoilPad and FlatFlap, use planar PCB coils to generate a small magnetic field to interact with magnets, converting electrical into mechanical energy. DriveCell is perfect for driving these actuators, because of its small size and easy to use library.

Understanding Magnetic Actuators & Why They Need DriveCell

What Are Magnetic Actuators?

Magnetic actuators work by passing current through a coil, which creates a magnetic field that interacts with nearby magnets. This allows them to vibrate or oscillate.

Unlike traditional DC motors, magnetic actuators require rapid polarity switching and precise control to function effectively, which is why H-Bridge drivers like DriveCell are required.

Why Use an H-Bridge Driver Like DriveCell?

Since magnetic actuators rely on alternating current directions, a standard transistor circuit won’t be enough. The DRV8837 H-Bridge in DriveCell allows current to flow in both directions, enabling full control over the polarity and intensity of the magnetic field.

DriveCell Specifications for Magnetic Actuators

Before connecting your actuators, it's essential to understand DriveCell’s electrical limitations:

• Operating Voltage: 1.8V to 5V 
• Maximum Continuous Current: 1.8A 
• H-Bridge Chip: DRV8837, allowing polarity switching & PWM control
• Built-in Protections: Overcurrent, undervoltage lockout, and thermal shutdown

Note: Both the CoilPad and the FlatFlap consume around 200mA - this means you can connect up 8 actuators in parallel, driving them using a single DriveCell.

Wiring a Magnetic Actuator to DriveCell

Basic Connection for One Actuator

Here’s how to solder/wire a single CoilPad or FlatFlap actuator to DriveCell:

1. Connect DriveCell Output Pins to the Actuator:
   • OUT1 → Actuator Terminal 1
   • OUT2 → Actuator Terminal 2
2. Connect DriveCell Input Pins to the Microcontroller:
   • IN1 → Any digital PWM-capable pin
   • IN2 → Another digital PWM-capable pin
3. Power Connections:
   • VCC → 5V (or up to 11V based on your actuator requirements)
   • GND → Common ground with the microcontroller

Parallel Connection for Multiple Actuators

You can connect multiple actuators in parallel:

• OUT1 → Both Actuator 1 and Actuator 2 terminal-1
• OUT2 → Both Actuator 1 and Actuator 2 terminal-2

This setup will drive both actuators in sync, making them activate simultaneously.

Controlling Magnetic Actuators with DriveCell Library

To simplify actuator control, DriveCell provides a software library. Below are the key functions you’ll need:

1. Installing the Library

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

2. Code Example

The following example demonstrates how to control two actuators with different intensities:

#include <DriveCell.h>

#define IN1_pin1 2
#define IN1_pin2 3
#define IN2_pin1 5
#define IN2_pin2 6

DriveCell Actuator1(IN1_pin1, IN1_pin2);
DriveCell Actuator2(IN2_pin1, IN2_pin2);

void setup() {
  Actuator1.Init();
  Actuator2.Init();
}

void loop() {
  delay(3000);
      Actuator1.Drive(1, 40); // Activate Actuator1 North-Polarity at 40% power
      Actuator2.Drive(1, 80); // Activate Actuator2 North-Polarity at 80% power
  delay(3000);
      Actuator1.Drive(0, 50); // Activate Actuator1 South-Polarity at 50% power
      Actuator2.Drive(1, 50); // Activate Actuator2 North-Polarity at 50% power
  delay(3000);
      Actuator1.Drive(0, 0); // Deactivate Actuator1
      Actuator2.Drive(0, 100); // Activate Actuator2 South-Polarity at 100% power
}

Understanding the Functions:

• Init() → Initializes DriveCell and sets up the input pins
• Drive(direction, power) → Controls actuator:
  • direction → 1 (north) / 0 (south)
  • power → Magnetic-field strength (0 to 100%)

Here's another 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();
  }
}

Understanding the Functions:

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

Below is another example that can be used with other microcontrollers like the Arduino Uno:

#include <DriveCell.h>

#define IN1_pin1 2
#define IN1_pin2 3

DriveCell myActuator(IN1_pin1, IN1_pin2);

void setup() {
  myActuator.Init();
}

void loop() {
    myActuator.Run(1000); // Activate actuator for 1 second, then reverse
}

This example activates the actuator in North-polarity for 1 second before reversing polarity, creating an oscillating square wave movement.

Conclusion

The tiny DriveCell module makes magnetic-actuator control simple and easy to use! Check out the DriveCell GitHub Repository for more code examples and technical documentation!

When working with brushed DC motors, controlling their speed and direction is key to building functional robotics, automation systems, and interactive projects. DriveCell is a tiny compact motor driver based on the DRV8837 H-Bridge, simplifies this process by providing an easy-to-use library. In this guide, we'll explore how DriveCell works, how to control a DC motor, and how to connect multiple motors efficiently.

Understanding Brushed DC Motors & Why They Need a DriveCell

A brushed DC motor is a simple type of electric motor where current flows through a set of brushes and a commutator to create rotational motion. It operates based on the principle of electromagnetic induction, which generates a magnetic field inside the motor, pushing it into continuous rotation.

Unlike servo motors or stepper motors, brushed DC motors require two input signals to control their movement:

• Direction control by reversing the current flow
• Speed control via PWM (Pulse Width Modulation)

This is where H-Bridge drivers like the DRV8837 in DriveCell come into play. The H-Bridge circuit allows current to flow in both directions, enabling bidirectional motor control with just two input pins.

DriveCell Specifications

Before connecting your motors, it's essential to understand the DriveCell's electrical limitations:

• Operating Voltage: 1.8V to 5V (suitable for small motors)
• Maximum Continuous Current: 1.8A
• H-Bridge Chip: DRV8837, handling motor direction & speed
• Built-in Protections: Overcurrent, undervoltage lockout, and thermal shutdown

If your motor requires less than 0.5A, you can also connect two motors in parallel and drive them using a single DriveCell.

Wiring a DC Motor to DriveCell

Basic Connection for One Motor

Here’s how to wire a single DC motor to DriveCell:

1. Connect DriveCell Output Pins to the Motor:
   • OUT1 → Motor Terminal 1
   • OUT2 → Motor Terminal 2
2. Connect DriveCell Input Pins to the Microcontroller:
   • IN1 → Any digital PWM-capable pin
   • IN2 → Another digital PWM-capable pin 
3. Power Connections:
   • VCC → 5V or less
   • GND → Common ground with the microcontroller

Parallel Connection for Two Motors

If your motors consume less than 500mA each, you can connect two motors in parallel:

• OUT1 → Both Motor 1 and Motor 2 terminals
• OUT2 → Both Motor 1 and Motor 2 terminals

This setup will drive both motors synchronously, making them spin in the same direction at the same speed.

Controlling the Motor with DriveCell Library

To make motor control simple, DriveCell provides an software library. Below are the key functions you’ll need:

1. Installing the Library

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

2. Code Example

The following example demonstrates how to control two motors at different speeds:

#include <DriveCell.h>

#define IN1_pin1 2
#define IN1_pin2 3
#define IN2_pin1 5
#define IN2_pin2 6

DriveCell Motor1(IN1_pin1, IN1_pin2);
DriveCell Motor2(IN2_pin1, IN2_pin2);

void setup() {
  Motor1.Init();
  Motor2.Init();
}

void loop() {
  delay(3000);   
      Motor1.Drive(1, 40); // Move Forward at 40% speed
      Motor2.Drive(1, 80); // Move Forward at 80% speed
  delay(3000);   
      Motor1.Drive(0, 50); // Move Backward at 50% speed
      Motor2.Drive(0, 50); // Move Backward at 50% speed
  delay(3000);   
      Motor1.Drive(0, 0); // Set to 0% speed
      Motor2.Drive(0, 100); // Move Backward at 100% speed 
}

⚠ Note: The Drive() function in this example uses a high-speed PWM timer, making it compatible only with CodeCell and other ESP32-based devices.

Below is another example that can be used with other microcontrollers like the Arduino Uno:

#include <DriveCell.h>

#define IN1_pin1 2
#define IN1_pin2 3

DriveCell myDriveCell(IN1_pin1, IN1_pin2);

void setup() {
  myDriveCell.Init();
}

void loop() {
    myDriveCell.Run(1000); // Run motor forward for 1 second, then reverse
}

This example will spin the motor in one direction for 1 second and then reverse its direction, creating a simple oscillating motion.

Conclusion

The tiny DriveCell module makes DC motor control simple and easy to use! Check out the DriveCell GitHub Repository for more code examples and technical documentation!

When working with small electronics projects that involve motors or actuators, controlling speed and direction can be a challenge. This is where DriveCell steps in. Packed into a fingertip-sized module, DriveCell simplifies motor control by utilizing a tiny H-Bridge chip, the DRV8837, making it an ideal solution for robotics, actuators, and even LED control. In this post, we’ll dive into the circuitry behind DriveCell and how it works.

The Heart of DriveCell: DRV8837 H-Bridge

At the core of DriveCell is the DRV8837 chip, an H-Bridge driver designed to handle low-power DC motors and actuators. An H-Bridge is a circuit configuration composed of four transistors arranged in an "H" shape, allowing for bidirectional control of a motor by reversing the current flow. The DRV8837 integrates this functionality into a compact form, offering:

• Motor Speed & Direction Control via two input pins
• PWM (Pulse Width Modulation) Support for fine-tuned control
• Overcurrent Protection, Undervoltage Lockout, and Thermal Shutdown for safety
• Maximum continuous output current of 1.8A, making it suitable for powering small but powerful dc motors or for powering multiple in parallel actuators like the CoilPad

Although the DRV8837 simplifies motor control, the DriveCell module takes it a step further by providing an easy-to-use software library that abstracts complex programming, making motor control accessible even to beginners.

Understanding DriveCell's Pinout & Functionality

The DriveCell module operates based on the state of its two input pins (IN1 and IN2) to control current flow through its output pins: 

• Forward Current: IN1 = VCC/PWM, IN2 = GND → Motor spins forward
• Reverse Current: IN1 = GND, IN2 = VCC/PWM → Motor spins in reverse
• Off State: IN1 = GND, IN2 = GND → Motor stops

For added clarity, an onboard LED provides visual feedback, indicating the direction of the output.

Why Choose DriveCell?

DriveCell is designed to be compact, efficient, and easy to integrate into various projects. Here’s why it stands out:

• Ultra-compact size – about the size of a fingertip
• Castellated pins for easy soldering and integration into custom PCBs
• Seamless compatibility with Arduino, CodeCell, and other microcontrollers
• No need for complex H-Bridge configurations – just a simple function call

Getting Started with DriveCell

To start using DriveCell, follow these steps:

1. Wiring DriveCell to Your Circuit

Solder the output pins to your motor or actuator and the input/power pins to your microcontroller. The input pins determine the state of the output pins:

• Setting IN1 high makes OUT1 high

• Setting IN2 high makes OUT2 high
• Typically, IN1 and IN2 are set in opposite polarities to allow current to flow through the motor

The VCC must be connected to a maximum supply voltage of 5V. 

2. Coding with the DriveCell Library

While wiring one of the input pins to VCC will instantly activate DriveCell, we recommend using the DriveCell Library for automatic control. This library makes DriveCell highly flexible and programmable.

Steps to Install the Library:

1. Open Arduino IDE
   
2. Go to Library Manager and search for “DriveCell”
3. Click Install
4. Load the example sketches to start experimenting!

3. Keeping things tiny

Use our CodeCell module which is designed to be pin-to-pin compatible with DriveCell. With CodeCell, you can add wireless control and interactive sensing, unlocking new possibilities for your projects.

Conclusion

DriveCell simplifies the complexities of motor control with a compact design. Whether you’re building a tiny robot or a magnetic actuator, DriveCell provides an easy way to get started.

Check out the DriveCell Schematics here to explore its circuit design in detail and start integrating it into your next project!

DriveCell est un appareil petit mais puissant qui vous permet de contrôler facilement les moteurs, les actionneurs et les lumières LED haute puissance pour vos projets de bricolage. DriveCell facilite le contrôle de ces composants, même si vous débutez en programmation ou en électronique.

Dans ce tutoriel, nous expliquerons :

• Qu'est-ce qu'un DriveCell et comment fonctionne-t-il ?
• Démarrer avec sa bibliothèque de logiciels Arduino
• Contrôlez deux moteurs à courant continu et entraînez-les à des vitesses différentes
• Fabriquer le DriveCell plus interactif avec les capteurs CodeCell

Qu'est-ce que DriveCell ?
Imaginez que vous vouliez fabriquer un petit robot et contrôler la vitesse et la direction de son moteur. Cela peut être complexe pour les débutants et nécessite généralement des modules volumineux. DriveCell simplifie ce processus car :

• C'est un pilote super petit (à peu près de la taille du bout de votre doigt)
• Peut être facilement soudé avec des broches en forme de C
• Fonctionne avec les microcontrôleurs Arduino et dispose de fonctions faciles à utiliser qui vous permettent de contrôler directement les moteurs, les actionneurs et les LED sans plonger dans une programmation compliquée.

Comment fonctionne DriveCell ?
DriveCell utilise une puce de pont en H DRV8837 intégrée pour contrôler le flux de courant à travers les broches de sortie, contrôlé par l'état des broches d'entrée :

• Courant direct : IN1 = VCC/PWM, IN2 = GND
• Courant inverse : IN1 = GND, IN2 = VCC/PWM
• Désactivé: IN1 = MASSE, IN2 = MASSE

La puce DRV8837 offre une protection contre les surintensités, un verrouillage en cas de sous-tension et des fonctions d'arrêt thermique, garantissant un fonctionnement sûr.

Premiers pas avec DriveCell
Avant de pouvoir commencer à utiliser DriveCell , vous devez le configurer et le connecter à votre projet. Voici un guide simple pour vous aider à démarrer :

• Connexion de DriveCell :

• Codage DriveCell :

1. Init()

Nous avons d’abord besoin d’un code de configuration de base pour vous permettre de démarrer :

 #include <DriveCell.h> // This line includes the DriveCell library

 DriveCell myDriveCell(IN1, IN2); // Replace IN1 and IN2 with your specific pins

 void setup() {
 myDriveCell.Init(); // Initializes the DriveCell
 }

Ce code indique au DriveCell de démarrer et de se préparer à contrôler votre moteur ou votre actionneur. La fonction Init s'assure que tous les périphériques nécessaires sont configurés.

2. Impulsion (bool direction, uint8_t ms_duration)

Cette commande envoie une courte rafale de puissance dans une polarité spécifiée, pour dynamiser rapidement l'actionneur et le réteindre.

 myDriveCell.Pulse(true, 10); // Short burst for 10 milliseconds

3. Buzz (uint16_t us_buzz)
Cela fait vibrer l'actionneur comme un buzzer. C'est idéal pour créer des sons de retour.

 myDriveCell.Buzz(100); // Creates a 100us buzzing sound

4. Tonalité()
Cette fonction émet une tonalité par défaut en faisant vibrer l'actionneur à différentes fréquences enregistrées.

 myDriveCell.Tone(); // Plays varying tones

5. Basculer(uint8_t power_percent)
Cette fonction change simplement le sens de rotation à 100 % de puissance, ce qui peut être utile pour inverser le sens de rotation d'un moteur à balais ou créer de simples mouvements de battement.

 myDriveCell.Toggle(); // Switches direction

En utilisant le CodeCell ou tout autre microcontrôleur ESP32, vous pouvez également ajuster le rapport cyclique « power_percent ». Pour les actionneurs magnétiques, le « power_percent » contrôle la force magnétique, tandis que pour les moteurs à balais, il ajuste la vitesse.

6. Exécuter(bool smooth, uint8_t power_percent, uint16_t flip_speed_ms)

En utilisant le CodeCell ou tout autre microcontrôleur ESP32, cette fonction vous permet d'inverser la polarité d'un actionneur ou d'inverser un moteur toutes les « flip_speed_ms » au cycle de service « power_percent ». Le réglage de « smooth » sur 1 adoucit le mouvement, ce qui est idéal pour piloter le FlatFlap ou le CoilPad avec des mouvements lents (moins de 2 Hz).

 myDriveCell.Run(true, 50, 1000); // Smooth drive at 50% power every 1000 ms

Pour les autres appareils Arduino, cette commande permet au moteur/actionneur d'inverser sa direction (vers l'avant et vers l'arrière) à pleine vitesse. Par exemple :

 myDriveCell.Run(500); // Motor changes direction every 500 milliseconds

7. Drive(bool direction, uint8_t power_percent)
En utilisant le CodeCell ou tout autre microcontrôleur ESP32, cette fonction vous permet de contrôler la vitesse et la direction de votre moteur. Vous pouvez faire avancer ou reculer le moteur et ajuster sa vitesse.

 myDriveCell.Drive(true, 75); // Moves forward at 75% power

Exemples :

En utilisant l'une de ces fonctions dans une boucle, vous pouvez créer la séquence souhaitée pour votre moteur, votre actionneur ou vos LED haute puissance. Voici un exemple où nous initialisons deux moteurs à courant continu et les pilotons à des vitesses différentes :

 #include <DriveCell.h>

 #define IN1_pin1 2
 #define IN1_pin2 3
 #define IN2_pin1 5
 #define IN2_pin2 6

 DriveCell Motor1(IN1_pin1, IN1_pin2);
 DriveCell Motor2(IN2_pin1, IN2_pin2);

 uint8_t mode = 0;
 uint8_t speed_percentage = 0;

 void setup() {
 Motor1.Init();
 Motor2.Init(); 
speed_percentage = 80; /* Régler le moteur à 80 % de puissance */
 }

 boucle vide() {
 délai(3000);
 mode++;
 commutateur (mode) {
 cas 1:
 /* Avancer */
 Motor1.Drive(1, pourcentage_vitesse);
 Motor2.Drive(1, pourcentage_vitesse);
 casser;
 cas 2:
 /* Déplacer vers l'arrière */
 Motor1.Drive(0, pourcentage_vitesse);
 Motor2.Drive(0, pourcentage_vitesse);
 casser;
 cas 3:
 /* Tourner à gauche */
 Motor1.Drive(1, pourcentage_vitesse);
 Motor2.Drive(0, pourcentage_vitesse);
 casser;
 cas 4:
 /* Tournez à droite */
 Motor1.Drive(0, pourcentage_vitesse);
 Motor2.Drive(1, pourcentage_vitesse);
 casser;
 cas 5:
 /* Éteignez les deux moteurs */
 Moteur1.Drive(1, 0);
 Moteur2.Drive(1, 0);
 si (pourcentage_vitesse < 95) {
 speed_percentage += 5; /* Incrémenter la vitesse */
 } autre {
 speed_percentage = 50; /* Réinitialiser à 50 % de puissance */
 }
 mode = 0;
 casser;
 }
 }

Dans l'exemple suivant, nous utilisons le capteur de proximité du CodeCell pour activer les moteurs. Ce capteur agira comme un interrupteur gestuel et s'activera lorsqu'une main se trouvera à moins de 5 cm.

 #include <CodeCell.h>
 #include <DriveCell.h>

 #define IN1_pin1 2
 #define IN1_pin2 3
 #define IN2_pin1 5
 #define IN2_pin2 6

 CodeCell myCodeCell;
 DriveCell Motor1(IN1_pin1, IN1_pin2);
 DriveCell Motor2(IN2_pin1, IN2_pin2);

 uint8_t speed_percentage = 0;
 bool on_flag = 0;

 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*/
 Motor1.Init();
 Motor2.Init();
 speed_percentage = 100;
 }

 void loop() {
 if (myCodeCell.Run()) {
 /*Runs every 100ms - Put your code here*/
 if (myCodeCell.Light_ProximityRead() > 3000) { 
/*Si un tapotement est détecté, la LED s'allume en jaune pendant 1 seconde*/
 monCodeCell.LED(0XA0, 0x60, 0x00U);
 Moteur1.Drive(0, 0);
 Moteur2.Drive(0, 0);
 délai(1000);
 sur_drapeau = !sur_drapeau;
 }
 si (sur_drapeau) {
 /*Avancer*/
 Motor1.Drive(1, pourcentage_vitesse);
 Motor2.Drive(1, pourcentage_vitesse);
 } autre {
 Moteur1.Drive(0, 0);
 Moteur2.Drive(0, 0);
 }
 }
 }

Si vous avez d'autres questions sur le DriveCell, n'hésitez pas à nous envoyer un e-mail et nous serons heureux de vous aider !