Archives

Démarrage sûr et contrôle d’angle avec AccelStepper pour moteur pas à pas

.

Découvrez comment piloter un moteur pas à pas de manière précise et flexible avec notre code basé sur la bibliothèque AccelStepper. Conçu pour éviter les déclenchements intempestifs grâce à une gestion intelligente des rebonds, ce code vous offre une maîtrise totale sur la rotation de votre moteur.

Sommaire :

 

Rotation sur mesure :

Avec notre code, vous avez le contrôle total sur la rotation de votre moteur. La variable valeur_de_la_rotation est votre outil principal pour définir l’angle de rotation souhaité. Vous envisagez une double rotation complète ? Réglez-la à 720 degrés. Vous avez besoin d’une précision chirurgicale pour un projet spécifique ? Aucun problème, ajustez-la à 10 degrés ou même moins. Cette flexibilité vous permet d’adapter le comportement du moteur à une multitude de scénarios, qu’il s’agisse d’une application industrielle nécessitant des rotations répétitives ou d’un projet artistique où chaque degré compte.

Adaptabilité du moteur :

Grâce à l’utilisation de la bibliothèque AccelStepper, ce code offre une flexibilité remarquable pour s’adapter à différents types de moteurs pas à pas et leurs drivers. En combinant les variables DEGRES_PAR_PAS et MICRO_PAS, il est possible d’ajuster le comportement du moteur avec précision. Par exemple, si vous utilisez un moteur conçu pour 400 pas par tour, ce qui équivaut à 0.9 degrés par pas, il suffit d’ajuster la variable DEGRES_PAR_PAS à 0.9. De même, pour un moteur standard à 200 pas par tour, qui équivaut à 1.8 degrés par pas, modifiez cette variable à 1.8. La variable MICRO_PAS joue également un rôle crucial en permettant de définir le niveau de micro-stepping de votre driver. Cela contribue à une plus grande précision et flexibilité dans le contrôle de votre moteur pas à pas, rendant l’utilisation d’AccelStepper essentielle pour un démarrage sûr et un contrôle d’angle précis

.

séparateur-redohm-001

 

AccelStepper stepper(AccelStepper::DRIVER, impulsion, direction) :

Cette ligne de code crée une instance de l’objet AccelStepper, qui est utilisée pour contrôler le moteur pas à pas.

  • AccelStepper : Il s’agit du nom de la classe fournie par la bibliothèque AccelStepper. Cette classe offre diverses fonctionnalités pour contrôler les moteurs pas à pas, comme la gestion de l’accélération et de la vitesse.
  • stepper : C’est le nom de l’objet que vous créez. Cet objet représente votre moteur pas à pas et vous permettra de le contrôler en appelant différentes méthodes sur cet objet.
  • AccelStepper::DRIVER : Ce paramètre indique que vous utilisez le mode « DRIVER » pour AccelStepper. Ce mode est utilisé lorsque vous contrôlez un moteur pas à pas avec un pilote externe, ce qui est commun pour les configurations de moteurs pas à pas plus complexes. Dans ce mode, vous ne fournissez que les pins d’impulsion et de direction à l’objet AccelStepper.
  • impulsion : C’est le pin Arduino connecté à la broche d’impulsion (step) du pilote de votre moteur pas à pas. Chaque impulsion envoyée sur ce pin fera avancer le moteur d’un pas.
  • direction : C’est le pin Arduino connecté à la broche de direction du pilote de votre moteur pas à pas. Le signal envoyé sur ce pin détermine la direction dans laquelle le moteur tournera.

↩️

stepper.setCurrentPosition() :

Est une fonction importante pour le contrôle précis des moteurs pas à pas, permettant aux développeurs de définir ou de redéfinir le point de référence à partir duquel les mouvements du moteur sont calculés. Cette capacité de réinitialisation est particulièrement utile dans les applications automatisées et robotiques où la position exacte et la répétabilité des mouvements sont cruciales.

Réinitialisation de la Position du Compteur de Pas :

  • Lorsque vous exécutez stepper.setCurrentPosition(0);, vous dites essentiellement à la bibliothèque AccelStepper de considérer la position actuelle du moteur comme la position « 0 » du compteur de pas.
  • Cela n’affecte pas physiquement la position du moteur, mais modifie la valeur de référence interne utilisée par le contrôleur pour suivre la position du moteur.

