CoilPad est une bobine PCB flexible et ultra-fine, adaptable à diverses applications, dont la détection de métaux. En associant CoilPad à un condensateur, vous pouvez créer un oscillateur LC sensible à la présence d'objets métalliques. De plus, deux CoilPad peuvent servir de transformateur, suffisant pour transmettre des données sans fil ou même alimenter une LED sans fil !
Lorsqu'un condensateur est placé en parallèle avec CoilPad, il forme un Circuit LC (circuit inductance-condensateur). Lorsqu'il est alimenté à sa fréquence de résonance, ce circuit oscille. L'approche d'un objet métallique perturbe le champ, modifiant ainsi la fréquence du circuit. Ce changement est détectable, permettant à CoilPad de fonctionner comme un simple détecteur de métaux.
Pour transformer CoilPad en détecteur de métaux, vous avez besoin de :
#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);
}
Ce code lit la fréquence et l'imprime sur le moniteur série, vous permettant d'observer les changements de fréquence lorsque du métal est à proximité.
CoilPad peut également être utilisé pour le transfert sans fil en associant deux CoilPads réglés sur la même fréquence de résonance.
Où L est l'inductance du CoilPad qui est de 30,7 uH
#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);
}
Lorsque le récepteur CoilPad est placé à proximité, la LED doit s'allumer, démontrant le transfert sans fil.
Au-delà du transfert de puissance, CoilPad permet également de transmettre des données en modulant la fréquence du signal côté émetteur et en détectant les variations côté récepteur. Génial !
Avec ces techniques, vous pouvez commencer à utiliser CoilPad pour détecter le métal ou même comme antenne sans fil.
Prêt à expérimenter ? Procurez-vous un CoilPad dès aujourd'hui et donnez du mouvement à votre prochain projet !
CoilPad est une bobine autocollante flexible et ultra-fine destinée à être utilisée comme actionneur magnétique. Cependant, elle peut également être transformée en micro-chauffage pour certaines applications spécialisées. Actionneur pouvant également fonctionner comme micro-chauffage.
En ajustant la forme d'onde PWM, vous pouvez faire varier la chaleur générée.
Alimenté à une tension constante de 5 V, le CoilPad peut atteindre jusqu'à 100 °C. Il est donc idéal pour les applications nécessitant un élément chauffant compact et homogène. La variation de la tension d'entrée permet de contrôler directement la chaleur produite. Ainsi, en alimentant le CoilPad avec un signal de modulation de largeur d'impulsion (MLI) plutôt qu'une alimentation constante, nous pouvons également faire varier la chaleur. Un rapport cyclique élevé augmente la production de chaleur, tandis qu'un rapport cyclique faible maintient une température plus basse.
Plusieurs facteurs affectent les performances de chauffage du CoilPad :
Si vous utilisez la bibliothèque DriveCell, vous pouvez facilement contrôler le CoilPad comme un micro-chauffage avec l'exemple suivant :
#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);
}
Comprendre les fonctions :
direction : vrai (active l'élément chauffant)power_percent : Règle la puissance calorifique (0 à 100 %)⚠ Remarque : la fonction Drive() utilise un minuteur PWM haute vitesse, ce qui la rend compatible uniquement avec les appareils basés sur CodeCell et ESP32.
Si vous utilisez un Arduino standard, vous pouvez contrôler la production de chaleur avec le code suivant. Cependant, assurez-vous que la fréquence de l'onde est correctement réglée, idéalement autour de 20 kHz.
#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);
}
Comme nous l'avons appris en utilisant le contrôle PWM, CoilPad peut être transformé en micro-chauffage ! Consultez le dépôt GitHub DriveCell pour plus d'exemples de code et de documentation technique !
Ce guide explique comment le CoilPad peut générer des vibrations, comment la fréquence et la polarité affectent son mouvement et comment créer ses signaux d'entraînement.
Pour faire vibrer le CoilPad, un courant électrique est appliqué à sa bobine, générant un champ magnétique. En inversant la polarité à une fréquence définie, on crée un mouvement de va-et-vient répétitif qui provoque des vibrations.
La fréquence de vibration peut être contrôlée entre 1 Hz et 25 Hz, ce qui signifie que CoilPad peut osciller entre 1 et 25 fois par seconde selon le signal d'entrée. Il peut atteindre des fréquences plus élevées, mais l'aimant n'a généralement pas le temps de réagir.
Si vous l'attachez à quelque chose, vous pouvez l'ajuster pour qu'il corresponde à sa nouvelle fréquence de résonance et faire trembler l'ensemble.
Un signal carré est nécessaire pour faire vibrer le CoilPad. Un pilote de pont en H comme notre DriveCell doit inverser sa polarité pour le faire vibrer. Les signaux d'entrée du signal carré peuvent être générés à l'aide de simples commandes digitalWrite() dans 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);
}
Ce code simple crée une oscillation carrée, faisant vibrer le CoilPad en continu. Vous pouvez ajuster le temps de retard pour modifier la fréquence de vibration.
L'exemple de code ci-dessus génère une onde carrée basique qui entraîne la bobine de manière brusque. À basses fréquences, cela peut être indésirable. Pour atténuer ce phénomène, nous pouvons utiliser la modulation de largeur d'impulsion (MLI) sur les deux sorties. Cette méthode modifie progressivement l'intensité du champ magnétique, réduisant ainsi les contraintes mécaniques sur le CoilPad.
Cette fonction est gérée automatiquement dans notre bibliothèque DriveCell :
#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();
}
boucle vide() {
retard(1);
compteur_de_vibrations++;
si (compteur_vibrations < 2000U) {
CoilPad1.Run(0, 100, 100); // Mode onde carrée
CoilPad2.Run(0, 100, 100); // Mode onde carrée
}
sinon si (compteur_vibrations < 8000U) {
CoilPad1.Run(1, 100, 1000); // Mode d'onde PWM lisse
CoilPad2.Run(1, 100, 1000); // Mode d'onde PWM lisse
} autre {
compteur_vibrations = 0U;
}
}
Init() → Initialise DriveCell et configure les broches d'entrée.Run(smooth, power, speed_ms) → Fait osciller le CoilPad 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 %)speed_ms → Vitesse de vibration en millisecondes ⚠ Remarque : la fonction Run() & Drive() utilise un minuteur PWM haute vitesse, ce qui la rend compatible uniquement avec les appareils CodeCell et ESP32.
Grâce à ces techniques, vous pouvez commencer à utiliser CoilPad pour faire vibrer vos appareils. Consultez le dépôt GitHub DriveCell pour plus d'exemples de code et de documentation technique !
Lors de projets nécessitant mouvement ou actionnement, les moteurs traditionnels peuvent être encombrants et difficiles à intégrer dans des conceptions compactes. C'est là que CoilPad se démarque : une bobine incroyablement fine conçue pour donner du mouvement à vos projets sans occuper d'espace supplémentaire.
Dans cet article, nous explorerons les fondamentaux, les fonctionnalités et l'intégration du CoilPad dans vos projets.
Le CoilPad est un actionneur d'autocollant magnétique - seulement 0,1 mm d'épaisseur, flexible et conçu pour coller sur des surfaces planes ou courbes avec un rayon de courbure maximal de 18 mm.
En ajoutant un aimant, vous pouvez créer un mouvement oscillant et le transformer en un minuscule actionneur, convertissant l'énergie électrique en mouvement mécanique. Vous pouvez également l'intégrer à un buzzer fin, un micro-chauffage ou un détecteur de métaux !
Lorsqu'un courant électrique traverse sa bobine ultra-fine, il génère un champ magnétique qui interagit avec les aimants externes. Selon le sens du courant, l'aimant est attiré ou repoussé, créant ainsi un mouvement.
En appliquant un signal d'onde carrée, le CoilPad peut également vibrer, battre ou osciller en continu avec une vitesse et une intensité réglables.
Le CoilPad est doté d'un dos adhésif pelable , permettant une installation rapide et sécurisée. Voici comment l'appliquer :
Nettoyez la surface avant de fixer le CoilPad pour une prise ferme.
Décollez le film adhésif à l'aide d'une pince à épiler avant de mettre le CoilPad sous tension.
Collez-le sur la surface en vous assurant qu'il reste en place pendant le fonctionnement.
Soudez les bornes à votre circuit de commande pour démarrer l'actionnement.
Remarque : retirez toujours le couvercle adhésif avant de mettre le CoilPad sous tension pour éviter d'endommager la couche adhésive.
Pour tester votre CoilPad :
Connectez une broche à 5 V et l’autre à la terre – cela créera une attraction ou une répulsion magnétique initiale.
Échangez les connexions : l’inversion de la polarité inversera le mouvement.
Pour un fonctionnement continu , utilisez un circuit en pont en H pour automatiser la commutation de polarité. Un pont en H est un circuit composé de quatre transistors disposés en « H », permettant le contrôle bidirectionnel d'un actionneur par inversion du flux de courant.
Soudez le CoilPad directement sur notre module DriveCell Pour une compacité optimale. Ce module intègre un pilote de pont en H DRV8837 dans un boîtier compact, conçu pour gérer les moteurs et actionneurs CC de faible puissance.
Prêt à expérimenter ? Procurez-vous un CoilPad dès aujourd'hui et donnez du mouvement à votre prochain projet !
CoilPad n'est pas seulement un actionneur à bobine flexible : il peut également générer des bourdonnements, à la manière d'un buzzer piézoélectrique. En envoyant un signal haute fréquence, CoilPad peut produire des sons et des vibrations audibles, ce qui le rend idéal pour les systèmes d'alerte, les réponses interactives et les installations sonores créatives.
Bien que vous puissiez utiliser n'importe quel pilote H-Bridge pour contrôler CoilPad, DriveCell rend la configuration compacte et facile à intégrer dans les projets de microcontrôleurs.
CoilPad utilise une fine bobine de cuivre et un aimant néodyme N52, créant un mouvement lorsqu'un courant électrique le traverse. En inversant rapidement le sens du courant à une fréquence audible (~100 Hz–10 kHz), CoilPad peut émettre des sons similaires à ceux d'un haut-parleur ou d'un buzzer piézoélectrique.
En variant la fréquence, vous pouvez :
Pour générer des tonalités, vous aurez besoin d'un pilote de moteur à pont en H (comme DriveCell) capable de changer rapidement le sens du courant. L'utilisation de DriveCell simplifie les connexions et rend l'installation plus compacte, mais tout module à pont en H standard peut également être utilisé.
Voici comment connecter CoilPad à un module DriveCell :
CoilPad peut générer des sons à l'aide de signaux PWM. Voici un exemple d'utilisation des fonctions intégrées de DriveCell pour la génération de sons.
Cet exemple fait vibrer CoilPad comme un haut-parleur, en jouant une séquence de tonalités :
#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 à 100 microsecondes */
}
Comprendre les fonctions :
Buzz(duration) → Génère un effet de bourdonnement à 100 microsecondes, contrôlant la vitesse de vibration.Tone() → Joue un tonalité audible, variant automatiquement sa fréquence. Astuce : En ajustant le fréquence et cycle de service, vous pouvez créer différentes notes de musique, alarmes ou sons de rétroaction.
Vous trouverez ci-dessous un autre exemple de code qui joue la chanson Super Mario à l'aide de 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
#définir la mélodiePin 5
//Mélodie du thème principal de Mario
int mélodie[] = {
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 les domine au rythme
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,
};
//Mélodie des Enfers
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
};
//Tempo Underworld
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
};
configuration vide(void)
{
pinMode(5, OUTPUT);//buzzer
pinMode(6, SORTIE);
digitalWrite(6, BAS);
}
boucle vide()
{
//chanter les airs
chanter(1);
chanter(1);
chanter(2);
}
int chanson = 0;
void chanter(int s) {
// parcourir les notes de la mélodie :
chanson = s;
si (chanson == 2) {
Serial.println(" 'Thème Underworld'");
int size = sizeof(underworld_melody) / sizeof(int);
pour (int thisNote = 0; thisNote < taille; thisNote++) {
// pour calculer la durée de la note, prenez une seconde
// divisé par le type de note.
//par exemple, noire = 1000 / 4, croche = 1000/8, etc.
int noteDuration = 1000 / underworld_tempo[thisNote];
buzz(melodyPin, underworld_melody[thisNote], noteDuration);
// pour distinguer les notes, définissez un temps minimum entre elles.
// la durée de la note + 30% semble bien fonctionner :
int pauseBetweenNotes = noteDuration * 1.30;
délai(pauseEntreLesNotes);
// arrête la lecture du son :
buzz(melodyPin, 0, noteDuration);
}
} autre {
Serial.println(" 'Thème Mario'");
int size = sizeof(mélodie) / sizeof(int);
pour (int thisNote = 0; thisNote < taille; thisNote++) {
// pour calculer la durée de la note, prenez une seconde
// divisé par le type de note.
//par exemple, noire = 1000 / 4, croche = 1000/8, etc.
int noteDuration = 1000 / tempo[cetteNote];
buzz(melodyPin, mélodie[thisNote], noteDuration);
// pour distinguer les notes, définissez un temps minimum entre elles.
// la durée de la note + 30% semble bien fonctionner :
int pauseBetweenNotes = noteDuration * 1.30;
délai(pauseEntreLesNotes);
// arrête la lecture du son :
buzz(melodyPin, 0, noteDuration);
}
}
}
void buzz(int targetPin, longue fréquence, longue longueur) {
long delayValue = 1000000 / frequency / 2; // calculer la valeur du délai entre les transitions
//// 1 seconde de microsecondes, divisée par la fréquence, puis divisée en deux puisque
//// il y a deux phases dans chaque cycle
long numCycles = fréquence * longueur / 1000; // calculer le nombre de cycles pour un timing correct
//// multipliez la fréquence, qui est en réalité le nombre de cycles par seconde, par le nombre de secondes pour
//// obtenir le nombre total de cycles à produire
for (long i = 0; i < numCycles; i++) { // pour la durée calculée...
digitalWrite(targetPin, HIGH); // écrire la broche du buzzer à l'état haut pour faire sortir le diaphragme
delayMicroseconds(delayValue); // attendre la valeur de délai calculée
digitalWrite(targetPin, LOW); // écrire la broche du buzzer au niveau bas pour retirer le diaphragme
delayMicroseconds(delayValue); // attendre à nouveau ou la valeur de délai calculée
}
}
Comme nous l'avons vu, CoilPad peut également produire des bourdonnements lorsqu'il est contrôlé par un module H-Bridge comme DriveCell. Consultez le dépôt GitHub DriveCell pour plus d'exemples de code et de documentation technique !
Le CoilPad est un actionneur incroyablement fin et innovant qui apporte du mouvement à vos projets dans un format compact. Pour comprendre son fonctionnement, plongeons-nous dans sa conception unique et les principes qui sous-tendent son fonctionnement.
Dans ce tutoriel, nous expliquerons :
Qu'est-ce qu'un CoilPad ?
Le CoilPad est un actionneur constitué d'une bobine plane flexible qui adhère parfaitement à toute surface lisse. En ajoutant un aimant, il se transforme en un appareil capable de mouvement magnétique, de bourdonnement ou même de chauffage. Il est conçu pour convertir facilement l'énergie électrique en mouvement mécanique.
Comment ça marche ?
Le CoilPad est doté d'une bobine plate et ultra-mince qui interagit avec des aimants externes. Lorsqu'un courant électrique traverse la bobine, il génère un champ magnétique qui attire ou repousse l'aimant, provoquant ainsi un mouvement. En alternant la direction du courant, vous pouvez contrôler le mouvement du CoilPad. L'application d'un signal d'onde carrée fait osciller le CoilPad en continu, avec une vitesse et une intensité réglables. Pour des mouvements organiques fluides, nous explorerons la bibliothèque DriveCell PWM.
Installation de CoilPad
La conception du CoilPad facilite son installation. Il est doté d'un dos adhésif pelable, garantissant qu'il reste fermement fixé sur toute surface lisse.
Faire bouger votre CoilPad
Vous pouvez commencer à le tester en tirant l'une de ses broches sur 5 V et l'autre sur la terre, puis en les intervertissant. Dans un cas, l'aimant sera repoussé et dans l'autre, il sera attiré. Vous pouvez le connecter à vos propres transistors ou à votre module de pont en H pour commuter ces broches automatiquement. Cependant, pour le rendre encore plus facile, vous pouvez acheter notre petit module DriveCell . Le DriveCell est un pilote de pont en H compact, compatible broche à broche, qui simplifie le processus de contrôle des actionneurs comme le CoilPad . Sa bibliothèque logicielle Arduino open source facilite le contrôle des actionneurs, en particulier pour les débutants, en fournissant des fonctions logicielles simples et des exemples faciles à suivre.
Pour un guide détaillé sur la bibliothèque logicielle DriveCell , consultez cet article . Mais voici un bref récapitulatif de la façon dont vous pouvez utiliser ses fonctions pour améliorer l'actionnement du CoilPad . Ne vous inquiétez pas, c'est assez simple ! Commencez par télécharger la bibliothèque « DriveCell » à partir du gestionnaire de bibliothèques d'Arduino. Une fois installée, vous serez prêt à contrôler votre appareil. Avant de commencer, assurez-vous de connecter le DriveCell à votre microcontrôleur. Nous vous recommandons d'utiliser un CodeCell, qui est compatible broche à broche, prend en charge toutes les fonctions de la bibliothèque et peut ajouter un contrôle sans fil et une détection interactive à votre CoilPad .
1. Init()
Tout d’abord, nous avons besoin d’un code de configuration de base pour vous permettre de démarrer :
#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
}
Ce code donne le nom « myCoilPad » à votre DriveCell et lui indique de démarrer et d'initialiser tous les périphériques nécessaires.
2. Impulsion (bool direction, uint8_t ms_duration)
Cette fonction envoie une brève décharge de puissance au CoilPad selon une polarité spécifiée. Cette mise sous tension et hors tension rapide peut provoquer un mouvement bref et brusque du CoilPad , selon la polarité.
myCoilPad.Pulse(1, 10); // Sends a short burst for 10 milliseconds in the specified direction3. Buzz (uint16_t us_buzz)
Cette fonction fait vibrer le CoilPad comme un buzzer, ce qui est utile pour créer un retour sonore.
myCoilPad.Buzz(100); // Makes the CoilPad buzz with a 100 microsecond pulses
4. Tonalité()
La fonction Tone permet au CoilPad de jouer un son. Elle peut être utilisée pour un retour sonore ou pour des applications créatives où le son fait partie de l'interaction.
myCoilPad.Tone(); // Plays a tone by varying the frequency
5. Basculer(uint8_t power_percent)
Cette fonction bascule la polarité du CoilPad , ce qui peut être utile pour créer un mouvement de battement rapide ou inverser rapidement la direction dans votre code.
myCoilPad.Toggle(100); // Toggles direction at 100% power
6. Exécuter(bool smooth, uint8_t power_percent, uint16_t flip_speed_ms)
Cette fonction vous permet d'inverser en continu la polarité du CoilPad et de contrôler sa vitesse de mouvement et sa fluidité. Si smooth est définie sur true , l'actionnement sera moins brusque et lissé, ce qui est idéal pour les mouvements plus lents et contrôlés.
myCoilPad.Run(true, 50, 1000); // Runs the CoilPad smoothly at 50% power, flipping every 1000 milliseconds
7. Drive(bool direction, uint8_t power_percent)
Cette fonction vous permet de contrôler la polarité du CoilPad et l'intensité de son champ magnétique en ajustant le niveau de puissance.
myCoilPad.Drive(true, 75); // Moves the CoilPad forward at 75% power
Voici un exemple où nous configurons deux CoilPads et les actionnons à deux vitesses différentes :
#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);
} autre {
c_counter = 0U;
}
}
Combinaison avec les capteurs CodeCell
Pour le rendre encore plus interactif, vous pouvez combiner le CoilPad et le DriveCell avec le petit module de capteur CodeCell. CodeCell est compatible broche à broche avec DriveCell , prend en charge toutes les fonctions de la bibliothèque et peut ajouter un contrôle sans fil et une détection interactive à votre projet. Cela vous permet de créer des éléments plus avancés et réactifs avec vos actionneurs CoilPad .
Avec cet exemple, le CodeCell contrôle deux CoilPad qui arrêtent de battre des ailes lorsqu'une proximité est détectée. Leur champ magnétique est ajusté de manière dynamique en fonction de la proximité de vos mains. Si aucune main n'est détectée, il inverse la polarité du CoilPad toutes les 400 millisecondes.
#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); /*Initialise la détection de lumière*/
CoilPad1.Init();
CoilPad2.Init();
CoilPad1.Tone();
CoilPad2.Tone();
}
boucle vide() {
si (myCodeCell.Run()) {
/*S'exécute toutes les 100 ms*/
uint16_t proximité = myCodeCell.Light_ProximityRead();
Serial.println(proximité);
si (proximité < 100) {
CoilPad1.Run(1, 100, 400);
CoilPad2.Run(1, 100, 400);
} autre {
proximité = proximité - 100 ;
proximité = proximité / 10 ;
si (proximité > 100) {
proximité = 100;
}
CoilPad1.Drive(0, (proximité));
CoilPad2.Drive(0, (proximité));
}
}
}
N'hésitez pas à modifier le code avec vos propres idées créatives ou à ajouter une détection de mouvement pour une nouvelle réaction ! Commencez dès aujourd'hui avec nos bibliothèques Arduino ! Si vous avez d'autres questions sur le CoilPad, n'hésitez pas à nous envoyer un e-mail et nous serons heureux de vous aider !