Archives

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  

Calibration d’un écran tactile avec Arduino : Guide Complet

Bienvenue dans ce tutoriel dédié à l’utilisation et à la compréhension des écrans tactiles TFT résistifs avec Arduino. Dans la première partie de ce tutoriel, nous aborderons le principe de fonctionnement d’une dalle résistive, afin que vous puissiez comprendre comment ces composants clés traduisent un toucher en signaux électriques.

Nous passerons ensuite à l’aspect pratique en montrant comment calibrer et utiliser un écran tactile TFT avec Arduino. Nous utiliserons pour cela les bibliothèques Adafruit_GFX pour les fonctionnalités graphiques de base, MCUFRIEND_kbv pour la prise en charge de l’écran TFT, et TouchScreen pour gérer les interactions avec l’écran tactile.

Nous détaillerons le code, en expliquant comment définir les broches de l’écran LCD, configurer l’écran tactile, et initialiser l’écran TFT. Nous vous montrerons également comment lire les coordonnées de l’écran tactile, les convertir en pixels sur l’écran, et les afficher.

Ce tutoriel convient parfaitement à ceux qui s’intéressent à la programmation Arduino et aux projets impliquant des écrans tactiles TFT.

Matériel nécessaire :

  1. Arduino (nous utilisons un Arduino UNO dans ce tutoriel)
  2. Écran tactile TFT de 3.5 pouces avec driver IC ILI9327

Facebook Twitter  Youtube

Grabcad Thingiverse Cults  

Intégration du capteur angulaire AS5600 pour vos projets de moteur pas à pas.

Le capteur AS5600 est un capteur de position angulaire magnétique. Il est conçu pour mesurer avec précision l’angle de rotation d’un objet, tel qu’un moteur, un arbre ou une pièce mobile. Voici quelques utilisations courantes du capteur AS5600 :

  1. Contrôle de moteurs : Le capteur AS5600 est largement utilisé dans le contrôle des moteurs, notamment les moteurs pas à pas, pour mesurer précisément l’angle de rotation et contrôler le positionnement et la vitesse de manière précise.
  2. Robotique : Dans les applications robotiques, il permet de détecter l’orientation et la position des bras, articulations et pièces mobiles, assurant un contrôle efficace des mouvements pour des tâches précises.
  3. Électronique grand public : Utilisé dans les manettes de jeu, drones, caméras motorisées, robots jouets, il fournit des informations précises sur l’orientation et la position, améliorant le fonctionnement et l’ergonomie des appareils.
  4. Contrôle d’axe : Dans les machines CNC, imprimantes 3D, équipements de gravure, il mesure l’angle des axes pour un positionnement précis et une stabilité de position.
  5. Automatisation industrielle : Intégré aux machines, robots et équipements, il assure le contrôle précis de position et d’orientation, répondant aux exigences des applications industrielles.

En résumé, le capteur AS5600 joue un rôle essentiel dans différentes applications, allant de la robotique à l’électronique grand public en passant par l’automatisation industrielle. Les concepteurs et les ingénieurs apprécient sa précision, sa facilité d’utilisation et sa fiabilité, ce qui en fait un choix populaire. Il mesure avec précision l’angle de rotation et facilite le contrôle dans divers domaines d’application.

Dans cette vidéo, nous vous présentons l’utilisation du capteur AS5600 pour mesurer précisément l’angle de rotation d’un moteur pas à pas. Découvrez comment câbler le capteur et l’intégrer à votre projet Arduino. Nous vous montrons également comment réaliser des essais en manipulant l’aiguille d’un système d’indexage et obtenir le retour de la valeur d’angle sur le moniteur IDE. Un tutoriel détaillé du code est également inclus pour faciliter votre compréhension. Exploitez tout le potentiel du capteur AS5600 et améliorez vos projets de contrôle de positionnement avec précision.

Facebook Twitter  Youtube

Grabcad Thingiverse Cults  

    •  
Le code pour le TB6600 5/8 , Contrôle d’un moteur pas-à-pas en fonction de l’angle souhaité

Contrôle d’un moteur pas à pas en fonction
de l’angle de rotation souhaité