Considérations Techniques :

  • Précision : Crucial pour les applications où la position exacte du moteur doit être connue, comme dans les systèmes de positionnement ou les appareils de précision.
  • Implications de Réinitialisation : Après l’appel de cette méthode, toute commande de mouvement telle que moveTo() ou move() interprétera la position actuelle du moteur comme étant « 0 ». Tous les mouvements futurs seront donc relatifs à cette nouvelle position de référence.

↩️

stepper.setAcceleration() :

La méthode setAcceleration() de la bibliothèque AccelStepper est utilisée pour définir la valeur d’accélération du moteur pas à pas. L’accélération est la vitesse à laquelle le moteur change sa vitesse. Elle est exprimée en pas par seconde au carré (pas/s^2).

  • Paramètre : La fonction prend un seul argument, qui est la valeur d’accélération souhaitée. Dans l’exemple donné, 2000 signifie que l’accélération du moteur est réglée sur 2000 pas par seconde au carré.
  • Comportement : Lorsque cette fonction est appelée, elle ne fait pas bouger le moteur immédiatement. Elle définit simplement la manière dont le moteur accélère pour atteindre sa vitesse maximale (définie par setMaxSpeed()) et comment il décélère pour s’arrêter. Une accélération plus élevée signifie que le moteur atteindra sa vitesse maximale plus rapidement.
  • Utilisation : Cette fonction est généralement appelée dans la section setup() du code Arduino pour initialiser l’accélération du moteur. Elle est particulièrement utile pour éviter les à-coups ou les vibrations qui peuvent survenir si le moteur démarre ou s’arrête brusquement.

Exemple d’utilisation :

La fonction stepper.setAcceleration(2000); est utilisée pour définir comment le moteur pas à pas accélère et décélère. Une accélération appropriée permet d’éviter les vibrations et d’assurer un mouvement fluide du moteur. Dans cet exemple, l’accélération est réglée sur 2000 pas par seconde au carré, ce qui signifie que le moteur augmentera ou diminuera sa vitesse à ce taux jusqu’à ce qu’il atteigne sa vitesse maximale ou s’arrête.

↩️

.

Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes  sur lesquelles nous éditons.
Cliquez sur celles qui vous intéressent .

Facebook Twitter Youtube 

Grabcad Thingiverse Cults  

Retour au menu tuto
Arduino pour Moteurs Brushless: Accélération et Capteurs à Effet Hall

.

Bonjour à tous ! Cette vidéo se concentre sur l’étude des rampes d’accélération et de décélération pour les moteurs brushless pilotés par une carte contrôleur. Nous explorerons également la mise à l’échelle de la vitesse en tours par minute et étudierons le rôle des capteurs situés à l’arrière du moteur. Un guide technique complet à ne pas manquer !

📌 Cette vidéo vise à décomposer et analyser en détail un code Arduino avancé conçu pour la régulation de vitesse d’un moteur électrique. Le programme utilise la technique de modulation par largeur d’impulsion (PWM) pour communiquer avec le contrôleur du moteur. Nous examinerons la méthodologie permettant la saisie automatique de la vitesse en tours par minute (tr/min) via le moniteur série et sa conversion ultérieure en signaux PWM destinés au contrôleur. De plus, nous explorerons la conception et l’implémentation de rampes d’accélération et de décélération pour un contrôle plus nuancé de la dynamique du moteur. En parallèle, nous aborderons le rôle des capteurs à effet Hall, situés à l’arrière du moteur et interfacés avec la carte de contrôle, pour mieux comprendre leur contribution à l’ensemble du système de régulation de vitesse. 

Ce que vous allez apprendre :

  • Comment utiliser la PWM avec Arduino
  • Comment lire des données du moniteur série
  • Comment mettre en œuvre des rampes d’accélération et de décélération
  • Mise à l’échelle de la vitesse en tr/min et la valeur du signal PWM

🛠 Fonctionnalités clés du code :

