Apprendre

MotorCell est un moteur PCB ultra-compact et sans arbre conçu pour les applications à grande vitesse et à faible couple. Avec sa conception innovante en forme de crêpe et ses enroulements PCB plans, MotorCell est parfait pour la robotique, les installations artistiques et les projets de bricolage. Ce moteur simplifie l'intégration en utilisant un contrôle sans capteur avec des réglages de vitesse PWM.

Dans ce tutoriel, nous aborderons :

• Qu'est-ce que MotorCell et comment fonctionne-t-il ?
• Configuration de votre MotorCell
• Démarrer avec sa bibliothèque Arduino
• Exemples de projets pour donner vie à MotorCell

Qu'est-ce que MotorCell ?

Le MotorCell réinvente la conception des moteurs en intégrant le rotor, le stator et le driver dans un seul circuit imprimé plat. Cette structure unique :

• Réduit la taille à quelques millimètres d'épaisseur.
• Fournit un contrôle de vitesse via PWM et également un retour de vitesse.
• Fonctionne sans capteur, ce qui signifie moins de composants et une configuration plus facile.
• Simplifie l'intégration avec les broches à pas standard.

MotorCell est idéal pour les applications qui nécessitent des moteurs petits, légers et compacts, tels que la petite robotique, l'art cinétique ou même les gadgets portables.

Configuration de votre Mo torCell

Pour commencer, suivez ces étapes :

• Connecter votre MotorCell

• Installation de la bibliothèque MotorCell

 #include "MotorCell.h"

 #define IN_PIN 2
 #define OUT_PIN 3
 #define FR_PIN 1

 MotorCell myMotorCell(IN_PIN, OUT_PIN, FR_PIN);

 void setup() {
 myMotorCell.Init(); // Initialize the MotorCell
 }

Fonctions de la bibliothèque MotorCell

Voici les fonctions principales de la bibliothèque MotorCell :

• Init() : configure la MotorCell pour le fonctionnement.

myMotorCell.Init();

• Spin(uint8_t speed_percent) : fait tourner le moteur à une vitesse spécifiée (0–100 %).

 uint16_t rpm = myMotorCell.Spin(50); // Spin at 50% speed

• SpinPID(uint16_t target_rpm) : maintient un régime cible à l'aide du contrôle PID (nécessite ESP32/CodeCell).

 uint16_t rpm = myMotorCell.SpinPID(12000); // Maintain 12,000 RPM

• ReverseSpin() : Inverse le sens du moteur.

 myMotorCell.ReverseSpin();

• Pulse(uint8_t p_pin, uint8_t ms_duration) : envoie une courte impulsion à la broche spécifiée pendant une durée donnée (en millisecondes). Utile pour les rafales de mouvement rapides ou les signaux momentanés.

   myMotorCell.Pulse(FR_PIN, 50); // Sends a 50ms pulse to the FR_PIN
  

• RPMRead() : lit le régime actuel du moteur.

 uint16_t currentRPM = myMotorCell.RPMRead();

• MaxSpin() : fait tourner le moteur à la vitesse maximale.

 myMotorCell.MaxSpin();

Exemple de projet : surveillance du régime moteur

Voici un projet simple pour vous aider à démarrer :

 #include "MotorCell.h"

 #define IN_PIN 2
 #define OUT_PIN 3
 #define FR_PIN 4

 MotorCell myMotorCell(IN_PIN, OUT_PIN, FR_PIN);

 void setup() {
 Serial.begin(115200);
 myMotorCell.Init();
 }

 void loop() {
 uint16_t rpm = myMotorCell.Spin(50); // Spin at 50% speed
 }

Plus d'exemples disponibles sur github , mais si vous avez des questions sur MotorCell, n'hésitez pas à nous contacter !

Si vous venez d'acquérir le CodeCell , vous allez être comblé. Ce petit module est conçu pour simplifier vos projets DIY grâce à ses multiples fonctionnalités intégrées dans une carte de la taille d'un centime. Dans ce guide, nous vous expliquerons :

• Qu'est-ce qu'un CodeCell ? Et comment fonctionne son circuit ?
• Comment configurer et utiliser votre CodeCell
• Premiers pas avec des exemples
• Expliquez toutes les fonctions de la bibliothèque disponibles et comment vous pouvez les utiliser dans votre projet

Qu'est-ce qui fait un CodeCell ?

CodeCell est un module compact et polyvalent intégrant l'ESP32-C3, de multiples options d'alimentation et des capteurs intégrés, le tout dans un format compact de 1,85 cm de large. Ces caractéristiques en font un outil puissant pour un large éventail d'applications.

Dans cette première section, nous commencerons par nous familiariser avec les circuits qui composent le CodeCell . Ensuite, nous vous expliquerons les étapes simples de configuration de votre CodeCell .

Module ESP32C3

Au cœur du CodeCell se trouve le module ESP32C3, un microcontrôleur compact reconnu pour sa facilité d'utilisation dans le domaine de l'IoT. Il associe une architecture compatible Arduino aux fonctionnalités Wi-Fi et Bluetooth Low Energy (BLE) intégrées. Cette intégration offre les options de connectivité les plus courantes tout en conservant un format compact.

L'antenne PCB du module ESP32C3 est positionnée sur un côté, à l'écart des autres composants, afin de minimiser les interférences et d'améliorer la transmission et la réception du signal. Ce positionnement permet de réduire l'impact des plans de masse ou autres surfaces conductrices, susceptibles de dégrader les performances de l'antenne. Les composants situés sur la face inférieure sont maintenus dans les limites de dégagement recommandées pour l'antenne. Les tests ont montré que les performances de l'antenne ne sont pas affectées par les interférences minimes d'un câble USB-C, ces câbles étant généralement blindés.