Ce programme permet de contrôler un moteur pas-à-pas pour effectuer un angle de rotation spécifié en degrés en appuyant sur un bouton. Le programme utilise les bibliothèques Arduino standard pour contrôler les broches d’entrée et de sortie et pour déterminer le temps écoulé entre les impulsions pour contrôler la vitesse du moteur.

  1. Déclarations de variables : Les constantes et variables nécessaires pour le contrôle du moteur sont définies ici, comme les broches de contrôle, la résolution du moteur, la base de temps pour les impulsions et d’autres variables d’état.
  2. La fonction ConversionAngleEnTour(float angle) convertit un angle en degrés en un nombre de pas pour un moteur pas-à-pas.
  3. Le setup() configure les broches d’entrée et de sortie du microcontrôleur et initialise les variables nécessaires au bon fonctionnement du programme.
  4. Le loop() effectue les opérations suivantes :
  • Lecture de l’état du bouton.
  • Inversion de l’état du moteur lorsque le bouton est enfoncé.
  • Si le moteur est en marche, il calcule le nombre total de pas nécessaires pour effectuer la rotation souhaitée et effectue la rotation en générant des impulsions sur la broche PULS_PIN.
  • Lorsque le moteur a atteint le nombre de pas souhaité, il arrête le moteur et réinitialise le compteur de pas.
  • Si le moteur n’est pas en marche, il allume la LED pour indiquer que le moteur est en attente de validation pour tourner.
Voici le principe de codage de la fonction : ConversionAngleEnTour
 

Ce code définit une fonction appelée ConversionAngleEnTour, qui prend un argument angle de type float. La fonction a pour but de convertir un angle en degrés en un nombre de pas pour un moteur pas-à-pas.

Dans le corps de la fonction, on trouve l’expression angle * resolution / 360.0. Cette expression effectue les opérations suivantes :

  1. Multiplie l’angle donné par la valeur de la variable resolution, qui représente le nombre de pas nécessaires pour effectuer un tour complet (360 degrés).
  2. Divise le résultat par 360 pour déterminer la proportion d’un tour complet que représente l’angle en question.

Ensuite, la fonction renvoie le résultat sous la forme d’un entier (en utilisant le cast (int)), correspondant au nombre de pas nécessaires pour effectuer la rotation souhaitée.

Par exemple, si l’angle est de 180 degrés et que la résolution est de 800 pas par tour, la fonction renverra 400 pas (180 * 800 / 360 = 400).

Facebook Twitter  Youtube

Grabcad Thingiverse Cults  

    •  
Arduino Nano 33 ble sense : Detection des couleurs avec le capteur APDS9960

Arduino Nano 33 ble sense : Detection des couleurs avec le capteur APDS9960

Découvrez comment utiliser le capteur APDS9960 avec Arduino pour calculer la couleur dominante et afficher à la fois le nom de la couleur et la valeur numérique correspondante. Le code est détaillé étape par étape, avec des explications sur les fonctions utilisées pour la détection de la couleur.

Voici la vidéo :

✔️ Descriptif du code 1 : Utilisation du capteur APDS9960 pour la détection de la couleur avec Arduino

Le programme commence par inclure la bibliothèque Arduino_APDS9960.

Ensuite, dans la fonction setup(), la communication série est initialisée à une vitesse de 9600 bauds. Le programme attend ensuite que la communication série soit établie. Ensuite, le capteur APDS9960 est initialisé. Si l’initialisation échoue, un message d’erreur est affiché.

Dans la fonction loop(), les valeurs de couleur détectées sont affichées sur le port série en utilisant la fonction Serial.print(). Ce code est conçu pour être utilisé avec le traceur de courbes de l’IDE Arduino 2.0.3,qui permet d’afficher les données sous forme de graphique en temps réel.

Le traceur de courbes de l’IDE Arduino 2.0.3 s’attend à recevoir des données sous forme de texte structuré.Dans ce code, les valeurs de couleur sont affichées en premier la valeur bleue, puis une virgule, puis la valeur rouge, suivie d’une autre virgule, puis la valeur verte, et enfin un saut de ligne pour passer à la ligne suivante. Cette séquence de caractères est importante car le traceur de courbes est configuré pour reconnaître cette structure et afficher les données correctement sous forme de courbe.

✔️ Descriptif du code 2 : Recherche de la couleur dominante avec le capteur APDS9960

Le programme commence par inclure la bibliothèque « Arduino_APDS9960.h » qui contient les fonctions pour communiquer avec le capteur de couleur.

Le setup est identique au premier code .

Dans la fonction « loop », le programme entre dans une boucle qui attend jusqu’à ce qu’une mesure de couleur soit disponible en utilisant « while (!APDS.colorAvailable()) ». Lorsqu’une mesure est disponible, les valeurs de rouge, vert et bleu sont lues à partir du capteur en utilisant « APDS.readColor(r, g, b) » et stockées dans les variables correspondantes.

Ensuite, le programme détermine la couleur dominante en comparant les valeurs de rouge, vert et bleu. Si la valeur de rouge est la plus élevée, le programme affiche « Rouge » sur la console série en utilisant « Serial.println(« Rouge ») ». Si la valeur de vert est la plus élevée, le programme affiche « Vert ». Si la valeur de bleu est la plus élevée, le programme affiche « Bleu ». Si les trois valeurs sont égales, le programme affiche « Blanc ». Sinon, le programme affiche « Couleur mixte ».