1️⃣ Étude des capteurs à effet Hall à l’arrière du moteur
2️⃣ Saisie de la vitesse désirée via le moniteur série
3️⃣ Conversion de la vitesse en tours par minute (tr/min) en une valeur PWM
4️⃣ Implémentation d’une rampe d’accélération et de décélération
5️⃣ Feedback en temps réel via le moniteur série.

Informations :

  • Code par : Hervé Mazelin pour RedOhm
  • Date de la réalisation : 11/10/2023
  • Version IDE Arduino : 2.2.1

Facebook Twitter  Youtube

Grabcad Thingiverse Cults  

Retour au sommaire
Interface Série pour Régulation de Moteur Brushless avec Contrôleur BLD-300B

.

📜 Description : Dans cette vidéo, nous allons explorer un programme Arduino conçu pour contrôler la vitesse d’un moteur brushless en utilisant un contrôleur BLD-300B. Le code utilise la communication série pour recevoir des valeurs de vitesse entre 0 et 255, qui sont ensuite appliquées au moteur via ce contrôleur spécifique.

🔍 À propos du Contrôleur BLD-300B : Le BLD-300B est un contrôleur de moteur brushless qui permet une régulation fine de la vitesse et du couple du moteur. Il est souvent utilisé dans des applications industrielles et de robotique pour un contrôle précis.

🔑 Points clés :

1️⃣ Utilisation du Contrôleur BLD-300B : Nous utilisons le contrôleur BLD-300B pour une meilleure régulation de la vitesse du moteur.

2️⃣ Configuration de la broche PWM : La broche 9 de la carte Arduino est configurée comme sortie pour le signal PWM.

3️⃣ Communication Série : Le programme utilise la communication série pour recevoir les valeurs de vitesse du moteur.

4️⃣ Validation des Entrées : Le code vérifie si les valeurs reçues sont dans la plage autorisée (0-255) avant de les appliquer.

5️⃣ Feedback Utilisateur : Des messages sont affichés sur le moniteur série pour informer l’utilisateur de l’état actuel du système.

N’oubliez pas de 👍 aimer la vidéo, de 🔔 vous abonner et de 💬 laisser un commentaire si vous avez des questions ou des suggestions !

📅 Date : 04/10/2023
🛠️ Version de l’IDE Arduino : 2.2.1
👨‍💻 Réalisé par : Hervé Mazelin pour RedOhm

 

Informations complémentaires :

Sur une carte Arduino, le signal PWM (Pulse Width Modulation, ou Modulation de Largeur d’Impulsion en français) est généralement utilisé pour simuler un signal analogique à l’aide d’une sortie numérique. Les cartes Arduino ont des broches spécifiques capables de générer des signaux PWM, souvent marquées avec un symbole « ~ » à côté du numéro de la broche.

La fonction analogWrite() est utilisée pour envoyer un signal PWM à une broche spécifique. Cette fonction prend deux arguments : le numéro de la broche et la valeur du rapport cyclique, qui est généralement un nombre entre 0 et 255. Par exemple, analogWrite(9, 127) enverra un signal PWM avec un rapport cyclique d’environ 50% à la broche 9.

Le microcontrôleur sur la carte Arduino génère le signal PWM en alternant rapidement la broche entre les états haut et bas, en modifiant la durée pendant laquelle la broche reste à chaque état selon la valeur du rapport cyclique spécifié. Par exemple, une valeur de 127 sur une échelle de 0 à 255 fera en sorte que la broche soit à l’état haut environ 50% du temps et à l’état bas les 50% restants.

Le signal PWM sur Arduino est souvent utilisé pour contrôler la vitesse des moteurs, régler la luminosité des LEDs, ou même générer des sons simples. Cependant, il est important de noter que même si cela peut simuler un comportement analogique, le signal généré est en réalité toujours numérique (état haut ou bas), et certains dispositifs peuvent nécessiter un filtrage supplémentaire pour fonctionner correctement avec un signal PWM.

 

Facebook Twitter  Youtube

Grabcad Thingiverse Cults  

Retour au sommaire

 

Surveillance de Potentiomètre avec Résolution ADC de 14 bits sur Arduino UNO R4

.

