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..
comme tout equipement a la pointe de la technologie, Arduino peut communiquer via bluetooth. il existe differents modules compatibles, ici nous allons voir l’utilisation du module HC-05. il est possible d’utiliser des modules HC-06 mais celui ci ne fonctionne qu’en mode esclave alors que le HC-05 peut etre utilisé en maitre et/ou en esclave , il est donc plus polyvalent . derniere possibilité comparable , l’utilisation d’un Module HM-10. ce module est compatible BT V4.0 et BT LE ce qui n’est pas le cas du HC-05 compatible uniquement BT V2.0
Le module Bluetooth HC-05 présente 6 broches :
VCC broche d’alimentation. Typiquement connectée à la broche 5V de l’Arduino.
GND masse. Typiquement connectée à la broche GND de l’Arduino
RX broche de réception. connecté à la broche de transmission (TX) de l’Arduino
TX broche de transmission. connecté à la broche de réception (RX) de l’Arduino
State retourne 1 lorsque le module est connecté
Key ou EN doit être alimentée pour entrer dans le mode de configuration et doit être déconnecté pour être en mode communication.
NOTA: dans les montage arduino , de façon a eviter de bloquer le moniteur serie de L’IDE arduino , au lieu d’utiliser les broches standard Tx et Rx de l’ARDUINO (broche D0 et D1), on va utiliser des borches compatibles du mode Tx et Rx , en general la broche D2 et la broche D3 et utiliser la bibliothèque « SoftwareSerial.h ».
SCHEMA DE CABLAGE POUR LE MODE CONFIGURATION
La configuration du module Bluetooth est utile pour modifier ses paramètres . pour passer le HC-05 en mode configuration , il faut connecter la broche KEY/EN au 3,3 V de l’arduino. et relier respectivement les broches GND et 5V du module a celles de l’arduino. puis ensuite le Tx du module au Rx de l’Uno (broche D2) et le RX du module au Tx arduino (broche D3) . Lorsque le module est en mode configuration, la LED s’allume deux secondes toutes les deux secondes.
la configuration du HC-05 va se faire au moyen de commandes AT . Ouvrez le moniteur série de l’Arduino et assurez vous que l’option de fin de ligne affiche « Nouvelle ligne » et que le baudrate est réglé à 9600. c’est le moniteur série qui va servir d’interface de configuration.
pour cela saisir le petit bout de programme suivant qui va permettre de saisir des commandes AT dans le moniteur serie et de visualiser le resultat en retour . le programme configure la vitesse de transmission. si vous rencontrez des problemes de connexion, verifier le cablage et la vitesse de communication.
#include <SoftwareSerial.h>
#define rxPin 2
#define txPin 3
String msg;
SoftwareSerial hc05(rxPin ,txPin);
void setup(){
pinMode(rxPin,INPUT);
pinMode(txPin,OUTPUT);
Serial.begin(9600);
Serial.println("ENTER AT Commands:");
hc05.begin(9600);
}
void loop(){
readSerialPort();
if(msg!="") hc05.println(msg);
if (hc05.available()>0){
Serial.write(hc05.read());
}
}
void readSerialPort(){
msg="";
while (Serial.available()) {
delay(10);
if (Serial.available() >0) {
char c = Serial.read(); //gets one byte from serial buffer
msg += c; //makes the string readString
}
}
}
Commandes de configuration
le module Bluetooth HC-05 permet de connaître ses paramètres enregistrés:
taper dans le moniteur série « AT+<command>?« , vous obtenez la valeur enregistré dans le module , par exemple avec » AT+PSWD? » vous aurez le code PIN du module. suivant les modules , le « ? » n’est pas nécessaire. sur certains module « AT+NAME? » ne retourne rien . mais la commande de parametrage du nom (voir ci dessous ) fonctionne.
Si vous tapez » AT+<command>=<Param> » , vous définissez la valeur du module . par exemple » AT+PWSD=1234 » pour fixer le code PIN en 1234.
Voici les commandes AT principales:
Pour tester la communication: tapez AT , le module doit répondre OK si tout fonctionne
Pour modifier le nom du module, tapez AT+NAME=<Param> . exemple: Pour changer le nom du module en « HC5V01 » tapez « AT+NAME=HC5V01«
Pour modifier le code PIN du module, AT+PSWD=<Param> .
pour modifier le role du module (esclave ou maître):AT+ROLE=<Param>
Pour modifier la vitesse de communication AT+UART=<Param1>,<Param2>,<Param3> avec Param1, 2 et 3 = paramètres de communication série (baud rate, bit d’arrêt et bit de parité)
dans le fichier ci dessous , detail des commandes AT du HC-05
ci dessous les paramètres d’une configuration esclave ( idem pour un HC-06)
AT retourne OK
AT+NAME=HC05-Esclave
AT+UART=9600,0,0
AT+ROLE=0
AT+ADDR pour obtenir l’adresse du module esclave
Configuration du module maître
ci dessous les paramètres d’une configuration maitre
AT retourne OK
AT+NAME=HC05-Maitre
AT+UART=9600,0,0
AT+ROLE=1
Vous devez enregistrer l’adresse du module esclave pour que le module maître puisse s’appairer: exemple « AT+BIND=98d3,32,21450e «
SCHEMA DE CABLAGE POUR LE MODE COMMUNICATION
pas de gros changement par rapport au mode configuration, on débranche juste le câble entre Key/En et le 3,3V.
EXEMPLE d’application: communication entre 2 ARDUINO UNO
pour cet exemple, il faudra 2 ARDUINO UNO avec chacun leur module HC-05 connectés a 2 PC differents par exemple ,l’un configuré en mode maitre et l’autre configuré en mode esclave. puis telecharger dans chacun les 2 programmes ci dessous et ensuite ouvrir le moniteur serie sur chacun des PC puis taper du texte sur le monituer serie du maitre et voir l’affichage sur l’esclave.
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
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 :
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…
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.
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.
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.
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.
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 4 pour les CNC shields UNO.
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:
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é.
si votre arduino uno dispose de broche libres pour y connecter MS1, MS2 et MS3, il devient ainsi possible d’integrer le pilotage du micro stepping dans le programme , cela permet par exemple d’inclure un facteur d’echelle sur la vitesse du PaP.
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 et ceci sans utiliser de librairie .
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.
si on avait cablé 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.:
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 .
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 :
#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é).
utilisation d’un 28BYJ-48 avec un driver POLOLU type A4988 ou DRV8825.
nous avons vu ICIl’utilisation classique avec un ULN2003, il est également possible de piloter un 28BYJ-48 avec un driver POLOLU. la différence se situe au niveau du nombre de fil .
Pas a pas BIPOLAIRE vs UNIPOLAIRE:
pour mémoire , il existe 2 types de moteurs pas a pas , les moteurs BIPOLAIRES (type NEMA) dont le schema electrique est le suivant:
et les moteurs UNIIPOLAIRES dont le schema electrique est le suivant:
le 28BYJ-48 est un moteur UNIPOLAIRE dont le schema exact est le suivant ( avec couleur de fils) :
ULN2003 vs A4988:
le driver ULN 2003 est concus pour piloter un pas a pas UNIPOLAIRE a 5 fils comme le 28BYJ-48, le POLOLU A4988 est lui conçu pour piloter un pas a pas bipolaire a 4 fils. pour piloter un moteur UNIPOLAIRE 5 fils avec un driver pour BIPOLAIRE 4 fils , il suffit donc d’enlever 1 fil , en l’occurrence le fil commun ROUGE . ce qui va donner le schema equivalent suivant:
MODIFICATION DU BROCHAGE:
le connecteur livré sur le cable du 28BYJ est utilisable sur les slots d’un POLOLU A4988 car l’ecartement des broches est le meme . par contre une fois le fil rouge enlevé , l’ordre des cables n’est pas le bon , en effet il faut realiser un schema de ce type :
voici l’ordre des broches sur le moteur reçu:
il va donc falloir enlever le fil ROUGE et réorganiser l’ordre des fils pour les rendres compatibles des connections d’un POLOLU. pour declipper les connecteur , il faut utiliser une pointe tres fine pour appuyer sur la languette de clip tout en tirant sur le cable:
le plus simple est de se fabriquer une petite lame spécifique ( ici a partir de tiges acier plates recuperées dans les balais d’essuie glace), elle sera utile pour tout un tas d’autres connecteurs a broches clippées.
une fois les broches réordonnées:
on peut maintenant , par exemple, facilement monter le moteur 28BYJ-48 sur un CNC shield
pour le fonctionnement et la programmation, elle est ensuite similaire a celle d’un NEMA 17 voir explications et exemples dans le lien ICI :
REGLAGE DES POLOLU:
attention, derniere etape avant d’utiliser sur un POLOLU A4988 ou DRV8825 , il faut calibrer la limitation de courant Vref , ici le 28BYJ ayant une tension de fonctionnement de 5 Volts et une résistance de phase de 50 Ohms ,soit un courant de fonctionnement résultant I= U/R = 5/50 = 0,1 Ampere , il faudra calculer le Vref équivalent en utilisant les formules données pour les POLOLU correspondants => voir le site POLOLU lien ci dessous:
I2C est un protocole de communication série multi-esclaves multi-maitres. on le trouve parfois sous le nom IIC ou TWI (Two Wire Interface) ou TWSI (Two Wire Serial Interface).
c’est un bus série synchrone bi-directionnel half-duplex.Les échanges ont lieu entre un seul maître et un (ou tous les) esclave(s), à l’initiative du maître (jamais de maître à maître ou d’esclave à esclave) mais rien n’empêche un composant de passer du statut de maître à esclave ou réciproquement.
La connexion est réalisée au moyen de deux lignes :
une ligne SDA (Serial Data ) : ligne de données bidirectionnelle,
une ligne SCL (Serial Clock ) : ligne d’horloge de synchronisation .
à ces 2 lignes , on rajoute une ligne de masse et une ligne d’alimentation Vdd qui tire les 2 lignes SDA et SCL au niveau Vdd au travers de resistance de Pul Up .
dernier point important , chaque composant du circuit a une adresse hexadécimale du type 0xYZ qui permet l’ échange entre maitre et esclave . le fonctionnement est asses similaire a celui de la distribution du courrier par la poste; l’ expéditeur ( le maitre) envoi un message a l’adresse du destinataire ( l’esclave) . le bus I2C c’est le facteur sur son itineraire de distribution, avec la particularité qu’a chaque fois il rentre a la poste pour aller chercher le courrier suivant et le distribuer a l’adresse suivante.
une des utilisation les plus basiques avec ARDUINO concerne les aspect IHM ( Interface Homme Machine) , a savoir la connexion de clavier et d’ecran ceci afin d’économiser des entrées /sorties Analogiques et Numériques sur l’ARDUINO. mais on trouve aussi des Joysticks I2C , des capteurs I2C et tout un tas d’elements compatibles avec ce protocole.
ci dessous un exemple de schéma pour un Interface de commande sur un montage ARDUINO:
le fonctionnement d’un ARDUINO en mode I2C nécessite des Librairies . dont basiquement la Librairie « Wire » qui assure le protocole de communication . a cette librairie , il faut en général ajouter d’autres librairies dédiées aux composants utilisés.
pour la librairie Wire , voici le lien vers le site ARDUINO pour les commandes de base:
pour le fonctionnement en I2C , chaque module ARDUINO possede des broches dédiées, (voir rubrique « generalités/Pinout ») , pour l’ARDUINO UNO il s’agit des broches A4 et A5:
passons maintenant a des cas pratiques , a titre de premier exemple , nous allons traiter le cas de l’afficheur LCD 16 x 2
AFFICHEUR LCD I2C 16×2:
l’utilisation d’un afficheur LCD I2C 16×2 nécessite une librairie spécifique. ici nous utiliserons la librairie « LiquidCrystal_I2C.h » qu’il vous faudra installer avant de téléverser le programme dans l’arduino uno . faire une recherche google pour la trouver .
deuxieme étape préliminaire , il vous faudra trouver l’adresse I2C de votre écran , pour cela , ouvrir l’IDE ARDUINO et charger le programme I2Cscanner ci dessous puis le téléverser et ouvrir le moniteur série . le programme scanne le bus I2C et affiche les adresse I2C connectées trouvées . utiliser le programme avec un seul composant sur le bus a la fois vous permet de trouver l’adresse I2C de celui ci.
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2); // initialise l'afficheur a l'adresse 0x27 et précise le nbre de caractères et de lignes
void setup() {
lcd.init(); // initialise l'afficheur LCD
lcd.backlight(); // allume le rétroéclairage de l'afficheur
}
void loop(){
lcd.setCursor(0,0); // curseur en colonne 0 ligne 0
lcd.print("apprendre avec");
lcd.setCursor(0,1); // curseur en colonne 0 ligne 1
lcd.print("E-TECHNO-TUTOS");
}
dans le cas d’utilisation d’un afficheur 20×4 , il suffit de remplacer la ligne en rouge par la commande suivante:
LiquidCrystal_I2C lcd(0x27,20,4);
UN CLAVIER MATRICIEL I2C:
voyons maintenant comment faire un clavier matriciel I2C à partir d’un simple clavier 4×4 et d’un Module d’extension PCF8574
le module PCF8574 a pour fonction de convertir les états ( haut/bas) d’une ligne de 8 signaux digitaux arrivant en parallèle en une information série d’une chaine de 8 bits . le module fonctionne egalement dans l’autre sens, si on lui envoie une chaine de 8 bits , il reparti les 8 bits en état de sortie haut ou bas sur les 8 lignes . c’est donc un convertisseur série/parallèle à double sens de conversion.
cette capacité de conversion va pouvoir être utilisée pour convertir l’état des touches clavier en un signal 8 bits qui sera converti en son caractère correspondant via une table de conversion adéquate .
par ailleurs , le module comporte des cavaliers A0-A1-A2 permettant de fixer l’adresse Hexa I2C du module: par exemple sur le module ci dessous , les 3 cavaliers sont positionnés sur la masse soit un niveau 0 pour A0-A1-A2, soit une adresse 8 bit de 0100000 ce qui fait 20 en hexadécimal , l’adresse du module sur le bus I2C sera donc 0x20 . avec les 3 cavaliers a gauche, l’adresse 8 bit serait 0100111 soit 0x27 en hexa. le module est donc configurable a hauteur de 8 adresses hexa differentes allant de 0x20 à 0x27 et on ne peut donc pas mettre plus de 8 modules de ce type sur un BUS I2C.
une fois l’adresse hexa fixée , le module PCF 8574 peut être connecté au clavier
voyons maintenant un petit programme pour utiliser cet ensemble avec un ecran I2C 16×2 ( il suffit de mettre l’ecran et le PCF8574 en serie sur le port I2C ):
le programme ci dessous affiche sur le LCD les touches appuyées.
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
ATTENTION:
le CNC shield peut egalement etre avantageusement utilisé avec d’autres microcontroleurs (raspberry PI par exemple) sans être pluggué sur le microcontroleur mais en carte additionnelle . dans ce cas il faudra veiller a avoir soit une broche spécifique qui active la fonction ENABLE (broche 8) sous le CNC shield soit fixer un cavalier de shunt sur les broches EN/NGD sous le bouton RESET en haut a gauche de la platine
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 : ici le ventilateur est tenu par une piece imprimée 3D bridée entre les 2 cartes
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).
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.
Exemple de réalisation:
a titre d’exemple de réalisation concrete, voici un telecommande radio NRF24 L01 a base de 2 cartes Joystick Funduino
l’emeteur et son recepteur en bas a droite
vue de dos avec sa batterie Lipo d’alimentation
vue avant avec le 3° joystick et l’arduino Nano qui controle l’ensemble.
