MotorCell ne se limite pas aux mouvements continus : il peut également être pulsé pour de courtes séquences de mouvements. Ceci est particulièrement utile pour les projets d'art cinétique, où des mouvements contrôlés et rythmés peuvent créer des effets visuels saisissants. En pulsant le moteur pendant quelques millisecondes à la fois, vous pouvez obtenir des effets de rotation coordonnés sur plusieurs moteurs.
Cet exemple montre comment pulser six moteurs pendant 2 000 millisecondes (2 secondes) chacun, créant ainsi un effet de rotation séquentielle. La fonction Pulse(IN_pinX, pulse_ms) active chaque moteur pendant une durée définie avant de passer au suivant.
#include <MotorCell.h>
#define IN_pin1 1
#define IN_pin2 2
#define IN_pin3 3
#define IN_pin5 5
#define IN_pin6 6
#define IN_pin7 7
#define pulse_ms 2000
int motor_num = 0;
MotorCell myMotorCell(1,2,3);
void setup() {
}
void loop() {
delay(100);
motor_num++;
switch (motor_num) {
case 1:
myMotorCell.Pulse(IN_pin1, pulse_ms); /* Pulse motor 1 for 2000ms */
break;
case 2:
myMotorCell.Pulse(IN_pin2, pulse_ms); /* Pulse motor 2 for 2000ms */
break;
case 3:
myMotorCell.Pulse(IN_pin3, pulse_ms); /* Pulse motor 3 for 2000ms */
break;
case 5:
myMotorCell.Pulse(IN_pin5, pulse_ms); /* Pulse motor 5 for 2000ms */
break;
case 6:
myMotorCell.Pulse(IN_pin6, pulse_ms); /* Pulse motor 6 for 2000ms */
break;
case 7:
myMotorCell.Pulse(IN_pin7, pulse_ms); /* Pulse motor 7 for 2000ms */
motor_num = 0; /* Reset the sequence */
break;
}
}
motor_num suit quel moteur est actuellement actif.motor_num et sélectionne le moteur correspondant.Pulse(IN_pinX, pulse_ms) permet d'activer chaque moteur pendant 2 secondes avant de passer au suivant.pulse_ms pour ajuster le temps de rotation de chaque moteur.Prêt à expérimenter ? Procurez-vous un MotorCell dès aujourd'hui et consultez le dépôt GitHub MotorCell pour plus d'exemples de code et de documentation technique !
MotorCell utilise le contrôleur triphasé contre-électromotrice BD67173NUX avec un système d'entraînement sans capteur, permettant le contrôle de la vitesse via un rapport cyclique du signal d'entrée PWM. La broche IN est par défaut à l'état bas, ce qui fait tourner le moteur à pleine vitesse lorsqu'elle est tirée à l'état haut (2,5 V–5 V). Vous pouvez régler la vitesse par paliers de 1 000 tr/min via le rapport cyclique ou utiliser directement les fonctions de la bibliothèque MotorCell.
Pour commencer, installez la bibliothèque MotorCell à partir du gestionnaire de bibliothèque Arduino :
La bibliothèque comprend des exemples pour vous aider à démarrer rapidement avec le contrôle MotorCell.
Nous allons commencer par contrôler la vitesse à l'aide de la fonction Spin. Cette fonction ajuste la vitesse du moteur au pourcentage souhaité de sa capacité maximale et renvoie la valeur actuelle du régime. Cette valeur est également automatiquement affichée sur le moniteur série, pour faciliter le débogage. Si le moteur cale, il tente automatiquement de redémarrer.
#include <MotorCell.h>
#define IN_pin1 2
#define OUT_pin2 3
#define FR_pin2 1
MotorCell myMotorCell(IN_pin1, OUT_pin2, FR_pin2); /* Configure the MotorCell pins */
void setup() {
Serial.begin(115200); /* Set up serial - Ensure Tools/USB_CDC_On_Boot is enabled */
myMotorCell.Init(); /* Initialize the MotorCell */
}
void loop() {
uint16_t MotorRPM = myMotorCell.Spin(25); /* Définir la vitesse à 25 % de la vitesse maximale */
}
⚠ Remarque : Pour cette fonction, nous recommandons d'utiliser un périphérique ESP32 comme le CodeCell pour éviter les retards lors de la lecture du RPM
L'exemple suivant montre comment inverser le sens de rotation du moteur toutes les 5 secondes à pleine vitesse. La fonction MaxSpin règle le moteur à sa vitesse maximale, tandis que la fonction ReverseSpin modifie son sens de rotation. Cette fonction alterne entre rotation horaire et antihoraire avec un délai de 5 secondes entre chaque changement de sens.
#include <MotorCell.h>
#define IN_pin1 2
#define OUT_pin2 3
#define FR_pin2 1
MotorCell myMotorCell(IN_pin1, OUT_pin2, FR_pin2); /* Configure the MotorCell pins */
void setup() {
Serial.begin(115200); /* Set up serial - Ensure Tools/USB_CDC_On_Boot is enabled */
myMotorCell.Init(); /* Initialiser la MotorCell */
}
boucle vide() {
myMotorCell.MaxSpin(); /* Régler le moteur à la vitesse maximale */
myMotorCell.ReverseSpin(); /* Inverse le sens de rotation du moteur */
delay(5000); /* Attendre 5 secondes */
myMotorCell.MaxSpin(); /* Maintenir la vitesse maximale */
myMotorCell.ReverseSpin(); /* Inverser à nouveau la direction */
delay(5000); /* Attendez encore 5 secondes */
}
Ce dernier exemple implémente un contrôleur PID pour réguler la vitesse du moteur à la vitesse souhaitée grâce à la fonction SpinPID. Le contrôleur PID compense dynamiquement les perturbations et les variations de charge, assurant ainsi un fonctionnement fluide. Si le moteur cale, la fonction le redémarre automatiquement et vous avertit si la vitesse cible ne peut être atteinte. Ces informations sont également automatiquement affichées sur le moniteur série, facilitant ainsi le débogage.
#include <MotorCell.h>
#define IN_pin1 2
#define OUT_pin2 3
#define FR_pin2 1
MotorCell myMotorCell(IN_pin1, OUT_pin2, FR_pin2); /* Configurer les broches MotorCell */
void setup() {
Serial.begin(115200); /* Configurer le port série - S'assurer que Tools/USB_CDC_On_Boot est activé */
myMotorCell.Init(); /* Initialiser la MotorCell */
}
boucle vide() {
uint16_t MotorRPM = myMotorCell.SpinPID(15000); /* Définir le régime cible à 15 000 à l'aide du PID */
}
⚠ Remarque : la fonction SpinPID () utilise un Minuterie PWM haute vitesse, la rendant compatible uniquement avec les appareils basés sur CodeCell et ESP32.
Avec la bibliothèque MotorCell installée, vous pouvez facilement contrôler la vitesse, la direction et surveiller son régime !
Prêt à expérimenter ? Procurez-vous un MotorCell dès aujourd'hui et consultez le dépôt GitHub MotorCell pour plus d'exemples de code et de documentation technique !
La conception sans arbre de MotorCell garantit une intégration aisée et compacte. Le rotor est fabriqué en aluminium de 3,3 mm avec un moletage sur son bord, permettant une fixation par pression directe sur les dents du rotor pour une connexion sécurisée.
Pour l'installation de pièces imprimées en 3D par press-fit, nous recommandons un diamètre intérieur compris entre 16,4 et 16,6 mm, selon la tolérance de votre imprimante 3D. Une fois imprimée, il suffit d'appuyer la pièce sur les dents du rotor pour la maintenir en place.
Pour une sécurité supplémentaire, de la superglue peut être appliquée sur les dents du rotor. Veillez à ce que la colle soit appliquée uniquement sur les côtés et ne pénètre pas près du roulement du MotorCell.
Une variété de supports imprimés en 3D peut être trouvée dans le référentiel GitHub de MotorCell : 👉 Supports 3D MotorCell
Voici quelques exemples :
Notre objectif est de rendre l’intégration de MotorCell dans vos projets aussi transparente que possible.
Prêt à expérimenter ? Procurez-vous un MotorCell dès aujourd'hui et consultez le dépôt GitHub MotorCell pour plus d'exemples de code et de documentation technique !
Lors de projets nécessitant des mouvements à grande vitesse dans un format compact, les moteurs brushless traditionnels peuvent s'avérer difficiles à intégrer en raison de leur taille et de leur complexité. C'est pourquoi MotorCell est unique : il combine le rotor, le stator et le variateur dans un seul module ultra-compact.
Dans cet article, nous explorerons la conception du MotorCell, la fonctionnalité du pilote et son intégration dans vos projets.
MotorCell est le plus petit moteur PCB haute vitesse sans noyau, doté de bobinages PCB plans et d'un contrôle sans capteur intégré, éliminant ainsi le besoin de capteurs supplémentaires ! En intégrant tout dans un seul module, il offre une solution compacte et compacte aux fabricants et développeurs travaillant sur des applications nécessitant un contrôle moteur haute vitesse.
Conçu pour les applications à faible couple et à grande vitesse, MotorCell prend en charge le contrôle de vitesse basé sur PWM et fonctionne de manière transparente avec la bibliothèque MotorCell, qui comprend un contrôle PID prédéfini pour CodeCell et d'autres appareils basés sur ESP32.
Son stator est constitué d'une carte FR4 à 6 couches, avec 6 enroulements en cuivre connectés en étoile. Ce moteur est ainsi un moteur sans balais triphasé à flux axial. Ce type de moteur nécessite une alimentation spécifique pour générer une forme d'onde de commutation et faire tourner le rotor magnétique situé au-dessus.
C'est pourquoi MotorCell utilise également la puce BD67173NUX comme contrôleur de force contre-électromotrice triphasée, permettant une commutation sans capteur, donc sans capteurs à effet Hall. Ce driver permet de régler la vitesse via le rapport cyclique PWM du signal d'entrée, avec une résolution d'environ 1 000 tr/min. La broche IN est par défaut à l'état bas, ce qui fait tourner le moteur à sa vitesse maximale lorsqu'elle est activée (2,5 V–5 V).
Si le moteur est forcé de s'arrêter, il entre dans un mode de protection de verrouillage de 5 secondes, qui peut être instantanément réinitialisé lorsque PWM est réglé sur 0 % et redémarré - ceci est automatiquement géré par la fonction Spin de la bibliothèque MotorCell.
Nous sommes convaincus que l'avantage majeur des moteurs PCB réside dans leur intégration transparente à l'électronique, éliminant ainsi le recours à des PCB supplémentaires. C'est pourquoi nous avons simplifié l'intégration directe du stator dans votre PCB personnalisé grâce à sa conception open source (disponible ici) .
Cependant, la construction d'un rotor à grande vitesse reste un défi complexe. Pour plus de simplicité, vous pouvez acheter le rotor séparément, ce qui vous permet d'ajouter facilement un moteur PCB à votre carte pour une conception plus compacte tout en garantissant une configuration de rotor fiable !
Pour démarrer avec Arduino :
Avec la bibliothèque MotorCell installée, vous pouvez facilement contrôler la vitesse, la direction et surveiller son régime, expliqué plus en détail dans nos autres tutoriels.
Prêt à expérimenter ? Procurez-vous un MotorCell dès aujourd'hui et consultez le dépôt GitHub MotorCell pour plus d'exemples de code et de documentation technique !
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 ?
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 :
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 :
Épingles :
Ouvrez l'IDE Arduino, allez dans Sketch > Inclure la bibliothèque > Gérer les bibliothèques , recherchez « MotorCell » et installez-le. Ensuite, incluez-le dans votre code et configurez vos broches :
#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 :
myMotorCell.Init();
uint16_t rpm = myMotorCell.Spin(50); // Spin at 50% speed
uint16_t rpm = myMotorCell.SpinPID(12000); // Maintain 12,000 RPM
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
uint16_t currentRPM = myMotorCell.RPMRead();
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); // Rotation à 50 % de la vitesse
}
Plus d'exemples disponibles sur github , mais si vous avez des questions sur MotorCell, n'hésitez pas à nous contacter !
Un moteur PCB est une solution innovante qui intègre la mécanique du moteur dans les composants électroniques, en utilisant le PCB lui-même comme structure du moteur.
Qu'est-ce qu'un moteur PCB ?
Un moteur PCB est un type de moteur unique qui utilise les traces de cuivre sur un circuit imprimé (PCB) pour créer un champ magnétique qui entraîne le moteur. Ce concept s'inspire de la façon dont les systèmes radio utilisent les traces de PCB comme antennes. Le même principe est appliqué pour générer un champ magnétique suffisamment puissant pour faire tourner un rotor. Ce type de moteur est connu sous le nom de moteur sans balai à flux axial, où le stator PCB et le rotor sont alignés en parallèle.
La conception et la construction d'un moteur PCB
La première étape de la création d'un moteur PCB consiste à concevoir les bobines du stator PCB. Dans les moteurs traditionnels, ces bobines sont souvent constituées de fils enroulés en formes tridimensionnelles denses. Dans un moteur PCB, les bobines sont plutôt fabriquées sous forme de traces en spirale plates imprimées sur les couches d'un PCB.
L'un des défis de ces moteurs planaires est de placer suffisamment de spires dans le petit espace disponible pour générer un flux magnétique suffisant. Ces bobines doivent être connectées dans une configuration en étoile ou en triangle pour créer un système triphasé. Dans notre conception MotorCell à 6 fentes configurée en étoile, nous avons pu empiler les bobines sur quatre couches, en utilisant deux couches supplémentaires pour le contrôleur, afin de produire le champ magnétique requis pour faire tourner le rotor.
Au fil des années, nous avons également appris que la conception du rotor est cruciale pour améliorer l'efficacité du moteur. Il est important d'utiliser des roulements à billes en céramique de haute qualité et d'aligner les roulements avec précision pour obtenir la solution mécanique optimale. Cela nécessite généralement des outils spécialisés, c'est pourquoi nous proposons également le rotor du MotorCell individuellement, ce qui vous permet de l'intégrer facilement à votre PCB personnalisé.
Réalisation de la synchronisation dans le moteur PCB
L'un des aspects les plus critiques de la conduite d'un moteur sans balais est de s'assurer que le rotor reste synchronisé avec le champ électromagnétique du stator. Dans les moteurs traditionnels à balais, la synchronisation est gérée mécaniquement par les balais eux-mêmes. Cependant, dans un moteur sans balais triphasé comme un moteur PCB, un retour sensoriel est nécessaire pour assurer le bon fonctionnement du moteur.
La force contre-électromotrice est généralement utilisée comme rétroaction pour contrôler la vitesse du moteur. La force contre-électromotrice est la tension générée par le moteur en rotation lui-même, qui peut être mesurée pour déterminer la vitesse du rotor. Ces informations sont ensuite transmises à l'électronique de commande du moteur, garantissant que les bobines du stator sont entraînées en synchronisation avec le mouvement du rotor. Pour le MotorCell , tout cela est géré directement par la puce embarquée, ce qui simplifie le processus.