Ce code Arduino a été spécialement conçu pour surveiller les valeurs d’un potentiomètre connecté à la broche A0 d’une carte Arduino UNO R4. L’une des caractéristiques uniques de ce code est l’utilisation d’une résolution de 14 bits pour le convertisseur analogique-numérique (ADC). Cette résolution supérieure permet des lectures plus précises et détaillées, ce qui est particulièrement utile dans des applications comme le contrôle de moteurs de précision, l’instrumentation scientifique et la surveillance environnementale.

🎯 Fonctionnalités clés :

🔌 Initialisation de la Communication Série : Le code commence par initialiser la communication série à un débit de 9600 bauds. Cette fonctionnalité est essentielle pour des applications comme la télémétrie où les données doivent être transmises à distance.

🔒 Vérification de la Communication Série : Le code s’assure que la communication série est bien établie avant de procéder à toute lecture ou écriture. C’est particulièrement utile pour des applications médicales où la fiabilité des données est cruciale.

🎛 Configuration de la Résolution ADC : Le code utilise la fonction analogReadResolution() pour configurer l’ADC à une résolution de 14 bits. Cette haute résolution est bénéfique dans des applications comme l’automatisation industrielle où une précision extrême est nécessaire.

📊 Lecture et Affichage des Valeurs : Le code lit ensuite la valeur analogique du potentiomètre et l’affiche dans le moniteur série en deux formats : décimal et binaire. Cette fonctionnalité peut être utile dans des applications d’audio de haute qualité où la représentation précise des données est requise.

⏳ Intervalle de Lecture : Le code effectue une pause de 500 millisecondes entre chaque lecture, ce qui est suffisant pour des applications comme l’agriculture de précision où les conditions peuvent changer lentement.

📋 Informations de Version :

  • 👨‍💻 Développeur : Hervé Mazelin pour RedOhm
  • 🛠 Version de l’IDE Arduino utilisée : 2.2.1
  • 📅 Date de réalisation : 07/10/2023

Ce code est idéal pour toute personne cherchant à obtenir des lectures analogiques précises pour des applications nécessitant une grande précision. Il est particulièrement adapté pour des domaines comme le contrôle de moteurs, la mesure médicale, l’instrumentation scientifique, et bien d’autres applications où la précision est cruciale.

 

Facebook Twitter  Youtube

Grabcad Thingiverse Cults  

Retour au sommaire

 

Tutoriel Arduino : Compteur de Vitesse Analogique avec Écran TFT !

.

Ce programme est conçu pour fonctionner avec une carte Arduino et un écran TFT. Son objectif principal est d’afficher un compteur de vitesse sur l’écran TFT, simulant ainsi un tableau de bord analogique, comme celui que l’on pourrait trouver dans une voiture ou une moto.

  1. Fonctionnement de base :
    • Le programme lit une valeur analogique (provenant d’un capteur ou d’un potentiomètre connecté à la broche A9 de l’Arduino) qui est censée représenter une vitesse.
    • Cette valeur analogique est ensuite mappée (ou convertie) en une valeur de vitesse allant de 0 à une vitesse maximale définie (dans ce cas, Vitesse_max est définie à 150).
    • Le programme utilise la vitesse déduite pour ajuster une aiguille sur l’écran TFT. Cette aiguille indique la vitesse actuelle, similaire à un compteur de vitesse analogique. Outre l’aiguille, le programme affiche la vitesse exacte numériquement sur l’écran.
  2. Caractéristiques visuelles :
    • L’écran TFT affiche un cercle représentant le compteur de vitesse, avec des marques (ou graduations) pour indiquer différentes vitesses. Ces marques sont espacées de 10 unités de vitesse et sont accompagnées de chiffres pour faciliter la lecture.
    • Une aiguille pivote autour du centre du cercle, indiquant la vitesse actuelle.
  3. Mise à jour dynamique :
    • Le programme vérifie en continu la valeur analogique lue. Il met à jour l’affichage de l’aiguille et de la valeur numérique en conséquence.
    • Le programme évite les mises à jour inutiles pour réduire les clignotements sur l’écran. »Il met à jour l’affichage seulement quand la vitesse change.

