Catégorie : ARDUINO TUTOS

petit tuto sur le shiel boutons/joystick FUNDUINO , bein utile pour les application type commande de robot ou modèle reduit.

ce shield de 85 mm par 55 mm se monte directement sur un arduino UNO ou MEGA.

DESCRIPTION:

il comporte :

• un joystick avec 2 axes X/Y et une fonction bouton poussoir (appui vertical)
• 4 boutons poussoirs plastique designé A B C et D
• 2 micro boutons poussoirs désignés E et F
• 1 connecteur I2C ( rectangle orange en bas a droite )
• 1 connecteur pour module bluetooth HC06 ( rectangle bleu en haut a droite)
• 1 barrette de connexion pour écran LCD Nokia 5110 (rectangle vert)
• 1 slot 2×4 pour module radio nRF24L01

BROCHAGE:

le shield utilise les broche numeriques et analogiques ARDUINO suivant le tableau ci dessous :

EXEMPLE DE PROGRAMME

voyons un petit exemple simple d’utilisation, nous allons lire l’etat des entrées binaires E2 a E8 correspondant aux boutons A a J et la valeur des potentiometres de Joystick A0/A1 et afficher tout ça sur le moniteur série ( qu’il faudra ouvrir une fois le programme format txt copié dans l’IDE ARDUINO puis téléversé sur la carte).

void setup() {
  for (int i=2; i <= 8; i++)   {
      pinMode(i, INPUT_PULLUP);                   
  }
  Serial.begin(9600);
}

void loop() {
    for (int i=2; i <= 8; i++)   {
         Serial.print("E");
         Serial.print(i); 
         Serial.print(":");
         Serial.print(digitalRead(i));
         Serial.print("  ");                            
    }
    Serial.println(" ");
    Serial.print("A0: ");         
    Serial.println(analogRead(A0));
    Serial.print("A1: ");   
    Serial.println(analogRead(A1));
    delay(1000);
    Serial.println("NOUVELLE LECTURE");
}

petite vue du résultat sur moniteur série:

ce programme peut etre modifié pour de la telecommande radio par exemple en intégrant les valeurs lues dans des variables et en les envoyant a un recepteur radio via un module nRF24L01.

voyons l’utilisation d’un module type GPS NEO-6M pour récuperer les données GPS via un ARDUINO UNO

Le MODULE GPS NEO-6M:

on trouve ce petit module GPS sur AMAZONE , ALIEXPRESS , Ebay pour une fourchette de prix (2022) de 5 à 10 € piece. il en existe différentes version avec PCB rouge ou bleu et une antenne rectangulaire ou carrée.

ci dessous photo recto verso du module utilisé pour ce tuto.

une fois branché sur un arduino UNO via les broche serie Tx et Rx , il est capable de fournir une multitude de données de géolocalisation dont les principales sont:

• latitude et longitude
• altitude
• vitesse
• nombre de satellites vus
• date et heure UTC

EXEMPLE BASIQUE d’UTILISATION

premier exemple simple d’utilisation, nous allons lire les données reçues du GPS et les afficher dans le moniteur Serie.

le montage

on raccorde les broches Rx et Tx du module aux broches 3 et 4 de l’arduino UNO la broche GND du module au GND de l’UNO et la broche Vcc du module au 3,3V de l’UNO.

le programme

ouvrir le programme ci dessous dans l’IDE arduino et le televerser dans l’arduino.

#include <SoftwareSerial.h>
SoftwareSerial ss(3, 4);
void setup(){
  Serial.begin(9600);
  ss.begin(9600);
}

void loop(){
  while (ss.available() > 0){
    byte gpsData = ss.read();
    Serial.write(gpsData);
  }
}

ouvrir le moniteur serie et configurer a 9600 bauds puis se positionner pres d’une fenetre ou dehors puis attendre un petit moment que le module GPS établisse le contact avec les satellites ( la LED sous le modules est allumée fixe puis se met a clignoter une fois le signal GPS recu).

le moniteur serie affiche en temps réel les trame NMEA reçues du GPS.

ci dessous , un document PDF qui explique ce que sont les Trames NMEA reçues par un GPS.

AFFICHAGE DES DONNES SUR ECRAN I2C LCD

dans ce deuxieme exemple, nous allons voir comment afficher les données sur un ecran LCD I2C de 4 lignes de 20 caracteres. le montage sera alimenté par une pile 9V et sera ainsi autonome et utilisable dans une voiture par exemple pour tester ses fonctionnalités.

le montage

.

le programme

ouvrir le programme ci dessous dans l’IDE arduino et le televerser dans l’arduino.

le programme utilise la librairie “TinyGPSPlus.h” disponible ici :

https://github.com/mikalhart/TinyGPSPlus

#include <Arduino.h>
#include <SoftwareSerial.h>
#include <Wire.h>
#include <TinyGPSPlus.h>
#include <LiquidCrystal_I2C.h>

TinyGPSPlus GPS;
LiquidCrystal_I2C lcd(0x27, 20, 4); // LCD address to 0x20 (20 chars on 4 line)
SoftwareSerial ss(3, 4);            //serial connection to GPS (Rxpin,Txpin)

void setup() {
  ss.begin(9600);
  Serial.begin(9600);
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0); 
  lcd.print("GPS Neo 6M");
  lcd.setCursor(0, 1);
  lcd.print("attente signal");
}

void loop() {
  while (ss.available() > 0)   {
    if (GPS.encode(ss.read()))    {
      if (GPS.location.isUpdated() && GPS.altitude.isUpdated()) {
          lcd.clear();
          lcd.setCursor(0, 0);
          lcd.print("LT");
          lcd.setCursor(3, 0);
          lcd.print(GPS.location.lat(), 3);
          lcd.setCursor(11, 0);
          lcd.print("LG");
          lcd.setCursor(14, 0);
          lcd.print(GPS.location.lng(), 3);
          lcd.setCursor(0, 1);
          lcd.print("AL");
          lcd.setCursor(3, 1);
          lcd.print(GPS.altitude.meters());
          lcd.setCursor(11, 1);
          lcd.print("VI");
          lcd.setCursor(14, 1);
          lcd.print(GPS.speed.kmph(), 2);
          lcd.setCursor(7, 2);
          lcd.print("SA");
          lcd.setCursor(10, 2);
          lcd.print(GPS.satellites.value());
          lcd.setCursor(0, 3);
          lcd.print(GPS.date.day());
          lcd.setCursor(2, 3);
          lcd.print("/");
          lcd.setCursor(3, 3);
          lcd.print(GPS.date.month());
          lcd.setCursor(5, 3);
          lcd.print("/");
          lcd.setCursor(6, 3);
          lcd.print(GPS.date.year());
          lcd.setCursor(11, 3);
          lcd.print(GPS.time.hour());
          lcd.setCursor(13, 3);
          lcd.print(":");
          lcd.setCursor(14, 3);
          lcd.print(GPS.time.minute());
          lcd.setCursor(16, 3);
          lcd.print(":");
          lcd.setCursor(17, 3);
          lcd.print(GPS.time.second());
          delay(2000);
        }
      }
    }
  }

petite photo du montage en fonctionnement:

il est possible de compacter l’ensemble en remplaçant l’ecran LCD par un ecran I2C OLED 128×32 et en montant l’ensemble sur un shield (ici un shield SD pour enregistrer les données en temps réel sur une carte SD.

;

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

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…

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.

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);
}

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();
}

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.

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);                      
}

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);                          
}

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 .