L'ESP32-C3 dispose d'une mémoire importante, avec 4 Mo de Flash et 400 Ko de SRAM, lui permettant d'exécuter la plupart des applications courantes. Son processeur monocœur RISC-V 32 bits, cadencé jusqu'à 160 MHz, gère efficacement diverses tâches. Cette combinaison de mémoire et de puissance de traitement rend l'ESP32-C3 adapté à un large éventail d'utilisations.

Le module ESP32C3 prend également en charge un contrôleur USB série/JTAG, nous permettant de rendre le CodeCell reflashable via le port USB-C et d'envoyer des données série pour la communication et le débogage.

Gestion de l'alimentation

Le CodeCell offre une grande flexibilité d'alimentation. Il peut être alimenté par le connecteur de la batterie LiPo, par un câble USB-C, ou par les deux.

Le connecteur de batterie LiPo permet de connecter la batterie en toute sécurité plus facilement que jamais, sans avoir besoin de souder ni de risquer un court-circuit accidentel.

Le port USB-C a une double fonction : il permet d'alimenter l'appareil et/ou de le reprogrammer. Cette option multi-alimentation est activée par la puce de gestion de batterie BQ24232, dotée d'une gestion dynamique du chemin d'alimentation (DPPM) permettant d'alimenter le système tout en chargeant la batterie simultanément et indépendamment. Le processus de charge de la batterie se déroule en trois phases : précharge de conditionnement, courant constant et tension constante. Pour protéger la batterie, la tension de sortie (Vo) est régulée par la puce BQ24232. Cette sortie supporte un courant de sortie maximal de 1 500 mA lorsqu'elle est alimentée par la batterie LiPo et de 450 mA lorsqu'elle est alimentée par USB.

Par défaut, le courant de charge de la batterie LiPo est réglé à 90 mA, garantissant un taux de charge équilibré et sûr pour la batterie LiPo optionnelle de 170 mAh. De plus, pour ajuster le taux de charge, il est nécessaire de dessouder la résistance R12 en 0402 et de la remplacer par une nouvelle résistance selon la formule (R = 870/Ichrg). Cette solution est réservée aux soudeurs professionnels qui n'ont pas peur de manipuler de minuscules composants en 0402 ! Consultez la fiche technique du BQ24232 pour plus d'informations sur la charge de la batterie.

La bibliothèque CodeCell peut fournir un retour visuel sur l'état de la batterie/de l'alimentation USB via la LED RVB adressable intégrée :

• Avertissement de batterie faible : lorsque la tension de la batterie descend en dessous de 3,3 V, le voyant LED clignote en rouge dix fois et l'appareil passe en mode veille. Cela permet d'économiser l'énergie jusqu'à ce que l'appareil soit reconnecté à un chargeur USB.
• Processus de charge : Pendant la charge, le CodeCell suspend les applications, allume la LED bleue et attend que la batterie soit complètement chargée. Une fois la charge terminée, la LED émet une animation lumineuse clignotante indiquant la distance de proximité détectée par les capteurs.
• Alimenté par batterie : lorsque l'USBC est déconnecté et fonctionne sur batterie, le CodeCell s'allume à nouveau en vert et effectue une animation lumineuse respiratoire, indiquant la distance de proximité détectée par les capteurs.

La régulation de puissance est également assurée par plusieurs condensateurs de découplage, dont jusqu'à deux condensateurs de masse de 100 µF chacun, placés à proximité du connecteur de batterie. Ces condensateurs sont connectés aux broches 3,3 V et de sortie Vo pour assurer une alimentation stable. De plus, la carte est équipée de deux diodes TVS de protection : l'une préserve la tension d'entrée USB 5 V (Vin) et l'autre la tension de sortie (Vo). Ces diodes TVS offrent une protection contre les décharges électrostatiques (DES) et peuvent absorber en toute sécurité des décharges électrostatiques répétées supérieures au niveau maximal spécifié dans la norme internationale CEI 61000-4-2, sans dégradation des performances.

La carte intègre également un régulateur LDO (Low Dropout) de 3,3 V, qui assure une alimentation stable aux composants basse tension. Ce minuscule circuit LDO NCP177 peut délivrer un courant de sortie allant jusqu'à 500 mA avec une faible chute de tension typique de 200 mV à 500 mA.

Broches GPIO et d'alimentation

Compte tenu de la conception compacte, le principal défi consistait à optimiser l'utilisation des broches GPIO. Nous avons résolu ce problème en divisant chacun des trois côtés disponibles du CodeCell en sections d'E/S distinctes selon les applications. Nous avons également placé des broches d'alimentation le long des bords du module pour faciliter la connexion à diverses sources d'alimentation, permettant ainsi de connecter d'autres modules, capteurs et actionneurs sur les différents côtés.

Sur la face inférieure, trois des cinq broches sont utilisées pour l'alimentation : une broche de masse (GD), une broche d'alimentation logique 3,3 V (3V3) et une broche de charge d'entrée 5 V (5V0). Cette broche 5V0 est connectée à l'entrée USB. Vous pouvez ainsi l'utiliser pour obtenir une alimentation 5 V lorsque l'USB est connecté, ou comme entrée d'alimentation pour la charge. Les deux autres broches sont les broches I2C SDA et SCL, permettant d'ajouter des capteurs numériques externes. Si vous n'utilisez pas de capteurs externes ni de capteurs de lumière/mouvement, ces broches I2C peuvent être configurées comme GPIO.