Pourquoi le système de coordonnées sur un écran TFT diffère-t-il de la convention mathématique? Comment cela impacte-t-il la programmation sur ces écrans?

Lorsque nous parlons du cercle trigonométrique standard en mathématiques, il commence avec 0° à droite (sur l’axe des abscisses positif) et augmente dans le sens antihoraire.

Cependant, dans de nombreux systèmes de graphiques informatiques, y compris la plupart des écrans TFT pilotés par Arduino, le système de coordonnées est différent :

  1. Origine (0,0) : L’origine du système de coordonnées se trouve généralement dans le coin supérieur gauche de l’écran, et non au centre.
  2. Direction positive de l’axe Y : Dans la plupart des systèmes trigonométriques, l’axe Y est positif vers le haut. Mais dans de nombreux systèmes graphiques, l’axe Y est positif vers le bas.
  3. Sens de rotation : En trigonométrie, l’angle augmente dans le sens antihoraire. Cependant, sur les écrans TFT, c’est différent. L’axe Y positif change la direction. Les objets tournent dans le sens horaire.

Ces différences peuvent rendre la translation des concepts mathématiques trigonométriques dans le monde du graphisme informatique un peu déroutante au début. C’est pourquoi, par exemple, le cercle trigonométrique commence souvent à un angle différent, comme 135° pour le compteur dans le code que nous avons examiné, afin d’avoir le point de départ à l’endroit souhaité.

Ainsi, lors de la programmation pour des écrans TFT ou d’autres systèmes de graphiques informatiques, nous devons prendre en compte ces différences et ajuster les calculs en conséquence.

Pourquoi est-il nécessaire de convertir les degrés en radians lors de l’utilisation de fonctions trigonométriques sur Arduino?

Sur Arduino, la nécessité de traduire les degrés en radians n’est pas due à une limitation spécifique de la plate-forme Arduino elle-même, mais plutôt à la manière dont les fonctions trigonométriques standard, telles que sin() et cos(), sont définies dans la plupart des langages de programmation, y compris le C++ utilisé par l’Arduino.

Voici quelques raisons pour lesquelles les radians sont utilisés pour les fonctions trigonométriques :

Définition mathématique : En mathématiques, le radian est la mesure standard pour les angles. C’est une unité sans dimension qui représente le rapport entre la longueur d’un arc et le rayon du cercle. Cette propriété rend les radians plus fondamentaux et naturels pour décrire les angles dans le contexte des mathématiques.

Simplicité des formules : De nombreuses formules en trigonométrie, en analyse et en physique sont plus simples lorsqu’elles sont exprimées en radians. Par exemple, la dérivée de sin(x) est cos(x) seulement si x est en radians.

Facebook Twitter Youtube

Grabcad Thingiverse Cults  

Page d'accueil du site

 

 

 

Arduino et moteurs pas à pas : Découverte de la bibliothèque AccelStepper

.

Dans ce tutoriel, nous présentons comment contrôler un moteur pas à pas à l’aide des drivers TB6600, DM542 ou DM860, en association avec une carte Arduino, en mettant en avant quelques fonctions spécifiques de la librairie AccelStepper. Grâce à cette dernière, notre code permet à l’utilisateur d’ajuster la vitesse du moteur via un potentiomètre, de démarrer ou arrêter le moteur via des boutons, et d’obtenir des retours visuels grâce à deux LEDs, illustrant l’état de fonctionnement du moteur et sa phase d’accélération.

Découverte et utilité de la librairie AccelStepper :

La librairie AccelStepper dépasse la simple commande d’un moteur pas à pas. Elle propose une gamme étendue de fonctionnalités, mais ce tutoriel n’en aborde certaines que superficiellement. Par exemple, cette librairie autorise un contrôle précis de l’accélération, elle gère minutieusement les mouvements et elle est compatible avec de nombreux pilotes de moteurs. Nous démontrons dans ce tutoriel comment utiliser AccelStepper pour simplifier et enrichir le pilotage d’un moteur pas à pas, en modifiant sa vitesse selon la position d’un potentiomètre ou en lançant une série de mouvements avec une seule commande.

