DriveCell ne se limite pas à piloter des moteurs et des actionneurs : il peut également les faire générer des sons et des vibrations. En envoyant un signal sur la gamme de fréquences audibles, DriveCell peut créer différentes tonalités pouvant être diffusées sur des appareils tels que des buzzers piézoélectriques, des CoilPads, des FlatFlaps et même des moteurs. Il est ainsi utile pour les systèmes d'alerte ou les réponses interactives. Dans ce guide, nous explorerons comment DriveCell peut générer des bourdonnements, comment le câbler et comment l'utiliser pour diverses applications, des buzzers piézoélectriques aux CoilPads et aux vibrations de moteurs.
Le bourdonnement est obtenu en envoyant des impulsions électriques rapides à un appareil, le faisant osciller dans la plage de fréquences audibles (~20 Hz–20 kHz). DriveCell permet de contrôler ces impulsions grâce à la modulation de largeur d'impulsion (PWM), ce qui permet de générer des tonalités, des alertes et des vibrations.
Voici comment câbler un buzzer, un CoilPad ou un FlatFlap à DriveCell :
Pour générer des bourdonnements, DriveCell fournit Fonctions compatibles Arduino pour les tonalités de bourdonnement.
L'exemple suivant fait vibrer un buzzer, un CoilPad ou un FlatFlap à l'aide de la fonction intégrée de la bibliothèque DriveCell :
#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 à 100 microsecondes */
délai(500);
myDriveCell.Tone(); /* Jouer une tonalité fixe avec des fréquences variables */
délai(500);
}
Buzz(duration) → Génère un effet de bourdonnement :
duration → Fréquence du ton en microsecondes (ajuster pour changer l'intensité)Tone() → Joue une tonalité fixe intégrée à la bibliothèque⚠ Remarque : certains sons peuvent également être émis sur des moteurs à courant continu, mais vérifiez la fiche technique et évitez d'exécuter en continu des bourdonnements à haute fréquence sur des moteurs à balais, car cela peut provoquer une usure excessive.
Le petit module DriveCell simplifie le buzz ! Consultez le dépôt GitHub DriveCell pour plus d'exemples de code et de documentation technique !
Les LED haute puissance sont largement utilisées dans les projets d'éclairage, des lampes de poche aux bandes lumineuses en passant par les indicateurs de signalisation. Généralement, un seul transistor permet de commuter ou de faire varier l'intensité des LED haute puissance, mais DriveCell, un minuscule module en pont en H intégré au plus petit module, offre une alternative tout en supportant jusqu'à 1,8 A de courant continu.
Dans ce guide, nous explorerons comment DriveCell peut être utilisé pour contrôler des LED haute puissance ou des bandes LED monochromes, discuterons des configurations de câblage et démontrerons un effet de fondu à l'aide de sa bibliothèque.
DriveCell est construit autour du pont en H DRV8837, doté de quatre transistors en forme de « H » permettant un courant bidirectionnel. Un seul transistor suffit pour atténuer la luminosité des LED haute puissance. Si vous recherchez une solution compacte, DriveCell peut gérer jusqu'à 1,8 A de courant continu et s'intègre facilement aux microcontrôleurs.
Avant de connecter votre LED, il est essentiel de comprendre les limitations électriques de DriveCell :
Remarque : en matière d’éclairage, DriveCell est uniquement idéal pour contrôler la luminosité des bandes LED monochromes ou des LED haute puissance individuelles.
Voici comment câbler une seule LED ou une bande LED à DriveCell :
Pour ajuster dynamiquement la luminosité des LED, DriveCell propose une bibliothèque logicielle. Voici un exemple d'effet de fondu.
L'exemple suivant montre comment faire apparaître et disparaître progressivement une LED à l'aide de 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); /* Ajustez ce délai pour modifier la vitesse de fondu */
si (led_brightness_flag == 1) {
si (luminosité_led < 100U) {
led_brightness++;
} autre {
led_brightness_flag = 0;
}
} autre {
si (luminosité_led > 1U) {
led_brightness--;
} autre {
led_brightness_flag = 1;
}
}
LED.Drive(0, led_brightness); /* Affiche le nouveau niveau de luminosité */
}
Init() → Initialise DriveCell et configure les broches d'entréeDrive(direction, brightness) → Contrôle la luminosité des LED :
direction → 0 (polarité fixe pour les LED)brightness → Niveau de gradation (0 à 100 %)Ce code augmente et diminue progressivement la luminosité de la LED, créant un effet de décoloration douce.
⚠ Remarque : la fonction Drive() est uniquement compatible avec ESP32 et CodeCell, car elle utilise un minuteur PWM haute vitesse.
Vous trouverez ci-dessous un autre exemple qui peut être utilisé avec d’autres microcontrôleurs comme l’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
}
Cet exemple est tout simplement allume et éteint la LED toutes les secondes.
Le petit module DriveCell simplifie et accélère le contrôle des LED haute puissance ! Consultez le dépôt GitHub DriveCell pour plus d'exemples de code et de documentation technique !
Les actionneurs magnétiques, comme le CoilPad et le FlatFlap , utilisent des bobines PCB planes pour générer un faible champ magnétique interagissant avec les aimants, convertissant ainsi l'énergie électrique en énergie mécanique. DriveCell est idéal pour piloter ces actionneurs grâce à sa petite taille et à sa bibliothèque intuitive.
Les actionneurs magnétiques fonctionnent en faisant passer un courant dans une bobine, ce qui crée un champ magnétique qui interagit avec les aimants proches. Cela leur permet de vibrer ou d'osciller.
Contrairement aux moteurs à courant continu traditionnels, les actionneurs magnétiques nécessitent une commutation de polarité rapide et un contrôle précis pour fonctionner efficacement, c'est pourquoi des pilotes de pont en H comme DriveCell sont nécessaires.
Les actionneurs magnétiques s'appuyant sur des courants alternatifs, un circuit à transistor standard ne suffit pas. Le pont en H DRV8837 de DriveCell permet au courant de circuler dans les deux sens, offrant ainsi un contrôle total de la polarité et de l'intensité du champ magnétique.
Avant de connecter vos actionneurs, il est essentiel de comprendre les limitations électriques de DriveCell :
Remarque : le CoilPad et le FlatFlap consomment environ 200 mA, ce qui signifie que vous pouvez connecter jusqu'à 8 actionneurs en parallèle et les piloter à l'aide d'un seul DriveCell.
Voici comment souder/câbler un seul actionneur CoilPad ou FlatFlap à DriveCell :
Vous pouvez connecter plusieurs actionneurs en parallèle :
Cette configuration pilotera les deux actionneurs de manière synchronisée, les faisant s'activer simultanément.
Pour simplifier le contrôle des actionneurs, DriveCell propose une bibliothèque logicielle. Voici les principales fonctionnalités dont vous aurez besoin :
L'exemple suivant montre comment contrôler deux actionneurs avec des intensités différentes :
#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); // Activer la polarité nord de l'actionneur 2 à 80 % de puissance
délai(3000);
Actuator1.Drive(0, 50); // Activer la polarité sud de l'actionneur 1 à 50 % de puissance
Actuator2.Drive(1, 50); // Activer la polarité nord de l'actionneur 2 à 50 % de puissance
délai(3000);
Actuator1.Drive(0, 0); // Désactiver Actuator1
Actuator2.Drive(0, 100); // Activer la polarité sud de l'actionneur 2 à 100 % de puissance
}
Comprendre les fonctions :
Init() → Initialise DriveCell et configure les broches d'entréeDrive(direction, power) → Actionneur de commande :
direction → 1 (nord) / 0 (sud)power → Intensité du champ magnétique (0 à 100 %)Voici un autre exemple où nous configurons deux FlatFlaps et les faisons voleter à des vitesses différentes :
# include <DriveCell.h> # define IN1_pin1 2 # define IN1_pin2 3 # define IN2_pin1 5# définir IN2_pin2 6 DriveCell FlatFlap1 ( IN1_pin1 , IN1_pin2 ) ; DriveCell FlatFlap2 ( IN2_pin1 , IN2_pin2 ) ; uint16_t flap_counter = 0 ; configuration vide ( ) { FlatFlap1 .Init ( ) ; FlatFlap2 .Init ( ) ; FlatFlap1 . Tone ( ) ; FlatFlap2 . Tone ( ) ; } boucle vide ( ) { retard ( 1 ) ; compteur_volet ++ ; si ( compteur_flap < 2000U ) { FlatFlap1 . Exécuter ( 0 , 100 , 100 ) ; FlatFlap2 . Exécuter ( 0 , 100 , 100 ) ; } sinon si ( flap_counter < 8000U ) { FlatFlap1 . Exécuter ( 1 , 100 , 1000 ) ; FlatFlap2 . Exécuter ( 1 , 100 , 1000 ) ; } autre { compteur_flap = 0U ; FlatFlap1 . Drive ( 0 , 100 ) ; FlatFlap2 . Lecteur ( 1 , 100 ) ; retard ( 500 ) ; FlatFlap1 . Lecteur ( 1 , 100 ) ; FlatFlap2 . Lecteur ( 1 , 100 ) ; retard ( 500 ) ; FlatFlap1 . Lecteur ( 1 , 100 ) ; FlatFlap2 . Lecteur ( 0 , 100 ) ; retard ( 500 ) ; FlatFlap1 . Lecteur ( 1 , 100 ) ; FlatFlap2 . Lecteur ( 1 , 100 ) ; retard ( 500 ) ; FlatFlap1 . Lecteur ( 0 , 100 ) ; FlatFlap2 . Lecteur ( 0 , 100 ) ; retard ( 500 ) ; FlatFlap1 . Lecteur ( 1 , 100 ) ; FlatFlap2 . Lecteur ( 1 , 100 ) ; retard ( 500 ) ; FlatFlap1 . Tone ( ) ; FlatFlap2 . Tone ( ) ; } }
Comprendre les fonctions :
Run(smooth, power, speed_ms) → Osciller le FlatFlap soit dans une onde carrée, soit dans une onde PWM plus douce.
smooth → 1 (onde pwm) / 0 (onde carrée)power → Intensité du champ magnétique (0 à 100 %)power → Vitesse de retournement en millisecondes ⚠ Remarque : la fonction Run() & Drive() utilise un Minuterie PWM haute vitesse, la rendant compatible uniquement avec les appareils basés sur CodeCell et ESP32.
Vous trouverez ci-dessous un autre exemple qui peut être utilisé avec d’autres microcontrôleurs comme l’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
}
Cet exemple active l'actionneur en polarité nord pendant 1 seconde avant d'inverser la polarité, créant un mouvement d'onde carrée oscillante.
Le petit module DriveCell simplifie et accélère le contrôle des actionneurs magnétiques ! Consultez le dépôt GitHub DriveCell pour plus d'exemples de code et de documentation technique !
Lors de l'utilisation de moteurs CC à balais, le contrôle de leur vitesse et de leur direction est essentiel à la création de robots fonctionnels, de systèmes d'automatisation et de projets interactifs. DriveCell, un pilote de moteur compact basé sur le pont en H DRV8837, simplifie ce processus grâce à une bibliothèque intuitive. Dans ce guide, nous explorerons le fonctionnement de DriveCell, comment contrôler un moteur CC et comment connecter efficacement plusieurs moteurs.
Un moteur à courant continu à balais est un type de moteur électrique simple dans lequel le courant circule à travers un ensemble de balais et un collecteur pour créer un mouvement de rotation. Son fonctionnement repose sur le principe de l'induction électromagnétique, qui génère un champ magnétique à l'intérieur du moteur, le propulsant en rotation continue.
Contrairement aux servomoteurs ou aux moteurs pas à pas, les moteurs à courant continu à balais nécessitent deux signaux d'entrée pour contrôler leur mouvement :
C'est là qu'interviennent les pilotes de pont en H comme le DRV8837 de DriveCell. Le circuit de pont en H permet au courant de circuler dans les deux sens, permettant ainsi un contrôle bidirectionnel du moteur avec seulement deux broches d'entrée.
Avant de connecter vos moteurs, il est essentiel de comprendre les limitations électriques du DriveCell :
Si votre moteur nécessite moins de 0,5 A, vous pouvez également connecter deux moteurs en parallèle et les piloter à l'aide d'un seul DriveCell.
Voici comment câbler un seul moteur à courant continu à DriveCell :
Si vos moteurs consomment moins de 500 mA chacun, vous pouvez connecter deux moteurs en parallèle :
Cette configuration entraînera les deux moteurs de manière synchrone, les faisant tourner dans la même direction à la même vitesse.
Pour simplifier le contrôle des moteurs, DriveCell propose une bibliothèque logicielle. Voici les principales fonctionnalités dont vous aurez besoin :
L'exemple suivant montre comment contrôler deux moteurs à 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);
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); // Déplacement vers l'arrière à 100 % de la vitesse
}
⚠ Remarque : la fonction Drive() de cet exemple utilise un minuteur PWM haute vitesse, ce qui la rend compatible uniquement avec CodeCell et d'autres appareils basés sur ESP32.
Vous trouverez ci-dessous un autre exemple qui peut être utilisé avec d’autres microcontrôleurs comme l’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
}
Cet exemple fera tourner le moteur dans un sens pendant 1 seconde, puis inverser son sens direction , créant un mouvement oscillant simple.
Le petit module DriveCell simplifie et accélère le contrôle des moteurs à courant continu ! Consultez le dépôt GitHub DriveCell pour plus d'exemples de code et de documentation technique !
Lors de petits projets électroniques impliquant des moteurs ou des actionneurs, contrôler la vitesse et la direction peut s'avérer complexe. C'est là qu'intervient DriveCell. Intégré dans un module de la taille d'un doigt, DriveCell simplifie le contrôle des moteurs grâce à une minuscule puce en pont en H, le DRV8837, ce qui en fait une solution idéale pour la robotique, les actionneurs et même le contrôle des LED. Dans cet article, nous allons explorer les circuits de DriveCell et leur fonctionnement.
Au cœur de DriveCell se trouve la puce DRV8837, un driver en pont en H conçu pour gérer les moteurs et actionneurs CC basse consommation. Un pont en H est un circuit composé de quatre transistors disposés en « H », permettant le contrôle bidirectionnel d'un moteur par inversion du flux de courant. Le DRV8837 intègre cette fonctionnalité dans un format compact, offrant :
Bien que le DRV8837 simplifie le contrôle du moteur, le module DriveCell va encore plus loin en fournissant une bibliothèque logicielle facile à utiliser qui résume la programmation complexe, rendant le contrôle du moteur accessible même aux débutants.
Le module DriveCell fonctionne en fonction de l'état de ses deux broches d'entrée (IN1 et IN2) pour contrôler le flux de courant à travers ses broches de sortie :
IN1 = VCC/PWM , IN2 = GND → Le moteur tourne en sens directIN1 = GND , IN2 = VCC/PWM → Le moteur tourne en sens inverseIN1 = GND , IN2 = GND → Le moteur s'arrêtePour plus de clarté, une LED intégrée fournit un retour visuel, indiquant la direction de la sortie.
DriveCell est conçu pour être compact, efficace et facile à intégrer à divers projets. Voici pourquoi il se distingue :
Pour commencer à utiliser DriveCell, suivez ces étapes :
Soudez les broches de sortie à votre moteur ou actionneur et les broches d'entrée/alimentation à votre microcontrôleur. Les broches d'entrée déterminent l'état des broches de sortie :
Le réglage de IN1 à un niveau élevé rend OUT1 à un niveau élevé
Le VCC doit être connecté à une tension d'alimentation maximale de 5 V.
Bien que le câblage d'une broche d'entrée sur VCC active instantanément DriveCell, nous recommandons d'utiliser la bibliothèque DriveCell pour un contrôle automatique. Cette bibliothèque rend DriveCell extrêmement flexible et programmable.
Utilisez notre module CodeCell, conçu pour une compatibilité broche à broche avec DriveCell. Avec CodeCell, vous pouvez ajouter un contrôle sans fil et une détection interactive, ouvrant ainsi de nouvelles possibilités à vos projets.
DriveCell simplifie la complexité du contrôle moteur grâce à sa conception compacte. Que vous construisiez un mini-robot ou un actionneur magnétique, DriveCell vous offre un moyen simple de démarrer.
Consultez les schémas DriveCell ici pour explorer en détail la conception de son circuit et commencer à l'intégrer dans votre prochain projet !
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 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 :
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 :
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 :
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 !