ARDUINO: le CNC SHIELD

voyons ici comment utiliser le CNC SHIELD pour des applications de pilotage de moteurs pas a pas en dehors du domaine de la CNC de loisir.

nous avons vu dans la rubrique moteur pas a pas comment piloter un moteur type NEMA 17 a partir d’un driver type POLOLU A4988 , a partir de ce principe , il est possible de piloter plusieurs moteur NEMA sur un ARDUINO UNO . Dans la rubrique ARDUINO-CNC , est développé brièvement la description de l’utilisation d’un CNC SHIEL pour commander une petite CNC DIY de loisir , nous allons voir ici de façon plus approfondie son principe et ses utilisations potentielles dont aussi les utilisations autres que pour de la CNC.

DESCRIPTION

comme tous les shield , le CNC shield est prévu pour se monter sur un ARDUINO UNO mais aussi sur un ARDUINO MEGA.

vue de dessus

vue arriere

BROCHAGE

le shield est concu a la base pour etre utilisé en applications CNC sur un ARDUINO avec GRBL installé dessus . GRBL est un programme permettant de lire des instruction GCODE reçues d’un programme de conduite de CNC et de les transformer en trajectoires lineaires ou circulaires. pour les aspects CNC et GCODE voir les rubriques dédiées du site.

son architecture est donc prévue pour fonctionner selon le brochage arduino ci dessous:

le shield comporte des slot permettant de recevoir des drivers d’axe type POLOLU A4988 ou DRV8825 dont l’architecture de fonctionnement est la suivante :

le principe de fonctionnement est décrit avec des exemples de programme arduino simple dans la rubrique spécifique ICI

ALIMENTATION

le shield comporte un bloc de connexion bleu en bas a gauche permettant de faire l’alimentation en puissance (motor power supply 8-35V ) en orange dans le schéma ci dessus. pour les montage en alimentation 12V ( batterie auto ou moto) il est possible de combiner l’alimentation du shield et de l’arduino via un cable commun dont voici une proposition de conception avec des prises jack male/femelle standard de 5,5mm:

le shield est prévu pour recevoir jusqu’a 4 drivers type POLOLU dont les emplacements sont notés: X – Y – Z – A . visuellement , ils sont différenciés par des slot jaunes pour X,Y et Z et des slots ROUGE pour A. cette notation est en correspondance avec la notation des axes utilisé en CNC. chaque emplacement comporte son condensateur filtre de 100 micro farrad entre les 2 rangées de slot support

le 4° driver ( emplacement A, slot rouge) peut etre configuré pour une utilisation en synchronisation avec l’un des 3 autres soit en 4° axe propre. on peut donc piloter jusqu’a 4 moteurs pas a pas indépendamment avec un CNC SHIELD.

CONFIGURATION DU 4° DRIVER:

elle se fait au moyen de cavaliers a positionner sur les broches juste au dessus du connecteur d’alimentation

ici un exemple de config avec l’axe A en tandem de l’axe Y

et pour un fonctionnement en 4° axe , dans ce cas ce sont les broches 12 et 13 de l’arduino qui vont permettre de piloter le driver en DIR/STEP avec la broche 12 arduino pour le signal STEP et la broche 13 arduino pour le signal DIR.

le schema de brochage ARDUINO equivalent devient ainsi le suivant ( modifications en rouge):

LE MICRO STEPPING:

le micro stepping de chaque driver se configure indépendamment au niveau de chaque emplacement via des broche sur lesquelles on positionne des jumpers de court circuit permettant de mettre chaque position M0-M1-M2 au 5V avec un cavalier dédié. sans cavalier , le bloc correspondant est au niveau LOW, avec un cavalier il passe au niveau HIGH

le choix de configuration dépends du niveau de micro-stepping souhaité , par exemple avec un drive DRV8825 capable d’un micro-stepping jusqu’a 1/32 voici les config possibles :

le probleme avec le shield CNC c’est que le micro-stepping n’est pas commandable via une broche arduino. une fois les cavaliers positionnés , pas possible , a priori , de faire varier le micro-stepping avec un code arduino via une broche de l’UNO.

ceci dit si l’on reprends le brochage de l’UNO avec 4 moteurs :