Pour aller plus loin dans la découverte de cette librairie et explorer ses nombreuses autres fonctionnalités, nous vous recommandons vivement de consulter notre chaîne YouTube. Vous y trouverez une multitude de tutoriels et d’applications diverses centrées sur la librairie AccelStepper, vous offrant une compréhension approfondie et des idées pour vos futurs projets.

Bonus : Sur cette page, vous avez également la possibilité de télécharger directement le code présenté dans ce tutoriel. N’hésitez pas à le récupérer pour vous familiariser avec sa structure et ses commandes.

Ces fonctions sont les principales méthodes de la bibliothèque AccelStepper utilisées dans notre code pour contrôler le moteur pas à pas.

  • AccelStepper::DRIVER: Il s’agit d’un mode de fonctionnement pour le pilote du moteur pas à pas. Cela indique à la bibliothèque qu’on utilise un pilote externe (comme le TB6600) pour contrôler le moteur, et qu’on ne fait que lui fournir des signaux de step et de direction.

  • stepper(AccelStepper::DRIVER, pinPULS, pinDIR) : Ceci est le constructeur de la classe AccelStepper qui initialise un nouvel objet pour contrôler un moteur pas à pas. Ici, on lui indique le mode de fonctionnement et les pins pour les signaux de step et de direction.

  • stepper.setMaxSpeed(speed) : Cette fonction définit la vitesse maximale à laquelle le moteur peut tourner.
  • stepper.setAcceleration(50) : Cette fonction définit la valeur d’accélération pour le moteur.
  • stepper.moveTo(stepper.currentPosition() + 1000000) : Cette fonction demande au moteur de se déplacer vers une position donnée. Ici, il est demandé au moteur de se déplacer d’un grand nombre de pas depuis sa position actuelle.
  • stepper.setCurrentPosition(0) : Cette fonction réinitialise la position actuelle du moteur à une valeur donnée, dans ce cas, zéro.
  • stepper.stop() : Cette fonction arrête immédiatement le moteur.
  • stepper.run() : Cette fonction doit être appelée régulièrement pour faire tourner le moteur. Elle prend en compte la vitesse, l’accélération, et la position cible pour déterminer les étapes à effectuer.

 

Facebook Twitter Youtube

Grabcad Thingiverse Cults  

Découvrez comment transformer un écran TFT en pseudo-oscilloscope!

.

Dans cette vidéo, nous allons explorer comment utiliser un écran TFT pour visualiser en temps réel les signaux provenant de deux broches analogiques. C’est un outil idéal pour ceux qui souhaitent avoir un aperçu rapide et pratique des signaux électroniques sans investir dans un oscilloscope professionnel.

🔹 Points clés de la vidéo :

1️⃣ Explication de la vitesse de balayage et comment elle est contrôlée par la broche A10.
2️⃣ Visualisation des signaux de A8 et A9 en différentes couleurs.
3️⃣ Utilisation d’un interrupteur pour ajuster l’offset du tracé.

Exemple d’etude :

  • Comprendre le fonctionnement du balayage de notre pseudo-oscilloscope

Le balayage de notre pseudo-oscilloscope est un processus par lequel les signaux électriques sont « balayés » ou tracés horizontalement à travers l’écran, permettant à l’utilisateur de visualiser les variations du signal sur une période de temps. Voici une explication détaillée:

  1. Initialisation: Au début du balayage, une position de départ est définie sur le côté gauche de l’écran (par exemple, la variable x initialisée à 30 dans votre code).
  2. Conversion du Signal: Notre oscilloscope lit les valeurs de tension à partir des broches d’entrée (dans votre cas, A8 et A9). Ces valeurs analogiques sont converties en positions verticales sur l’écran à l’aide de la fonction map(). Ainsi, chaque valeur de tension est représentée par un point sur l’écran.
  3. Tracé du Signal: Chaque valeur lue est dessinée pixel par pixel à partir de la position horizontale initiale. À chaque nouvelle lecture, la position horizontale (x) est incrémentée, créant ainsi un tracé continu qui se déplace horizontalement à travers l’écran.
  4. Vitesse de Balayage: La vitesse à laquelle le tracé se déplace horizontalement est déterminée par la valeur du potentiomètre connecté à la broche A10. Cela permet à l’utilisateur d’ajuster la vitesse de balayage et donc la résolution temporelle de l’affichage.
  5. Réinitialisation: Une fois que le tracé atteint la fin de l’écran ou une position prédéfinie (comme tft.width() - 10), l’écran est effacé et le tracé recommence depuis la position initiale. Cette action simule le comportement d’un véritable oscilloscope, où une fois que le tracé atteint la fin de l’écran, il « revient » pour commencer un nouveau balayage.
  6. Affichage Continu: La boucle de balayage se répète indéfiniment, permettant ainsi une visualisation continue des signaux d’entrée en temps réel.