✔️ Descriptif du code 3 : Calcule la couleur dominante et affiche à la fois le nom de la couleur dominante et la valeur numérique.

Dans la boucle principale (loop()), le programme attend qu’une mesure de couleur soit disponible en utilisant la fonction colorAvailable() du capteur APDS9960. Une fois qu’une mesure de couleur est disponible, les valeurs de rouge, vert et bleu sont stockées dans des variables respectives à l’aide de la fonction readColor(). Les valeurs de rouge, vert et bleu sont affichées sur la console série à l’aide de la fonction Serial.println().La valeur maximale parmi les valeurs de rouge, vert et bleu est trouvée à l’aide de la fonction max().Ensuite, la couleur dominante est déterminée en fonction de la valeur maximale. Si la valeur maximale est le rouge, « Rouge » est stocké comme couleur dominante, si c’est le vert, « Vert » est stocké et sinon, « Bleu » est stocké.

La couleur dominante est stockée dans une chaîne de caractères et affichée sur le moniteur série.

Facebook Twitter  Youtube

Grabcad Thingiverse Cults  

Le code pour le TB6600 2/8, Contrôle de la vitesse

TB6600 2/8,Contrôle de la vitesse et de la direction d’un moteur pas-à-pas avec Arduino

Le code commence par définir les broches utilisées pour le contrôle du moteur, à savoir ENA_PIN (broche pour activer/désactiver le moteur), PULS_PIN (broche pour générer les impulsions) et DIR_PIN (broche pour définir la direction). Ensuite, les variables TEMPO (qui stocke la tempo en microsecondes), nouvelle_tempo (initialisée à 0), valeur_alpha_nouvelle_tempo (une chaîne de caractères qui stocke la nouvelle tempo saisie par l’utilisateur), et chaine_caractere (une chaîne de caractères qui stocke les données entrées sur le port série) sont définies.

Dans la fonction setup(), la communication série est initialisée avec une vitesse de transmission de 9600 bauds. Les broches sont configurées en sortie.

const int ENA_PIN = 8; Broche pour activer/désactiver le moteur
const int PULS_PIN = 9; Broche pour générer les impulsions
const int DIR_PIN = 10; Broche pour définir la direction

La fonction loop() est exécutée en boucle sans fin après le démarrage de l’Arduino. Si des données sont disponibles sur la communication série (Serial.available() supérieure à 0) ), la fonction Serial.readStringUntil lit une chaîne de caractères entrée sur le port série de l’Arduino et la stocke dans la variable chaine_caractere. Ensuite, la fonction indexOf() est utilisée pour rechercher les lettres ‘A’, ‘a’, ‘R’ et ‘r’ dans la chaîne de caractères.

Si la lettre ‘A’ ou ‘a’ est trouvée dans la chaîne de caractères (indexA != -1 || indexa != -1), cela signifie que l’utilisateur a saisi une commande de marche avant. La direction est alors définie en mode horaire (digitalWrite(DIR_PIN, HIGH)), et la valeur de la nouvelle tempo est extraite de la chaîne de caractères à partir de la position de la lettre ‘A’ ou ‘a’. Cette valeur est stockée dans la variable valeur_alpha_nouvelle_tempo et affichée sur le port série. Enfin, la valeur de la variable TEMPO est mise à jour avec la nouvelle tempo saisie.

Si la lettre ‘R’ ou ‘r’ est trouvée dans la chaîne de caractères (indexR != -1 || indexr != -1), cela signifie que l’utilisateur a saisi une commande de marche arrière. La direction est alors définie en mode antihoraire (digitalWrite(DIR_PIN, LOW)), et la valeur de la nouvelle tempo est extraite de la chaîne de caractères à partir de la position de la lettre ‘R’ ou ‘r’. Cette valeur est stockée dans la variable valeur_alpha_nouvelle_tempo et affichée sur le port série. Enfin, la valeur de la variable TEMPO est mise à jour avec la nouvelle tempo saisie.

Si aucune des lettres ‘A’, ‘a’, ‘R’ et ‘r’ n’est trouvée dans la chaîne de caractères, un message est affiché sur le port série indiquant que la confirmation de sens de direction est manquante.

Et enfin, pour réaliser la création du train d’impulsions, on commence par récupérer le temps actuel en microsecondes. Ensuite, on vérifie si le temps écoulé depuis la dernière impulsion est supérieur ou égal à la valeur de la tempo. Si c’est le cas, on met à jour le temps précédent avec le temps actuel et on inverse l’état de la broche PULS_PIN pour générer une impulsion. Ce code permet donc de générer des impulsions avec une fréquence régulière en fonction d’une valeur de tempo donnée.

Facebook Twitter  Youtube

Grabcad Thingiverse Cults