les broches 8-9-10 et 11 , dédiées a la fonction Enable et aux limites d’axes en version shield CNC sont disponibles pour d’autres actions , il est donc possible de les utiliser pour une “config” globale du micro-stepping en renvoyant les pins de config des drivers sur ces sorties. pour cela il suffit de réaliser des câbles spécifiques entre les broches de micro-stepping des drivers et les broches 8-9-10-11.

exemple d’un cable simple :

qui une fois branché sur les broches END STOPS X+ et X- correspondant a la broche D9 permet de contrôler l’état de M2 via le programme . avec 3 cables communs sur les broches M0 , M1 et M2et sur les broches 9-10-11 de l’arduino il est donc possible de contrôler via le soft , de façon commune, l’état des 3 broches M0, M1 et M2 des drivers.

la photo ci dessous montre une configuration ou les 2 supports de POLOLU X et Y ont un cavalier vert sur M0 et jaune sur M1 et le cable de renvoi M2 sur les broches X+ X- soit D9 sur l’arduino Uno ( voir ci dessous descriptif des connecteurs) . ce câblage permet donc de switcher, des POLOLU DRV8825 par programme C++ entre une config M0-M1-M2 a niveau HIGH-HIGH-LOW ( 1/8step) et HIGH-HIGH-HIGH (1/32 step).

bien sur ces 3 broches peuvent être utilisée a d’autres contrôles que les drivers.

LA CONNECTIQUE LATÉRALE DROITE:

le connecteur latéral a droite de la carte permet de récupérer un certain nombre de broches de l’arduino uno sur lequel il est branché, et donc brancher des capteurs ou des actionneurs. en voici la description:

L’ INTERFACE I2C :

Vu le nombre de sortie Arduino utilisées pour commander 4 moteurs pas a pas en utilisant les broche D9 D10 et D11 pour commander le microstepping, il peut etre interressant d’utiliser l’interface I2C pour communiquer avec des composants exterieurs compatibles du protocole I2C . pour cela il suffit d’utiliser l’ensemble des broches du connecteur en haut ( colonnes jaunes et bleues) sur la photo précédente . on y trouve en renvoi les broches GND et 5V ainsi que SDA ( A4) et SCL (A5) de l’interface I2C.

avec 2 bloc Dupont 4 connexions collés dos a dos on peut ainsi réaliser une prise rapide, comme par exemple dans la photo ci dessous ou le câble va ensuite sur un connecteur RJ11 utilisant un câble torsadé de téléphone pour aller a un ensemble écran/clavier/joystick géré sous le protocole I2C:

.

REFROIDISSEMENT DES DRIVERS

il est possible de rajouter un petit ventilateur 5V sur le coté pour produire un flux d’air afin de refroidir les drivers (munis de radiateurs) , ceci ameliore l’efficacité des drivers. il faut donc réaliser un petit support pour fixer le ventilo sur le caté du bloc arduino/CNC shield.

exemple de réalisation : pour obtenir le fichier STL , voir ICI

ARDUINO transmission radio

dans le cadre de communications sans fil , une alternative au wifi est la comm radio.

nous allons voir ici l’utilisation d’émetteur et récepteur 433MHz avec dans un premier temps la communication dans un seul sens , de l’émetteur vers le récepteur

les deux éléments utilisé sont :

un émetteur 433 MHz

un récepteur 433MHz

pour utiliser ces 2 éléments , il faut bien évidemment un arduino Uno branché a chacun d’entre eux , voici les schémas de branchement respectifs:

circuit d’émission

circuit de réception

EXEMPLE :

pour montrer un exemple concret de transmission, nous allons tout simplement envoyer la valeur lue d’un potentiomètre via l’Arduino émetteur et la recevoir et l’afficher dans le moniteur série sur l’Arduino de réception.

branchement du potentiomètre :

en plus de l’émetteur , nous allons ajouter un potentiomètre sur l’entrée analogique 0 de l’arduino:

programme coté émetteur:

programme coté récepteur:

les deux programmes utilisent la bibliotheque RCswitch

https://www.arduino.cc/reference/en/libraries/rc-switch/

charger le programme d’émission sur l’Arduino coté émetteur , débrancher l’Arduino du PC et ajouter une pile d’alimentation . brancher l’Arduino récepteur au port USB via le câble classique et charger le programme de réception .