En résumé, le balayage de notre pseudo-oscilloscope est une représentation visuelle d’un signal électrique au fil du temps, tracé horizontalement sur un écran à une vitesse ajustable.

Facebook Twitter  Youtube

Grabcad Thingiverse Cults  

Guide Pratique pour une Accélération Maîtrisée d’un Moteur Pas-à-Pas avec Arduino

.

Ce code est destiné à contrôler un moteur pas à pas avec un Arduino, en utilisant un driver TB6600. Le code contrôle trois aspects du moteur : l’activation, la direction et la vitesse.

Le contrôle du moteur est réalisé via les broches ENA (Enable), PULS (Pulse) et DIR (Direction). ENA sert à activer ou désactiver le moteur, PULS contrôle le mouvement du moteur en générant des impulsions, et DIR contrôle la direction du mouvement.

L’état d’activation du moteur est contrôlé par l’état d’un bouton physique connecté à la broche Bouton_depart_cycle. Lorsque ce bouton est relâché, le moteur est activé et commence à se déplacer.

Le code utilise aussi une rampe d’accélération, qui est une façon d’augmenter progressivement la vitesse du moteur au démarrage. Lorsqu’elle est active, la rampe d’accélération modifie le délai entre les impulsions envoyées à la broche PULS, ce qui fait accélérer le moteur progressivement. L’activation de la rampe d’accélération est contrôlée par un autre bouton connecté à la broche Bouton_choix_rampe. L’état de la rampe d’accélération est aussi indiqué par une LED

Information complementaire :

Dans ce code, nous utilisons une broche dédiée (oscilloscope) pour surveiller et analyser les impulsions du moteur dans le temps. La ligne digitalWrite(oscilloscope, !digitalRead(oscilloscope)); est responsable de cette opération.

Chaque fois que nous envoyons une impulsion au moteur pour faire avancer d’un pas (qui est gérée par la broche PULS_PIN), nous inversons également l’état de la broche de l’oscilloscope. Cela signifie que l’état de la broche oscilloscope est une réplique du signal de la broche PULS_PIN, elle change donc chaque fois que nous envoyons une impulsion au moteur.

En connectant cette broche à un oscilloscope, nous pouvons visualiser la fréquence et le timing des impulsions du moteur. C’est particulièrement utile lorsque nous utilisons une rampe d’accélération pour contrôler le moteur, car nous pouvons voir comment la vitesse du moteur change en fonction du temps.

L’oscilloscope nous donne une image visuelle de ces variations, ce qui nous permet d’analyser en détail comment notre moteur réagit aux commandes que nous lui donnons. C’est un outil précieux pour le débogage et l’optimisation de notre contrôle moteur.

Facebook Twitter  Youtube

Grabcad Thingiverse Cults  

Coffret de simulation pour moteur pas-à-pas

.

Nous sommes ravis de vous présenter notre Coffret de Simulation pour Moteur Pas-à-Pas. Ce dispositif est conçu pour faciliter vos tests et expérimentations avec des moteurs pas-à-pas.

Au cœur de ce système, vous trouverez un contrôleur angulaire AS 5600, conçu pour garantir un contrôle précis et fiable de la position du moteur. Il comprend également un moteur pas-à-pas pour fournir des mouvements fluides et réguliers dans vos applications.

Le coffret dispose également de deux potentiomètres, tous deux entièrement personnalisables pour s’adapter à vos besoins spécifiques. De plus, vous trouverez quatre boutons poussoirs, également paramétrables, vous offrant une flexibilité maximale pour ajuster et contrôler le comportement du moteur.