Les deux autres côtés possèdent chacun une broche de masse (GD) et une broche de sortie de tension (VO). Chaque côté comporte également trois broches GPIO programmables (IO1, IO2, IO3, IO5, IO6, IO7), toutes configurables en broches PWM ( idéal pour connecter directement un pont en H pour le contrôle d'actionneurs/moteurs ). IO1, IO2 et IO3 peuvent également servir de broches CAN.

Les broches ADC supportent des tensions allant jusqu'à 3,3 V et, par défaut, la référence de tension de l'ADC est réglée sur 2,5 V. Veuillez noter que cette valeur ne peut pas être modifiée.

Capacités de détection

Le CodeCell se distingue par ses capteurs intégrés. Chaque unité est équipée d'un capteur de lumière intégré, et un capteur de mouvement est également disponible en option pour améliorer la détection de mouvement de votre projet, particulièrement utile pour la robotique et les objets connectés !

• Capteur de lumière VCNL4040 : Ce capteur mesure à la fois la luminosité et la proximité jusqu'à 20 cm. Sa conception haute résolution 16 bits combine un capteur de proximité, un capteur de lumière ambiante et un IRED haute puissance dans un boîtier compact. L'intégration de photodiodes, d'amplificateurs et d'un convertisseur analogique-numérique sur une seule puce lui confère des fonctionnalités améliorées. La configuration I₂C est directement intégrée à la bibliothèque CodeCell , ce qui garantit l'initialisation automatique du capteur pour optimiser sa résolution de détection.
• Capteur de mouvement BNO085 9 axes en option : Ce capteur IMU avancé est une mise à niveau coûteuse, mais nous pensons que l'investissement en vaut la peine ! Il améliore les capacités du CodeCell avec un accéléromètre, un gyroscope et un magnétomètre 3 axes intégrés. Les algorithmes avancés de fusion de capteurs du BNO085 combinent les données de ces capteurs pour déterminer avec précision les données de mouvement du capteur, telles que : la mesure de la rotation angulaire (roulis, tangage, lacet), l'état du mouvement (par exemple, sur table, stationnaire, en mouvement), l'activité (par exemple, conduite, marche, course), les mesures de l'accéléromètre, du gyroscope, du magnétomètre, de la gravité, de l'accélération linéaire, la détection des tapotements et le podomètre. 

Nous allons ensuite découvrir comment la bibliothèque CodeCell simplifie à la fois la configuration de ces capteurs et la lecture de leurs données.

Qu'en est-il de la broche BOOT ?

Certaines cartes de développement ESP32 incluent un bouton RST (Reset) et un bouton BOOT pour passer manuellement en mode programmation. Cependant, l'ESP32-C3, comme celui du module CodeCell, peut passer automatiquement en mode boot via l'interface série lors de l'utilisation de l'IDE Arduino. Ainsi, le CodeCell n'a pas besoin de boutons RST ou BOOT dédiés, ce qui nous a permis de le rendre aussi compact.

Dans le cas rare où votre CodeCell se bloque ou rencontre une exception (le forçant à se réinitialiser en permanence), vous pouvez le forcer manuellement à démarrer pour reflasher le firmware. Pour cela, suivez simplement ces étapes :

• Connectez un fil entre la broche SCL et la broche GND.
• Débranchez l'USB et éteignez la batterie (si elle est connectée).
• Reconnectez le port USB.
• Reprogrammez votre CodeCell avec un nouveau code - assurez-vous que votre code ne contient pas le bogue qui a créé le problème.
• Retirez le fil court-circuité entre la broche SCL et la broche GND. Remettez la batterie sous tension si elle est connectée.

En suivant ces étapes, votre CodeCell retrouvera sa vie.

Comment configurer et utiliser votre CodeCell ?

Pour rendre la programmation encore plus facile, le CodeCell La bibliothèque offre un large éventail de fonctions pour l'initialisation, la lecture et la gestion des capteurs et de l'alimentation. Dans cette section, nous vous expliquerons tout ce que vous devez savoir sur la configuration de votre appareil et de sa bibliothèque.

Déballage de votre CodeCell

Commençons par le contenu de la boîte. Selon les options sélectionnées lors du paiement, vous y trouverez :

1. CodeCell : la star du spectacle, votre carte minuscule mais puissante dotée du module ESP32-C3, de broches GPIO programmables et de capteurs.
2. Vis : Quatre vis M1,2 x 6 mm pour monter le CodeCell en toute sécurité dans vos projets.
3. Embases : Trois jeux d'embases femelles qui peuvent être livrées dessoudées ou soudées, selon votre choix.
4. Batterie/Câble : Selon votre choix lors du paiement, vous recevrez soit un câble de batterie gratuit pour connecter votre propre batterie au connecteur intégré du CodeCell , soit une batterie LiPo 170 mAh 20 C avec câble pré-soudé. Cette batterie optionnelle mesure 23 x 17,5 x 8,7 mm et ne pèse que 4,6 grammes. Cliquez ici pour accéder à la fiche technique de la batterie.

Mettre votre CodeCell sous tension pour la première fois

Commençons par brancher un câble USB-C ! Une fois votre CodeCell alimenté, il devrait :

• Initialisation : configuration des périphériques internes et des capteurs embarqués. Une fois cette opération terminée, un message « Hello World » est affiché sur le moniteur série.
• Vérification de l'alimentation : la carte surveille l'état de l'alimentation, vérifie si la batterie est connectée et si elle est en charge. Si aucune batterie n'est connectée, une animation lumineuse s'affiche grâce à la LED RVB intégrée. La vitesse d'animation varie en fonction de la proximité du capteur de lumière : approchez votre main pour ralentir. Éloignez-la pour accélérer ! La LED clignote en bleu ou en vert selon que la carte est alimentée par USB ou par batterie. Si la batterie est en charge, la LED reste bleue fixe jusqu'à la charge complète.

Configuration de votre CodeCell

L'étape suivante consiste à connecter le CodeCell à l'IDE Arduino et à exécuter un croquis :

1. Connexion USB : connectez votre CodeCell à votre PC à l'aide d'un câble USB-C standard. Ce câble alimente la carte et permet également sa reprogrammation.
2. Installez l'IDE Arduino : Si vous êtes nouveau dans le monde Arduino, ne vous inquiétez pas, téléchargez et installez simplement la dernière version gratuite du logiciel IDE Arduino à partir du site officiel d'Arduino .
3. Ajouter l'URL du gestionnaire de cartes ESP32 : si vous n'avez jamais utilisé d'ESP32, ouvrez l'IDE Arduino et accédez à « Fichier > Préférences ». Dans le champ « URL supplémentaires du gestionnaire de cartes », saisissez : https://dl.espressif.com/dl/package_esp32_index.json », puis cliquez sur OK. Accédez ensuite à « Outils > Carte > Gestionnaire de cartes ». Recherchez « ESP32 » et cliquez sur « Installer ».
4. Sélectionnez la carte : L'étape suivante consiste à sélectionner notre carte. Accédez à « Outils > Carte » et choisissez « Module de développement ESP32C3 ». Dans quelques semaines, vous pourrez rechercher directement « CodeCell ». Pour l'instant, sélectionner « Module de développement ESP32C3 » fonctionne parfaitement, car il s'agit du microcontrôleur intégré au CodeCell .
5. Sélectionnez le port : allez dans « Outils > Port » et sélectionnez le port COM correspondant à votre CodeCell .
6. Autres paramètres : Accédez à « Outils > USB_CDC_On_Boot » et assurez-vous que cette option est activée si vous prévoyez d'utiliser le moniteur série. Réglez également la fréquence d'horloge sur 160 MHz.

Une fois votre IDE configuré, vous pouvez maintenant installer la bibliothèque « CodeCell ». Pour cela, allez dans « Sketch > Inclure la bibliothèque > Gérer les bibliothèques » ; le « Gestionnaire de bibliothèques » devrait s'ouvrir. Saisissez simplement « CodeCell » et cliquez sur « Installer » pour télécharger la dernière version de CodeCell .

Nous mettons continuellement à jour et ajoutons de nouvelles fonctionnalités à cette bibliothèque, alors assurez-vous d'utiliser la dernière version.

Pour vous familiariser rapidement avec cette bibliothèque, accédez à « Fichier > Exemples > CodeCell », où vous trouverez de nombreux exemples à utiliser et à modifier pour vos projets. Nous vous recommandons de commencer par l'exemple « GettingStarted », qui ne contient que quelques lignes de code, mais qui explique toutes les fonctionnalités de détection disponibles avec CodeCell .

Après avoir sélectionné un exemple de croquis, cliquez sur le bouton « Télécharger » pour charger le code sur votre CodeCell. Après le téléchargement, ouvrez le Moniteur série « Outils > Moniteur série » pour afficher les données série de votre CodeCell.

Voici quelques tutoriels CodeCell supplémentaires pour vous aider à démarrer avec diverses applications :

• Gestes de profondeur
• Détection de tapotement
• Proximité
• Gradation automatique
• Compteur de pas
• Contrôle d'angle
• Activité personnelle devinette
• Télécommande sans fil
• Invite d'IA
• Contrôle de la lumière Alexa

Fonctions de la bibliothèque CodeCell

Pour explorer davantage le code, décomposons toutes les fonctions et expliquons ce que fait chacune d'elles :

Initialisation de CodeCell

La première étape de l'utilisation du CodeCell Il s'agit de l'initialiser. Pour ce faire, utilisez la fonction `myCodeCell.Init()`, qui permet de spécifier les capteurs à activer.

Macros de détection disponibles :

• LUMIÈRE - Active la détection de lumière.
• MOTION_ACCELEROMETRE - Active la détection de l'accéléromètre.
• MOUVEMENT_GYRO - Active la détection du gyroscope.
• MOTION_MAGNETOMETRE - Permet la détection du magnétomètre.
• MOUVEMENT_LINÉAIRE_ACC - Permet la détection d'accélération linéaire.
• MOUVEMENT_GRAVITÉ - Active la détection de la gravité.
• MOUVEMENT_ROTATION - Active la détection de rotation.
• MOUVEMENT_ROTATION_SANS_MAG - Permet la détection de rotation sans magnétomètre.
• COMPTEUR_DE_PAS_DE_MOUVEMENT - Active le compteur de pas de marche.
• ÉTAT_MOUVEMENT - Active la détection de l'état de mouvement.
• DÉTECTEUR DE MOUVEMENT - Active le détecteur de tapotement.
• MOTION_ACTIVITY - Active la reconnaissance de l'activité de mouvement.

Vous pouvez combiner plusieurs macros à l'aide de l'opérateur « + » pour initialiser plusieurs capteurs à la fois.

Gestion du pouvoir

Appelez la fonction myCodeCell.Run(frequency) dans la boucle loop() pour gérer l'état de l'alimentation. Cette fonction gère également la LED intégrée pour indiquer l'état de l'alimentation.

Comportement de la fonction Run() :

• Cette fonction renvoie vrai à la fréquence spécifiée, entre 10 Hz et 100 Hz, selon la valeur passée. Cette fonction peut être utilisée pour des opérations temporelles. Par exemple, Run(10) renvoie vrai toutes les 10 Hz et Run(100) renvoie vrai toutes les 100 Hz.
• L'état de la batterie et de l'alimentation est vérifié toutes les 10 Hz. La LED intégrée indique les différents états d'alimentation :
• Clignotement rouge (clignotement 10 fois) - Tension de la batterie inférieure à 3,3 V, entrée en mode veille jusqu'à ce que le câble USB soit connecté pour le chargement.
• LED verte (animation respiratoire) - Alimenté par batterie
• LED bleue (statique) - La batterie est en charge
• LED verte (statique) - La batterie est complètement chargée
• LED bleue (animation respiratoire) - Alimentation USB

Pendant la charge, le CodeCell ferme l'application, allume la LED bleue fixe et attend que la batterie soit complètement chargée. Une fois la charge terminée, la LED devient verte fixe. Une fois le câble débranché, une animation lumineuse verte s'allume, dont la vitesse correspond à la distance de proximité. L'animation s'allume en vert lorsqu'elle est alimentée par la batterie et en bleu lorsqu'elle est alimentée par USB.

Lecture des données du capteur

Après avoir initialisé les capteurs, vous pouvez lire leurs données grâce aux différentes fonctions fournies par la bibliothèque. Voici un bref aperçu des fonctions disponibles :

Fonctions du capteur de lumière :

• Light_ProximityRead() - Lit la valeur de proximité du capteur de lumière.
• Light_WhiteRead() - Lit l'intensité de la lumière blanche à partir du capteur de lumière.
• Light_AmbientRead() - Lit l'intensité lumineuse ambiante à partir du capteur de lumière.

Fonctions du capteur de mouvement :

• Motion_AccelerometerRead(float &x, float &y, float &z) - Lit les données d'accélération le long des axes x, y et z.
• Motion_GyroRead(float &x, float &y, float &z) - Lit les données de vitesse de rotation le long des axes x, y et z.
• Motion_MagnetometerRead(float &x, float &y, float &z) - Lit les données d'intensité du champ magnétique le long des axes x, y et z.
• Motion_GravityRead(float &x, float &y, float &z) - Lit les données du vecteur de gravité le long des axes x, y et z.
• Motion_LinearAccRead(float &x, float &y, float &z) - Lit les données d'accélération linéaire le long des axes x, y et z.
• Motion_TapRead(uint16_t &x) - Lit le nombre de taps détectés.
• Motion_StepCounterRead(uint16_t &x) - Lit le nombre de pas comptés.
• Motion_RotationRead(float &roll, float &pitch, float &yaw) - Lit les données de rotation angulaire (roulis, tangage, lacet).
• Motion_RotationNoMagRead(float &roll, float &pitch, float &yaw) - Lit les données de rotation angulaire sans utiliser le magnétomètre.
• Motion_StateRead(uint16_t &x) - Lit l'état actuel (par exemple, Sur table, Stationnaire, Mouvement).
• Motion_ActivityRead(uint16_t &x) - Lit l'activité en cours (par exemple, conduite, marche, course).

Exemple d'utilisation :

Fonctions veille, économie d'énergie, diagnostic et LED

Le CodeCell comprend plusieurs fonctions pour gérer les modes veille et économie d'énergie :

• WakeUpCheck() - Vérifie la raison du réveil de l'appareil. Si l'appareil se réveille suite à un événement de minuterie, renvoie « true » ; sinon, renvoie « false ».
• Sleep(uint16_t sleep_sec) - Place l'appareil en veille prolongée pendant une durée spécifiée en secondes. Il configure les broches et capteurs nécessaires à une faible consommation d'énergie avant de passer en mode veille.
• USBSleep(bool cable_polarity) - Gère le mode veille de l'appareil lorsque le niveau de batterie est faible ou lorsqu'il est en charge via USB. Il ferme l'application et prépare l'appareil à la mise en veille pour permettre une reprogrammation si nécessaire.
• PrintSensors() – Imprime les relevés actuels de tous les capteurs initialisés sur le moniteur série. Cette fonction est particulièrement utile pour le débogage et l'enregistrement des données.
• BatteryRead() - Cette fonction lit et renvoie la tension de la batterie lorsque le port USB-C est déconnecté.
• LED_Breathing(uint32_t rgb_color_24bit) - Cette fonction est utilisée dans le gestionnaire Run() pour contrôler la LED intégrée et créer un effet de respiration d'une couleur spécifique. Le paramètre `rgb_color_24bit` est une valeur de couleur 24 bits représentant la couleur RVB. Soyez prudent lorsque vous utilisez cette fonction, car la fonction 'Run' pourrait écraser la couleur de votre LED.
• LED(uint8_t r, uint8_t g, uint8_t b) - Cette fonction définit la couleur de la LED adressable intégrée selon le modèle RVB, où « r », « g » et « b » sont des valeurs 8 bits représentant les composantes rouge, verte et bleue de la couleur. Chaque composante est comprise entre 0 et 255. Soyez prudent lorsque vous utilisez cette fonction, car la fonction « Exécuter » risque d'écraser la couleur de votre LED.

Félicitations!

Vous avez maintenant fait vos premiers pas avec CodeCell . Explorez les exemples de la bibliothèque, explorez les intégrations de capteurs et donnez vie à vos projets innovants avec CodeCell !

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 et comment ça marche ?
• Comment contrôler sa polarité, sa position et sa vitesse
• Fabrication du CoilPad plus interactif avec les capteurs CodeCell

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 direction

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

Exemples :

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 rendre le projet encore plus interactif, vous pouvez combiner le CoilPad et le DriveCell avec le minuscule 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 plus 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 !

Le FlatFlap 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 FlatFlap et comment ça marche ?
• Comment contrôler sa polarité, sa position et sa vitesse
• Fabriquer le FlatFlap plus interactif avec les capteurs CodeCell

Qu'est-ce qu'un FlatFlap ?

C'est plat et c'est un volet ~ le FlatFlap est un actionneur fabriqué à partir d'un circuit imprimé flexible et de raidisseurs en aluminium, pliés ensemble pour créer un mouvement de battement à faible force. Son système magnétique convertit l'énergie électrique en mouvement mécanique.

Comment ça marche ?

Le FlatFlap est doté d'un aimant en néodyme N52 fin de 10 mm à l'arrière, qui interagit avec la bobine de cuivre plane intégrée dans le PCB flexible. Lorsqu'un courant électrique traverse la bobine, il génère un petit champ magnétique qui attire ou repousse l'aimant, provoquant le mouvement du volet. En alternant la direction du courant, vous pouvez contrôler le mouvement de battement de l'actionneur. L'application d'un signal d'onde carrée permet au FlatFlap de se rabattre en continu, avec des vitesses allant jusqu'à 25 Hz. Pour des mouvements organiques fluides, nous explorerons la bibliothèque DriveCell PWM.

Installation de FlatFlap

La conception FlatFlap facilite l'installation. Il est doté d'un dos adhésif pelable et de vis M1.2 en option (incluses) pour plus de sécurité, garantissant qu'il reste fermement fixé à n'importe quelle surface, qu'elle soit lisse ou texturée. L'adhésif est 3M467, qui offre une forte adhérence mais peut être retiré avec une pince à épiler si nécessaire.

Faire bouger votre FlatFlap

Si vous avez acheté le FlatFlap en tant qu'actionneur autonome, vous pouvez commencer par tirer l'une de ses broches sur 5 V et l'autre sur la terre, puis les inverser. Dans un cas, le volet 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 rendre les choses encore plus faciles, vous pouvez acheter le FlatFlap directement soudé à 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 FlatFlap . 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 FlatFlap . 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 FlatFlap .

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 myFlatFlap(IN1, IN2); // Replace IN1 and IN2 with your specific pins

 void setup() {
 myFlatFlap.Init(); // Initializes your DriveCell connected to a FlatFlap
 }

Ce code donne le nom « myFlatFlap » à 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 courant au FlatFlap selon une polarité spécifiée. Cette mise sous tension et hors tension rapide peut provoquer un mouvement bref et brusque du FlatFlap , selon la polarité.

 myFlatFlap.Pulse(1, 10); // Sends a short burst for 10 milliseconds in the specified direction

2. Buzz (uint16_t us_buzz)

Cette fonction fait vibrer le FlatFlap comme un buzzer, ce qui est utile pour créer un retour sonore.

 myFlatFlap.Buzz(100); // Makes the FlatFlap buzz with a 100 microsecond pulses

3. Tonalité()

La fonction Tone permet au FlatFlap 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.

 myFlatFlap.Tone(); // Plays a tone by varying the frequency

4. Basculer (uint8_t power_percent)

Cette fonction change la direction de FlatFlap , ce qui peut être utile pour créer un mouvement de battement rapide ou inverser rapidement la direction dans votre code.

 myFlatFlap.Toggle(100); // Toggles direction at 100% power

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

Cette fonction vous permet d'inverser en continu la polarité du FlatFlap et de contrôler sa vitesse de mouvement et sa fluidité. Si smooth est défini sur true , le battement sera moins net et lissé, ce qui est idéal pour des mouvements plus lents et contrôlés.

 myFlatFlap.Run(true, 50, 1000); // Runs the FlatFlap smoothly at 50% power, flipping every 1000 milliseconds

6. Drive(bool direction, uint8_t power_percent)

Cette fonction vous permet de contrôler la polarité et la position angulaire du FlatFlap en ajustant le niveau de puissance, en ajustant essentiellement la force de l'attraction ou de la poussée magnétique.

myFlatFlap.Drive(true, 75); // Moves the FlatFlap forward at 75% power

Exemples :

Voici un exemple dans lequel 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
 #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);
 délai(500);
 FlatFlap1.Drive(0, 100);
 FlatFlap2.Drive(0, 100);
 délai(500);
 FlatFlap1.Drive(1, 100);
 FlatFlap2.Drive(1, 100);
 délai(500);
 FlatFlap1.Tone();
 FlatFlap2.Tone();
 }
 } 