démarrer le moniteur série et manipulez le potentiomètre coté Arduino émetteur, les valeurs sont lues puis envoyées par le circuit d’émission, reçues par ondes radio coté réception et affichées sur le moniteur série .

petite vidéo YouTube qui montre le processus complet:

voila rien de plus compliqué , on pourrait remplacer l’affichage par le pilotage d’un servo RC , voir par exemple ici l’utilisation d’un servo :

https://www.e-techno-tutos.com/2020/12/05/arduino-servo-libre/

il est possible de remplacer l’émetteur et le récepteur par deux circuits HC-12 qui ont la capacité de communication dans les 2 sens (modules bidirectionnels émission et réception) et ainsi bâtir des solutions de communication via onde radio…

ARDUINO-Basiques

les basiques de la programmation ARDUINO avec la documentation PDF du site du zero (Openclasroom maintenant)

cette documentation très complète, facilement accessible vous permettra d’apprendre les bases classiques du langage , la gestion des entrées sorties , les variables, les fonctions, etc…

ARDUINO – Moniteur Série

petit cablage simple pour découvrir l’utilisation du moniteur série. un potentiomètre branché entre 0V et 5V et son point variable sur la broche Analogique A0 .

programme de test: on met la valeur de la broche analogique dans une variable “PotValue” et on l’envoi sur la sortie serie avec un renvoi a la ligne ( Serial.println() )

void setup() {
  Serial.begin(9600);
}
 
void loop() {
  int PotValue = analogRead(A0);
  Serial.println(PotValue);
  delay(1);      
}

on televerse le programme dans l’arduino , on ouvre le moniteur serie et on tourne le potentiometre pour faire varier la valeur envoyée sr le moniteur série.

ARDUINO – module analogique KY-013

le module KY-013 est un capteur de température ambiante analogique. il combine une thermistance NTC avec une résistance 10 K Ohms. il fonctionne sur 5V et a une plage de mesure de -55°C à 125°C avec une précision de ±0.5°C.

le principe de base utilise le fait que la résistance de la thermistance varie avec la température. on va donc le brancher sur une broche analogique de l’ARDUINO et utiliser la relation de Steinhart-Hart pour calculer l’équivalence résistance / température.

la température retournée est en Kelvin, il faudra ensuite faire la transformation Kelvin -> Degrés C.

SCHÉMA DE BRANCHEMENT:

le programme: apres mesure et conversion, affichage du resultat sur le moniteur série.

int ThermistorPin = A0;
int Vo;
float R1 = 10000; // valeur de R1 sur le module
float logR2, R2, T; 
float c1=0.001129148, c2=0.000234125, c3=0.0000000876741;  //coefficients steinhart-hart 

void setup() {
  Serial.begin(9600);
}

void loop() {
  Vo = analogRead(ThermistorPin);
  R2 = R1 * (1023.0 / (float)Vo - 1.0);     //calcule la résistance sur le thermistor
  logR2 = log(R2);
  T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));     // température en Kelvin
  T = T - 273.15;        //Kelvin -> Celcius
  Serial.print("Temperature: "); 
  Serial.print(T);
  Serial.println(" °C");
  delay(500);
}

OPB 704

une rubrique dédiée à l’OPB704 et plus largement aux systeme à diode émettrice et réceptrice infrarouge.

l’OPB 704 est un composant comportant une diode émettrice et une diode réceptrice infrarouge. les 2 composants sont encapsulés dans un petit boitier les disposant a un angle permettant la réfection sur une pièce se présentant en face du composant et permettant d’utiliser l’ensemble comme détecteur de proximité sans contact.

outre la détection de proximité, ce type de matériel se prête bien a la détection de passage proche ou les fonctions type compte tour , son fonctionnement est similaire a celui des codeurs a fourches IR du type ci dessous que l’on trouvait par exemple dans les souris a boules :

le détecteur a fourche fonctionne en passe/passe pas avec une pièce intermédiaire munie de fentes qui laissent passer ou pas le faisceau infra rouge de la diode émettrice permettant une fonction de comptage. l’OPB704 lui fonctionne en réfection.

le câblage electrique standard de la fonction sur l’OPB704 est présenté ci dessous .