Quatre LED paramétrables sont également présentes pour vous offrir une indication visuelle claire et précise de l’état du système.

Le cerveau de ce coffret de simulation est une carte Arduino Uno. Cette plateforme de développement open-source est extrêmement populaire pour sa facilité d’utilisation, sa flexibilité et sa vaste communauté de support. Enfin, le moteur pas-à-pas est piloté par un driver TB6600

Ce coffret a été réalisé grâce à l’impression 3D et fait partie de nos projets open source. Pour faciliter votre travail, nous mettons à votre disposition les fichiers STL ainsi que les schémas de câblage. Vous pouvez donc les modifier et les adapter à vos besoins spécifiques.

En somme, notre Coffret de Simulation pour Moteur Pas-à-Pas représente un outil idéal pour ceux qui cherchent à explorer les capacités des moteurs pas-à-pas de manière contrôlée et efficace.

 

Information complémentaire sur le code.

Serial.begin(115200);
 

Un taux de bauds plus élevé comme 115200 permet non seulement de transmettre des données plus rapidement, mais aussi de rendre la « main » (ou le contrôle) au programme principal plus rapidement après la transmission des données. Cela est dû au fait qu’une vitesse de transmission plus élevée réduit le temps nécessaire pour envoyer chaque caractère de données.

En conséquence, votre programme principal sera en mesure de continuer à exécuter d’autres tâches sans attendre trop longtemps que les données soient transmises via la communication série. Cela peut améliorer l’efficacité et la réactivité de votre programme, surtout s’il doit gérer plusieurs tâches en parallèle ou répondre rapidement à certaines entrées ou conditions.

A savoir:

Bien que des taux de baud plus élevés peuvent théoriquement transmettre des données plus rapidement, ils peuvent également être plus susceptibles d’erreurs en raison du bruit électrique ou d’autres problèmes de signal. 115200 est souvent un bon compromis entre vitesse et fiabilité.

Facebook Twitter  Youtube

Grabcad Thingiverse Cults  

Conception d’un Contrôleur Avancé pour Moteur Pas à Pas avec Arduino et TB6600

Le projet consiste en la conception d’un driver intelligent pour moteur pas à pas en utilisant une carte Arduino couplée à un TB6600. L’objectif de ce projet est de développer un système qui peut non seulement contrôler un moteur pas à pas, mais aussi offrir un ensemble de fonctionnalités avancées pour améliorer l’efficacité et la précision du moteur.

  1. Gestion de DIR et ENA : Le système devra être capable de contrôler les broches DIR (direction) et ENA (enable) du TB6600. Cela permettra de contrôler la direction de rotation du moteur ainsi que d’activer ou de désactiver le driver du moteur.

  2. Gestion de la rampe d’accélération et de décélération : Afin d’éviter des contraintes mécaniques excessives sur le moteur et l’équipement associé, le système devra être capable de gérer la rampe d’accélération et de décélération du moteur. Cela signifie que le moteur devra être capable de démarrer et de s’arrêter progressivement, plutôt que de façon abrupte.

  3. La rétroaction, ou feedback : Un système de rétroaction sera nécessaire pour s’assurer que le moteur fonctionne comme prévu. Cela pourrait impliquer l’utilisation d’un capteur de position pour fournir un retour d’information sur la position réelle du moteur par rapport à la position désirée.

  4. La régulation de vitesse : Le système devra être capable de réguler la vitesse du moteur. Cela peut être nécessaire pour s’assurer que le moteur fonctionne à une vitesse appropriée pour la tâche qu’il est en train d’effectuer.

  5. Mode apprentissage : Un mode d’apprentissage sera intégré pour permettre au système d’apprendre et d’enregistrer une série de mouvements du moteur. Cela pourrait être utile pour automatiser des tâches répétitives.

Ce cahier des charges fournit un aperçu général des principales fonctionnalités que devra posséder le driver intelligent pour moteur pas à pas. Il sera nécessaire de réaliser des recherches et des tests supplémentaires pour définir plus précisément ces fonctionnalités et déterminer la meilleure façon de les implémenter.

Facebook Twitter  Youtube

Grabcad Thingiverse Cults