Combinaison avec les capteurs CodeCell

Pour rendre le projet encore plus interactif, vous pouvez combiner le FlatFlap et le DriveCell avec le minuscule module de capteur CodeCell. CodeCell est compatible broche à broche avec DriveCell , prend en charge toutes les fonctions de la bibliothèque et ajoute 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 plus réactifs avec vos actionneurs FlatFlap .

Avec cet exemple, le CodeCell contrôle deux FlatFlap qui arrêtent de battre des ailes lorsqu'une proximité est détectée. Leur angle est ajusté de manière dynamique en fonction de la proximité de vos mains.

 #include <CodeCell.h>
 #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);

 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*/

 FlatFlap1.Init();
 FlatFlap2.Init();

 FlatFlap1.Tone();
 FlatFlap2.Tone();
 }

 void loop() {
 if (myCodeCell.Run()) {
 /*Runs every 100ms*/
 uint16_t proximity = myCodeCell.Light_ProximityRead(); 
Serial.println(proximité);
 si (proximité < 100) {
 FlatFlap1.Run(1, 100, 400);
 FlatFlap2.Run(1, 100, 400);
 } autre {
 proximité = proximité - 100 ;
 proximité = proximité / 10 ;
 si (proximité > 100) {
 proximité = 100;
 }
 FlatFlap1.Drive(0, (proximité));
 FlatFlap2.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 ! Avec FlatFlap , vous pouvez donner vie à vos projets créatifs avec du mouvement dans un format compact et élégant. Que vous ajoutiez des éléments dynamiques à l'art, que vous expérimentiez la robotique ou que vous développiez des affichages mécaniques interactifs, le FlatFlap offre une solution polyvalente et facile à utiliser. Commencez dès aujourd'hui avec nos bibliothèques Arduino ! Si vous avez d'autres questions sur le FlatFlap, n'hésitez pas à nous envoyer un e-mail et nous serons heureux de vous aider !

CoilCell est une bobine planaire compacte conçue pour divers projets DIY. Que vous débutiez ou que vous soyez un maker expérimenté, CoilCell offre une intégration facile pour simplifier vos créations. Dans ce tutoriel, nous vous expliquerons :

• Qu'est-ce qu'un CoilCell et comment fonctionne-t-il ?
• Démarrer avec sa bibliothèque de logiciels Arduino
• Programmez une boule aimantée pour qu'elle rebondisse toutes les quelques millisecondes
• Rendre le CoilCell plus interactif avec les capteurs CodeCell

Qu'est-ce que CoilCell ?
CoilCell est une bobine mince et plane construite sur un PCB multicouche, avec un pilote intégré qui simplifie le contrôle de la polarité et de la force magnétiques. Elle est disponible en deux configurations :

• Bobine 1 WCell : 70 tours, avec un champ magnétique maximal de 2,3 mT.
• Bobine 2,5 W : 200 tours, avec un champ magnétique maximal de 10 mT, qui peut être mis à niveau jusqu'à 17 mT à l'aide d'une plaque arrière en fer.

Applications magnétiques

• Aimants N52 : utilisez des aimants à billes ou à disques N52 légers pour des interactions dynamiques telles que faire rebondir ou secouer des objets en trouvant leur fréquence de résonance.
• FlipDot : créez un pixel mécanique interactif en faisant pivoter un aimant pour le retourner. Construisez votre propre pixel FlipDot magnétique imprimé en 3D et ajoutez-en d'autres pour un mini affichage. Vos oreilles et vos yeux vont l'adorer !
• Plaque arrière en fer : améliorez la CoilCell de 2,5 W pour augmenter sa puissance maximale à 17 mT, la transformant en un électro-aimant faible adapté pour attirer de petits objets métalliques comme des trombones.
• Dés magnétiques : réalisez des tours amusants avec nos dés spéciaux contenant un aimant caché à l'intérieur, vous permettant de créer des secousses automatiques ou d'influencer le résultat du lancer avec le CoilCell de 2,5 W.

Conseils de sécurité
Lors de l'utilisation du CoilCell 2,5 W 200 tours, il peut potentiellement chauffer jusqu'à 110 °C, en particulier lorsqu'il est combiné avec la plaque arrière en fer. Suivez ces précautions :

• Gardez les mains éloignées des surfaces chaudes et éteignez la bobine lorsqu’elle n’est pas utilisée.
• Assurez-vous que les pièces et matériaux imprimés en 3D peuvent résister à des températures élevées.
• Utilisez également une protection des yeux lorsque vous travaillez avec de petits aimants qui peuvent être repoussés à grande vitesse.

Comment fonctionne CoilCell ?
CoilCell utilise une puce de pont en H DRV8837 intégrée pour contrôler le flux de courant à travers la bobine, lui permettant de changer de polarité magnétique :

• Nord : IN1 = VCC/PWM, IN2 = GND
• Sud : IN1 = GND, IN2 = VCC/PWM
• Désactivé : IN1 = GND, IN2 = GND

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 CoilCell
Le câblage d'une des broches d'entrée sur VCC activera instantanément la CoilCell . Mais pour le rendre plus intelligent, nous avons également développé une bibliothèque de logiciels Arduino pour vous faciliter la mise en route.

Vous devrez écrire un code de base pour indiquer à CoilCell ce qu'il doit faire. Ne vous inquiétez pas, c'est assez simple ! Commencez par télécharger la bibliothèque « CoilCell » à partir du gestionnaire de bibliothèques de l'Arduino. Une fois celle-ci installée, nous sommes prêts à contrôler votre appareil. Il existe plusieurs exemples qui peuvent vous aider à démarrer, mais nous allons maintenant décomposer et comprendre toutes les fonctions :

Avant de commencer, assurez-vous de connecter le CoilCell à votre microcontrôleur. Nous vous recommandons d'utiliser un CodeCell compatible broche à broche, de la même taille, prenant en charge toutes les fonctions de la bibliothèque et pouvant ajouter un contrôle sans fil + une détection interactive.

1. Initialiser CoilCell

 #include <CoilCell.h>
 
CoilCell myCoilCell(IN1, IN2); // Remplacez IN1 et IN2 par vos broches spécifiques

 vide configuration() {
 myCoilCell.Init(); // Initialise la CoilCell
 }

Ce code configure le CoilCell , le configurant pour le contrôle magnétique en fonction de vos broches et de votre microcontrôleur sélectionnés.

La fonction Bounce() fait rebondir un aimant de haut en bas. Le premier paramètre définit la polarité de la CoilCell et le delay_ms définit la durée pendant laquelle l'aimant est repoussé.

 myCoilCell.Bounce(true, 20); //Bounce the magnet up for 20ms

3. Buzz (uint16_t us_buzz)
Créez un bourdonnement en alternant rapidement la polarité de la bobine. Ajustez « us_buzz » pour contrôler la fréquence du bourdonnement.

 myCoilCell.Buzz(80); // Generates a buzzing effect at 80 microseconds intervals

4. Tonalité()
Cette fonction joue une tonalité par défaut en faisant vibrer la CoilCell à différentes fréquences enregistrées.

 myCoilCell.Tone(); // Plays varying tones

5. Drive(bool direction, uint8_t power_percent)
En utilisant le CodeCell ou tout autre microcontrôleur ESP32, cette fonction permet de contrôler la polarité et la force magnétique de la bobine. La force magnétique est ajustée par le « power_percent », qui contrôle la distance à laquelle l'aimant est poussé par rapport à la bobine.

 myCoilCell.Drive(true, 75); // Drive the coil north with 75% strength

6. Basculer(uint8_t power_percent)
En utilisant le CodeCell ou tout autre microcontrôleur ESP32, cette fonction bascule la polarité de la bobine à un niveau de puissance défini, utile pour des actions de retournement magnétique simples.

 myCoilCell.Toggle(60); // Toggle polarity at 60% power

Pour les autres appareils Arduino, cette commande fait que la bobine inverse sa direction à pleine puissance.

 myCoilCell.Toggle(); // Toggle polarity at 100% power

7. Vibrer (bool lisse, uint8_t power_percent, uint16_t vib_speed_ms)

Cette fonction inverse la polarité de la bobine à une vitesse et une puissance spécifiées. Le réglage « smooth » sur true crée des mouvements plus fluides, idéaux pour les fréquences lentes inférieures à 2 Hz.

 myCoilCell.Vibrate(true, 50, 1000); // Smooth vibration at 50% power every 1000 ms

Pour les autres appareils Arduino, cette commande fait que la bobine inverse sa polarité à pleine puissance.

 myCoilCell.Vibrate(100); // Vibrate at 100% power every 100 ms

Voici un exemple où nous initialisons une CoilCell pour faire rebondir un aimant à bille de 5 mm de diamètre. Dans cet exemple, la CoilCell est initialisée avec les broches 5 et 6. La fonction setup() appelle myCoilCell.Init() pour configurer la CoilCell . Dans la fonction loop() , la fonction Bounce() est utilisée pour faire rebondir l'aimant vers le haut pendant 20 millisecondes, suivi d'un délai de 600 millisecondes qui attire l'aimant vers le bas.

#include <CoilCell.h>

 #define IN1_pin1 5
 #define IN1_pin2 6

 CoilCell myCoilCell(IN1_pin1, IN1_pin2);

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

 void loop() {
 myCoilCell.Bounce(0, 20); /*Bounce the magnet up for 20ms*/
 delay(600); /*Attract the magnet back down for 600ms*/
 }

Dans l'exemple suivant, nous utilisons le capteur de mouvement du CodeCell pour détecter les tapotements. Lorsqu'un nouveau tapotement est détecté, le CoilCell inverse sa polarité magnétique et définit un délai d'une seconde pour faire clignoter la LED intégrée en jaune.

 #include <CodeCell.h>
 #include <CoilCell.h>

 #define IN1_pin1 5
 #define IN1_pin2 6

 CoilCell myCoilCell(IN1_pin1, IN1_pin2);
 CodeCell myCodeCell;
 
vide configuration() {
 Serial.begin(115200); /* Définissez le débit en bauds série sur 115 200. Assurez-vous que Tools/USB_CDC_On_Boot est activé si vous utilisez Serial. */

 myCodeCell.Init(MOTION_TAP_DETECTOR); /*Initialise la détection de pression*/
 maCoilCell.Init();
 maCelluleCoil.Tone();
 }

 boucle vide() {
 si (myCodeCell.Run()) {
 /*S'exécute toutes les 100 ms*/
 si (myCodeCell.Motion_TapRead()) {
 /*Si Tap est détecté, la LED s'allume en jaune pendant 1 seconde et inverse la polarité de la CoilCell*/
 monCodeCell.LED(0XA0, 0x60, 0x00U);
 maCoilCell.Toggle(100);
 délai(1000);
 }
 }
 }

Grâce à ces fonctions de base, vous pouvez commencer à expérimenter CoilCell dans vos projets. Que vous contrôliez des aimants, créiez des affichages interactifs ou expérimentiez des forces magnétiques, CoilCell offre une solution simple et efficace.

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

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 !