une version très compacte du câblage peut être réalisée directement sur le composant de la façon suivante:

ce câblage fonctionne très bien avec un couple de diodes utilisées tête bêche comme dans le détecteur a fourche donc sans le boitier de l’OPB704 . information interressante , la tension “Vout” est proportionnelle a l’intensité lumineuse reçue.

l’utilisation avec un arduino est simple , on va utiliser le signal “Vout” sur une broche d’entrée pour des fonctions de tections ou de comptage . les applications potentielles sont nombreuses, les plus courantes sont les suivantes:

  • détecteur d’ouverture de porte
  • capteur de fin de course sans contact
  • détecteur angulaire simple
  • compte tour

voyons quelques exemples d’applications

EXEMPLE 1: compte tour

l’idée est de coller un scotch réfléchissant sur une pièce en rotation et d’utiliser l’OPB704 pour mesurer la vitesse de rotation. on fait afficher le résultat sur le moniteur série

le programme :

il va utiliser une interruption pour effectuer la mesure de temps entre deux impulsions (passage du scotch devant l’OPB704):

volatile float time = 0;
volatile float time_last = 0;

void setup() {
  Serial.begin (19200);  
  attachInterrupt(0, rpm_interrupt, RISING);     //Pin 2 Set As An Interrupt ( if signal increase)
}

// Loop To Calculate RPM and Update the serial monitor Display
void loop() {
  int rpm = 0;
    while(1){ 
      delay(500);                //Slow Down Display Updates ( half second)
      Serial.println (" ");
      Serial.println (" ");   
      Serial.print ("rpm: ");   
      Serial.println (rpm);    
        if(time > 0) {
          rpm = 60*(1000000/(time));    
        }
    }
}

//Capture The OPB704 Beam =>Interrupt
void rpm_interrupt() {
   time = (micros() - time_last); 
   time_last = micros();
}

.

EXEMPLE 2: compte tour avec afficheur LCD

même montage , mais avec affichage sur écran LCD

le programme :

#include <Wire.h> 
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x20,16,2);  // LCD address to 0x20 (16 chars on 2 line)
volatile float time = 0;
volatile float time_last = 0;
void setup() {
  lcd.init(); 
  lcd.backlight(); 
  lcd.setCursor(0,0);        // (col,row)
  lcd.print("rpm: "); 
  attachInterrupt(0, rpm_interrupt, RISING);     //Pin 2 As Interrupt ( if signal increase)
}

void loop() {                    // Loop To Calculate RPM and Update the LCD Display
  int rpm = 0;
    while(1){ 
      delay(500);                //Slow Down Display Updates ( half second)
      if(time > 0) { 
        rpm = 60*(1000000/(time));  
        lcd.setCursor(0,1);
        lcd.print(rpm);  
        }   
    }
}

void rpm_interrupt() {              //Capture The OPB704 Beam =>Interrupt
   time = (micros() - time_last); 
   time_last = micros();
}

ARDUINO – capteur HC-SR501

petit tuto consacré au détecteur infrarouge HC-SR501 ( portée jusqu’à 7m) utilisable en détection de présence et détection de mouvement pour des système d’alarme ou pour de la prise de vue automatique en animalier ou équivalent. il peut être également utilisé avantageusement avec une ESP32 CAM (voir rubrique dédiée a l’ESP32 cam).

DATA SHEET DU CAPTEUR:

petit montage de test simple, on allume une LED si détection de mouvement

un bout de programme très basique pour exploiter le montage et faire des essais en modifiant le réglage des 2 potentiomètres de sensibilité et durée.

void setup() {
  pinMode(2,INPUT);
  pinMode(13,OUTPUT);
}

void loop() {
  digitalWrite(13,digitalRead(2));
}

voila , pas grand chose de plus a expliquer , a vous de voir comment utiliser ça en pratique.par exemple déclenchement d’une sirène , ou d’un appareil photo si détection de mouvement . bien d’autres applications possibles sur ce principe.

ARDUINO – SERVO

2 petits montages simple qui permettent d’appréhender le fonctionnement et le pilotage d’un servo avec un arduino .

cablage 1: le plus basique

programme simple :

petit programme qui met le servo en position 0 pendant 2 secondes , puis 90° pendant 2 secondes, puis 180° puis retour a 90 et boucle infini (retour a 0 => 90° etc..

#include <Servo.h>
Servo myservo;
void setup() {
  myservo.attach(3); 
}
void loop() {
  myservo.write(0);                 
  delay(2000);
  myservo.write(90);                 
  delay(2000);
  myservo.write(180);                 
  delay(2000);
  myservo.write(90);                 
  delay(2000);                      
}

cablage 2 : ajout d’un potentiomètre

programme qui asservi la position du servo a la position du potentiometre:

#include <Servo.h>
Servo myservo; 
int potpin = 0; 
int val;   
void setup() {
  myservo.attach(3); 
}
void loop() {
  val = analogRead(potpin);           
  val = map(val, 0, 1023, 0, 180);    
  myservo.write(val);                 
  delay(15);                          
}

ARDUINO – commande de pas a pas NEMA

autre moteurs pas a pas courants dans les montage arduino, les moteur NEMA dont en particulier les NEMA 17 .

la désignation NEMA ( National Electrical Manufacturers Association) caractérise une famille de moteurs pas a pas dont l’interface de fixation ( partie gauche sur la photo ci dessus) est standardisée. ce type de moteur est très largement utilisé dans les montage de machines CNC de hobby ( imprimantes 3D, fraiseuses CNC, graveuses laser, etc), mais peut avantageusement être utilisé pour bien d’autres applications a base d’ARDUINO.

le plus connu dans la famille NEMA étant le NEMA 17. l’un des intérêt de ces pas a pas par rapport a un 28BYJ-48 étant le couple et la précision de mouvement obtenu. les NEMA 17 les plus courants ont 200 pas par tour et certains 400 pas et aucun jeu mécanique sur l’axe.

pour commander ces moteurs on utilise majoritairement des Drivers Pololu A4988. je ne rentrerai pas plus dans les caractéristique et les explications sur le pilotage et vous encourage a aller consulter la rubrique ARDUINO – CNC pour approfondir le sujet (principe de pilotage, réglage des pololu, etc..). ici nous allons nous concentrer sur l’utilisation a des fins autres que le pilotage de CNC sous GRBL.

même si nous ne traitons pas de l’aspect CNC , pour piloter ce type de moteur , je recommande l’utilisation de modules type ELEKSMAKER a base d’ARDUINO NANO ou l’utilisation d’ARDUINO UNO et CNC SHIELD si vous souhaitez piloter plusieurs moteur pas a pas NEMA 17 a la fois, avec un maximum de 3 pour les CNC shields.

COMMANDE D’UN NEMA 17 avec un POLOLU A4988:

le principe de commande est décrit ( en anglais) dans les pages dédiées du fabricant:

https://www.pololu.com/product/1182

on y trouve egalement la liste des différents modules disponibles et leur caractéristiques:

https://www.pololu.com/category/120/stepper-motor-drivers

voici le diagramme générique de branchement d’un module POLOLU :

sur ce schéma , le câblage est en mode full step , il manque donc le branchement des broches MS1 – MS2 – MS3 qui permettent de piloter le moteur en micro-stepping, le tableau ci dessous donne le mode de branchement a appliquer suivant le micro-stepping souhaité (high = mise au 5V):

ainsi un NEMA 17 à 200 pas par tour piloté par un POLOLU A4988 en mode “sixteenth step” aura une précision de 200×16=3200 pas par tour soit pour un pas une précision angulaire en rotation de 360/3200=0,11 degré.

EXEMPLE DE COMMANDE D’UN NEMA17 en full micro-stepping

le bout de programme ci dessous fait tourner le moteur d’un tour dans un sens puis d’un tour dans l’autre sens .

void setup() {
  pinMode(8,OUTPUT);  // DIR Pin 
  pinMode(9,OUTPUT);  // STEP Pin 
}
void loop() {
  digitalWrite(8,LOW); // DIR sens1  
  for(int x = 0; x < 3200; x++) {
    digitalWrite(9,HIGH); 
    delay(1); 
    digitalWrite(9,LOW); 
    delay(1); 
  }
  delay(500); 
  digitalWrite(8,HIGH); // DIR sens2
  for(int x = 0; x < 3200; x++) {
    digitalWrite(9,HIGH); 
    delay(1); 
    digitalWrite(9,LOW); 
    delay(1); 
    } 
  delay(500);   
}

la commande : ” digitalWrite(8,LOW);” met le signal de la broche DIR n°8 a l’état bas soit dans le sens de rotation 1, puis la première boucle “for(int x = 0; x < 3200; x++) ” envoi 3200 fois une alternance de signaux haut et bas ( avec delay d’1ms entre chaque alternance) sur la broche PULSE n° 9 . chaque alternance fait avancer d’un pas , et comme le POLOLU A4988 est cablé en microstepping 1/16 avec un NEMA17 a 200 pas , le moteur va tourner de 3200 pas soit un tour. a raison d’1ms entre chaque alternance soit 2ms par pas, il faut 3200×2=6400 ms donc 6,4 secondes pour un tour. apres la fin de la première boucle for , le programme marque une pause de 500ms ( 1/2 seconde) et la commande “digitalWrite(8,HIGH);” met la broche DIR 8 a l’etat Haut pour changer le sens de rotation . ensuite une nouvelle boucle “for” fait faire 3200 pas au moteur , puis la boucle loop reprends depuis le debut apres une pause de 500ms.

on aurai pu câbler les broche MS1/MS2/MS3 sur une sortie de l’ARDUINO de façon a pouvoir contrôler le microstepping par le programme . si par exemple avec le programme ci dessous , on passe d’un stepping 1/16 a un full step et la boucle de comptage “for” avec 200 pas de comptage, on pourrait faire tourner le moteur d’un tour en 200ms soit 0,2 s ( a condition que le driver soit capable de fournir le courant nécessaire). en résumer , on peut faire varier la vitesse de rotation de 2 façon; en faisant varier le temps de pause entre chaque impulsion, ou en changeant le microstepping . sachant que la valeur de la commande”delay(1);” pourrait être remplacée par une variable, on pourrait très bien egalement asservir la vitesse a un potentiomètre branché sur une broche analogique de l’UNO.

nous venons de voir comment commander un NEMA 17 avec des commandes simples , il est également possible d’utiliser des librairies . l’une des plus connue est “Stepper.h”. ci dessous le même programme que précédemment mais avec la bibliothèque “Stepper.h”. celle ci a entre autre comme particularité de comporter une commande qui fixe la vitesse de rotation qu’on pourrait la aussi parametrer et asservir a une sortie Analogique.:

# include <Stepper.h>
Stepper myStepper(3200, 8, 9, );

void setup() {
  myStepper.setSpeed(60);
}

void loop() {
  myStepper.step(3200);
  delay(500);
  myStepper.step(-3200);
  delay(500);
}

sur la base de ces principes il est bien entendu possible de piloter plusieurs moteurs NEMA 17 , la limite etant fixée par le nombre de broches ARDUINO disponibles a raison de 2 broche ( STEP/DIR) pour chaque NEMA soit au maximum 6 NEMA 17 avec les 13 broches Digitales de l’UNO. le fonctionnement est parfaitement identique avec un Arduino NANO .

ARDUINO – PaP 28BYJ-48 / ULN2003

nous allons découvrir des utilisations simples du moteur pas a pas 28BYJ-48 couplé au driver ULN2003.

le moteur pas a pas 28BYJ-48 est un petit moteur a cout très bas permettant de réaliser des fonctions de positionnement précis en rotation ou tourner a des vitesses très précises .

ses principals caracteristiques sont les suivantes:

Rated voltage :5VDC 
Number of Phase   4 
Speed Variation Ratio 1/64 
Stride Angle   5.625° /64 
Frequency  100Hz 
DC resistance       50Ω±7%(25°C)
In-traction Torque  >34.3mN.m(120Hz) 
Self-positioning Torque >34.3mN.m Friction torque       
Insulated electricity power   600VAC/1mA/1s 

premier Montage: basé sur composants du KIT ELEGOO starter KIT UNO R3, il va permetre de tester une fonction simple de rotation continue a raison d’un pas toutes les 50 millisecondes.

pour commencer , un programme qui n’utilise pas de bibliotheque . le principe est d’envoyer sur chaque fil de phase une sequence de signal hauts dans l’ordre du diagramme de fonctionnement en demi pas donné plus haut :

#define A        10   // variables définissant chaque broche digitale      
#define A_bar    12                   
#define B        11                  
#define B_bar    13                   
#define x        50  // delai de pause apres chaque cycle d'impulsion
 
void setup() {
  pinMode(A, OUTPUT);
  pinMode(A_bar, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(B_bar, OUTPUT);
}
 
void loop() {   
    digitalWrite(A, HIGH);
    digitalWrite(A_bar, LOW);
    digitalWrite(B, LOW);
    digitalWrite(B_bar, LOW);
    delay (x);
   
    digitalWrite(A, HIGH);
    digitalWrite(A_bar, LOW);
    digitalWrite(B, HIGH);
    digitalWrite(B_bar, LOW);
    delay (x);
   
    digitalWrite(A, LOW);
    digitalWrite(A_bar, LOW);
    digitalWrite(B, HIGH);
    digitalWrite(B_bar, LOW);
    delay (x);
   
    digitalWrite(A, LOW);
    digitalWrite(A_bar, HIGH);
    digitalWrite(B, HIGH);
    digitalWrite(B_bar, LOW);
    delay (x);
   
    digitalWrite(A, LOW);
    digitalWrite(A_bar, HIGH);
    digitalWrite(B, LOW);
    digitalWrite(B_bar, LOW);
    delay (x);
   
    digitalWrite(A, LOW);
    digitalWrite(A_bar, HIGH);
    digitalWrite(B, LOW);
    digitalWrite(B_bar, HIGH);
    delay (x);
   
    digitalWrite(A, LOW);
    digitalWrite(A_bar, LOW);
    digitalWrite(B, LOW);
   digitalWrite(B_bar, HIGH);
    delay (x);
   
   digitalWrite(A, HIGH);
    digitalWrite(A_bar, LOW);
    digitalWrite(B, LOW);
    digitalWrite(B_bar, HIGH);
    delay (x);
    }

ci dessous video youtube de la motorisation d’une monture équatoriale fait sur la base de ce principe mais en tournant en pas entiers.

deuxieme programme qui utilise la bibliotheque “stepper.h” . ici on va faire un tour dans un sens puis un tour dans l’autre sens

#include <Stepper.h> 
const int stepsPerRevolution = 2048; // nbre de pas du moteur
// definition des broche de connexion 
Stepper myStepper(stepsPerRevolution, 10, 12, 11, 13);
 
void setup() {
    // definition de la vitesse de rotation( 5 tr/mn)
    myStepper.setSpeed(5);
}
 
void loop() {
  // rotation sens horaire
  myStepper.step(stepsPerRevolution);
  delay(500); 
  // rotation sens antihoraire (signe moins devant la variable)
  myStepper.step(-stepsPerRevolution);
  delay(500);
}

CABLAGE SUIVANT: nous allons brancher un joystick ( KIT ELEGOO) sur l’entrée Analogique A0 et utiliser l’axe X du joystick pour commander la rotation dans un sens ou dans l’autre du moteur pas a pas . sur cette base on peut rajouter un deuxieme moteur pas a pas et raccorder la sortie Y du joystick sur la broche A1 pour commander ce deuxieme moteur avec le même joystick.

voici le programme qui va avec le montage: telecharger le programme dans l’arduino et manipuler le joystick de gauche a droite , vous verrez tourner le moteur dans le sens associé au mouvement du joystick. on ulise une fonction map() qui transforme la plage 0-1023 analogique en plage -100-100 qui permet d’obtenir le sens de rotation ( horaire si >0 et antihoraire si <0 ). 2 fonctions if sont incluse dans le programme pour créer un point mort entre les valeurs -10 et 10 ( moteur fixe quand joystick relaché).

#include <Stepper.h>
int stepsPerRevolution = 2048;
int joypin = 0; 
int val;
Stepper myStepper(stepsPerRevolution, 10, 12, 11, 13);
 
void setup() {
  myStepper.setSpeed(8);
}
 
void loop() {
  val = map(analogRead(joypin), 0, 1023, -100, 100);
  if (val<-10) {
    myStepper.step(val);
  }
  if (val>10) {
    myStepper.step(val);
  }