ARDUINO: le module GPS

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.

;

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 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:

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é.

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.:

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

ARDUINO – PaP 28BYJ-48 / A4988

utilisation d’un 28BYJ-48 avec un driver POLOLU type A4988 ou DRV8825.

nous avons vu ICI l’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:

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

ARDUINO – Bus I2C

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.

pour plus d’info voir l’article Wikipedia:

https://fr.wikipedia.org/wiki/I2C

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:

https://www.arduino.cc/en/Reference/Wire

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.

une fois l’adresse I2C trouvée , ensuite téléverser le petit programme ci dessous et regarder ce qui s’affiche :

#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.

#include <Wire.h>
#include <Keypad_I2C.h>   // bibliotheque Keypad I2C
#include <Keypad.h>       // bibliotheque Keypad classique
#include <LiquidCrystal_I2C.h>    // bibliotheque LCD I2C
#define I2CADDR 0x20      // 0x20 adresse exa du clavier
LiquidCrystal_I2C lcd(0x27,16,2);  // 0x27 addresse LCD  16x2

const byte ROWS = 4; // 4 lignes
const byte COLS = 4; //4 colonnes
//definition des valeurs associees aux boutons du clavier
// char hexaKeys[ROWS][COLS] = {{'1','2','3','A'},{'4','5','6','B'},{'7','8','9','C'},{'*','0','#','D'}};
char hexaKeys[ROWS][COLS] = {{'A','B','C','D'},{'3','6','9','#'},{'2','5','8','0'},{'1','4','7','*'}};
byte rowPins[ROWS] = {7, 6, 5, 4};      //connection aux broche de ligne du clavier
byte colPins[COLS] = {3, 2, 1, 0};      // connection aux broche de colonne  du clavier

//initialize une instance de classe NewKeypad
Keypad_I2C customKeypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS, I2CADDR); 

void setup() {  
  Wire.begin( );                // démarre la communication I2C
  lcd.init();                   // initialise l'ecran LCD
  lcd.backlight();              // retro eclairage allumé
  customKeypad.begin( );        // demarre le clavier 
  lcd.clear();
  lcd.setCursor(0,0);           // curseur colonne 0 ligne 1 
  
  
void loop() {
  char customKey = customKeypad.getKey();
  while(customKey == NO_KEY)customKey=customKeypad.getKey();
  	lcd.clear();
  	lcd.setCursor(0,0);           // curseur colonne 0 ligne 1
  	lcd.print(customKey);   
  delay (100);    
}

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

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

ARDUINO: le shield Joystick FUNDUINO

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.

ARDUINO – SD RTC SHIELD

pour toute les applications de sauvergarde et utilisation de données , il existe des shields comportant un lecteur de carte SD et une Horloge Temps Reel ( Real Time Clock). on retrouve ce type d’application sous la denomination commune de DataLogger . Nous développerons ici le principe sur la base du SD-RTC shiel Deek-Robot mais adafruit propose le même module .

avant de commencer et pour ceux parlant Anglais , ci dessous en téléchargement la notice complete PDF de la version Adafuit:

Le Bus SPI:

premier point important a savoir, la partie SD du shield utilise le BUS SPI , Un bus SPI est un bus série composé de quatre fils : deux fils de données (MOSI et MISO), un fil d’horloge (SCK) et un fil d’adressage (/CS =”Chip Select”) par périphérique utilisant le bus SPI.

Les trois premiers fils sont communs à tous les périphériques d’un même bus SPI. Le quatrième fil (/CS) est unique par périphérique et permet au maître de choisir avec quel périphérique il souhaite communiquer. il y aura autant de fil /CS différents que de périphériques utilisant le BUS SPI. les modules Deek-Robot et Adafruit utilisent les broches D11 (MOSI)- D12(MISO)- D13 (SCK) de l’ARDUINO UNO pour le BUS SPI et normalement ( a verifier) la broche D10 pour le /CS ( voir paramétrage en rouge dans le premier exemple de programme ino proposé) , ces 4 broches sont donc indisponibles pour connecter des capteurs ou actionneurs.

si vous voulez utiliser en plus un shield Ethernet utilisant le Bus SPI , il faudra donc veiller a ce qu’il utilise une autre boche que la broche D10 pour activer la communication SPI.

La carte SD:

deuxieme point crucial , il faudra bien entendu utiliser une carte SD mais en prenant en compte quelques précautions et limitations. Toutes les cartes SD ne sont pas compatibles avec les cartes Arduino. Cela est dû au fait que les cartes Arduino communiquent avec la carte SD via un bus SPI. La communication en mode SPI n’est pas la méthode classique de communication avec une carte SD. Ce mode un peu spécial est un héritage des toutes premières versions de cartes SD. ci dessous , quelques conseils qui aideront:

  • les cartes doivent etre compatible du protocole SPI
  • Les cartes SDXC ne sont PAS compatibles. De même que les cartes d’une capacité supérieure à 32Go.
  • Utiliser une carte SD max 32 Go formatée en FAT16 ou FAT32 .
  • utiliser de preference des cartes de teille maxi 2 a 8 Go
  • Les noms de fichiers devront être au standard MSDOS ( 8 caractères sans espace ni extension de plus de 3 caractères)
  • Utiliser de préférence des fichiers au format .CSV (Comma Separated Value ) , format texte  tabulaire qui permet la récupération directe sur Excel.
  • Les vieilles cartes SD de 128 ou 256 Mo récupérées sur d’anciens apareils font très bien l’affaire pour les projets arduino:

Exemples : 128 Mo permet de stocker 2 560 000 enregistrements de 50 caractères

Si un enregistrement toutes les 5 minutes => capacité pour 9 000 jours soit plus de 20 ans d’enregistrement de données …

La Fonction RTC :

pour utiliser la fonction Horloge Temps Réels (Real Time Clock) du SD shield , il faut impérativement mettre une pile ronde plate CR1220 dans le logement prévu a cet effet , ceci pour la sauvegarde jour/heure du RTC en cas de coupure de courant sur l’ARDUINO.

deuxieme point important a savoir, l’horloge Temps Réel utilise le bus I2C pour la communication avec l’ARDUINO UNO , ARDUINO utilise les broche A4 et A5 pour le bus I2C , ces 2 broches ne sont donc plus disponibles comme broches Analogiques .

Mise en Œuvre, exemples:

  • Plugger l’ensemble sur l’arduino UNO en prenant garde à l’alignement des broches.
exemple de shield SD sur Arduino UNO

a titre d’exemple d’utilisation , nous allons connecteur un capteur DHT11 ( voir rubrique dédiée) et enregistrer les données du capteur sur la carte SD .

pour ce test , j’ai utilisé une carte SD de 2 Go . première opération, vérifier que la carte SD est reconnue par l’ARDUINO. pour cela , nous allons ouvrir l’exemple “cardinfo” de la librairie SD:

avant de télé-verser le programme dans l’ARDUINO , il faut modifier la ligne qui permet de spécifier la broche /CS et remplacer par la bonne valeur ( 10 dans le cas des cartes ADAFRUIT et DEEK ROBOT ):

une fois televersé dans l’arduino, ouvrir le moniteur serie , et si tout se passes bien un message du genre ci dessous devrait s’afficher .

passons maintenant a un premier cas concret avec le DHT11

charger le programme ino ci dessous ( format ZIP car format ino interdit en telechargement par mesure de securité) et televersez le dans l’arduino avec le DHT11 branché comme ci dessuspuis ouvrir le moniteur serie.

#include <SPI.h>
#include <SD.h>
#include <dht_nonblocking.h>
const int chipSelect = 10;    // broche /CS utilisée par le shield
#define DHT_SENSOR_TYPE DHT_TYPE_11
//#define DHT_SENSOR_TYPE DHT_TYPE_21
//#define DHT_SENSOR_TYPE DHT_TYPE_22
static const int DHT_SENSOR_PIN = 2;
DHT_nonblocking dht_sensor( DHT_SENSOR_PIN, DHT_SENSOR_TYPE );

void setup() {
  Serial.begin(9600);
  while (!Serial) { ; // wait for serial port to connect. Needed for native USB port only
  }
  Serial.print("Initializing SD card...");  
  if (!SD.begin(chipSelect)) {    // see if the card is present and can be initialized:
    Serial.println("Card failed, or not present");    
    while (1);    // don't do anything more:
  }
  Serial.println("card initialized.");
}

static bool measure_environment( float *temperature, float *humidity ) {
static unsigned long measurement_timestamp = millis( );
if( millis( ) - measurement_timestamp > 3000ul )   {
        if( dht_sensor.measure( temperature, humidity ) == true )       {
           measurement_timestamp = millis( );
           return( true );
        }
    }
   return( false );
}

void loop() { 
   float temperature;
   float humidity;
   if( measure_environment( &temperature, &humidity ) == true )   {
      String dataString = String(temperature) + ";" + String(humidity) ;  // make a string for assembling the data to log: 
      File dataFile = SD.open("DHT11.csv", FILE_WRITE);  
      if (dataFile) {     // if the file is available, write to it:
          dataFile.println(dataString);
          dataFile.close();
          // print to the serial port too:
          Serial.println(dataString);
          Serial.print( "T = " );
          Serial.print( temperature, 1 );
          Serial.print( " deg. C, H = " );
          Serial.print( humidity, 1 );    
          Serial.println( "%" );
      }
      // if the file isn't open, pop up an error:
      else {
          Serial.println("error opening datalog.txt");
      }    

   }  
}

dans le moniteur série on a quelque chose comme ça:

debrancher l’ARDUINO de l’alimentation et mettre la carte SD dans un PC pour voir ce qui a été enregistré dans le fichier.

le deuxieme exemple de mise en pratique va utiliser l’Horodatage de façon a avoir date et heure de chaque donnée. pour cela , en préliminaire , il va faloir installer la bibliothequeRTC disponible ici:

https://github.com/adafruit/RTClib

une fois fait , charger le programme ci dessous dans l’IDE arduino et televersez le dans l’ARDUINO.

#include <SPI.h>
#include <SD.h>
#include <RTClib.h>   // horodatage
#include <Wire.h> // Pour la communication I2C horodateur
#include <dht_nonblocking.h>
const int chipSelect = 10;   // broche CS pour le bus SPI
#define DHT_SENSOR_TYPE DHT_TYPE_11
//#define DHT_SENSOR_TYPE DHT_TYPE_21
//#define DHT_SENSOR_TYPE DHT_TYPE_22
static const int DHT_SENSOR_PIN = 2;
DHT_nonblocking dht_sensor( DHT_SENSOR_PIN, DHT_SENSOR_TYPE );
RTC_DS1307 RTC;

void setup() {
  Serial.begin(9600);
  Wire.begin();
  RTC.begin();
  // following line sets the RTC to the date & time this sketch was compiled
  // RTC.adjust(DateTime(__DATE__, __TIME__));
  
  while (!Serial) { ; // wait for serial port to connect. Needed for native USB port only
  }
  Serial.print("Initializing SD card...");  
  if (!SD.begin(chipSelect)) {    // see if the card is present and can be initialized:
    Serial.println("Card failed, or not present");    
    while (1);    // don't do anything more:
  }
  Serial.println("card initialized.");
}

static bool measure_environment( float *temperature, float *humidity ) {
static unsigned long measurement_timestamp = millis( );
if( millis( ) - measurement_timestamp > 3000ul )   {
        if( dht_sensor.measure( temperature, humidity ) == true )       {
           measurement_timestamp = millis( );
           return( true );
        }
    }
   return( false );
}

void loop() { 
   float temperature;
   float humidity;
   if( measure_environment( &temperature, &humidity ) == true )   {
      File dataFile = SD.open("DHT11.csv", FILE_WRITE);  
      if (dataFile) {     // if the file is available, write to it:
          DateTime now = RTC.now();
          uint16_t year1 = now.year();
          uint16_t month1 = now.month();
          uint16_t day1 = now.day();
          uint16_t hour1 = now.hour();
          uint16_t minute1 = now.minute();
          uint16_t second1 = now.second();
          String dataReg = String(year1) + ";" + String( month1) + ";" + String(day1) +";" + String(hour1) + ";" + String(minute1) + ";" + String(temperature) + ";" + String(humidity) ; 
          dataFile.println(dataReg);
          dataFile.close();
          // print to the serial port too:
          Serial.println(dataReg);
      }
      // if the file isn't open, pop up an error:
      else {
          Serial.println("error opening DHT11.csv");
      }  
   }  
}

l’affichage dans le moniteur serie donne ceci:

et si ensuite on ouvre le fichier de la carte SD avec un PC sous notepad et excel on a ceci.

cet exemple terminera ce tuto sur le principe d’utilisation d’un DATALOGGER shield.

ARDUINO- ETHERNET SHIELD

impossible de parler d’ARDUINO sans parler d’objets connectés. comme beaucoup de systemes programmables , ARDUINO peut communiquer avec les réseaux internet.

l’une des options est la connexion via câble Ethernet , pour cela il existe des SHIELD ETHERNET a plugger directement sur un ARDUINO UNO . la gamme de shield disponible evolue en permanence mais les fonctions principales restent les memes. en general , un connecteur RJ45 , et une carte SD pour stockage de données . petit reproche ,a mon sens il manque une horloge temps réels mais cela peut etre compensé via un composant RTC ajouté.

pas plus de discours sur le sujet , et pour développer , je vous propose d’aller sur la page en lein ci dessous pour voir une application concrete ( station meteo serveur )

Station météo Serveur ARDUINO

ESP32 cam

dans le domaine de la vidéo , impossible de zapper l’ESP32 cam qui est devenu la référence dans le monde du DIY .elle est a elle seule un arduino équipé d’une camera et du wifi et du Bluetooth en standard.

avec cet ensemble , outre les fonction vidéo et prise de vue, la camera possède de base un émetteur- récepteur wifi permettant de la connecter au réseau mais aussi des possibilités de reconnaissance faciale intégrées. elle comporte egalement un lecteur de carte SD. pour finir, une LED haute luminosité peut être commandée pour des prises de vues la nuit par exemple. Dans ce cas, il est possible de connecter une photorésistance sur la carte. En effet, elle intègre aussi quelques ports GPIO pour assembler différents capteurs et actionneurs. permettant l’enregistrement direct . cet ensemble ouvre la porte a la création de système de sécurité DIY ou a bien d’autres applications de prise de vues .

la camera est disponible en achat en ligne pour mois de 15 euros sur Amazone et est livré avec sa camera non montée .

le module accepte d’autres cameras compatible comme par exemple le module fisheye ci dessous que l’on trouve pour 10 euros , équipé d’un capteur CMOS UXGA (1632 x 1232) .

on peut acheter en option un kit antenne 2,4GHz externe pour augmenter la portée (a priori jusqu’a 200m suivant les essais trouvés ça et la sur internet).

ci dessous , une petite description sommaire de la carte et de ses connexion:

REMARQUE: si l’ESP32cam est utilisées avec une SD card insérée, les broches GPIO de gauche (GPIO 4-2-14-15-13-12) sont monopolisées par les fonctions “oranges” correspondant aux signaux DATA1-DATA2-CLK-CMD DATA3 et DATA4 de communication avec la carte SD. si aucune carte SD n’est utilisée , ces broches peuvent alors être utilisées comme entrées/sorties supplémentaires.

ALIMENTATION EXTERNE DE L’ESP32 CAM:

Une source externe 5 Vcc de 2 A minimum est nécessaire pour alimenter le module via les broches GND et 5V . c’est ensuite le régulateur interne qui va fournir les 3,3V de la tension de fonctionnement.

bien que la documentation précise qu’on peut alimenter via la broche 3,3V , il vaut mieux éviter d’alimenter en 3,3V sous peine de rencontrer des problèmes potentiels de stabilité ou de fonctionnement ( nombreux utilisateurs rapportant ce type de soucis).

NOTA: la broche Vcc (3,3V/5V orange sur schéma ci dessus) est une broche de sortie , il ne faut donc surtout pas y brancher d’alimentation externe. elle délivre une tension utilisable par des composants annexes a l’ESP32cam . attention , en général a la livraison , l’ESP32 cam est configuré pour délivrer du 3,3V sur la broche Vcc. pour obtenir du 5V il faut dé-souder la résistance de shunt en position 3V3 sur le circuit (rectangle bleu sur photo ci dessous) et la déplacer/souder sur la position 5V .

PROGRAMMATION DE L’ESP32 CAM:

la programmation de l’ESP32 CAM va nécessiter 2 opérations préparatoire préliminaires:

– installation d’un module complémentairement sur l’IDE ARDUINO.

– achat d’un module type FTDI232 : le module ESP32cam n’est en effet pas équipé de prise USB et il ne peut donc pas etre connecté directement a un PC pour la programmation.

IDE ARDUINO: installation du module ESP32 :

ouvrir l’IDE ARDUINO puis dans l’option FICHIER aller sur préférences:

dans la fenetre qui s’ouvre, dans la case du bas ” additional Board manager, saisir les adresses url ci dessous séparées par une virgule, puis valider:

https://dl.espressif.com/dl/package_esp32_index.json, http://arduino.esp8266.com/stable/package_esp8266com_index.json

on ouvre ensuite le menu “tools” puis “Board:” puis “Board Manager” et on cherche “ESP32

et dans la fenetre ESP32 , cliquer sur “instal”, une fenetre de telechargement s’ouvre pendant l’installation et une fois terminé l’option “INSTALLED” s’affiche.

TELECHARGEMENT avec le FTDI232:

branchement :

comme toute connexion de modules de communication série ensembles , bien veiller a croiser les broches Tx et Rx de chaque module : Tx de l’un vers Rx de l’autre et vice versa . ce qui donne pour toutes les broches utiles au mode programmation:

GND FTDI <=> GND ESP32

VCC FTDI <=> 5V ESP32

TX FTDI<=> UOR ESP32

RX FTDI<=> UOT ESP32

NOTA: pour le mode téléchargement avec l’IDE ARDUINO, on met un câble de shunt (FLASH MODE DE L’ESP) entre le IO0 ESP32 et le GND juste en dessous ( câble jaune sur image ci dessous). il faudra penser a enlever ce shunt pour les tests une fois le téléchargement terminé.

ouvrir l’IDE ARDUINO et Aller dans Outils/gestionnaire de cartes et selectionner “ESP32 Wrover Module”

puis modifier les parametres en dessous comme dans l’image :

Aller dans Fichier/Exemples/ESP32/Caméra et ouvrir le fichier CameraWebServer.ino et televerser le code .

NOTA: suivant le modèle d’ESP32cam acheté, il faudra peut être appuyer sur le bouton reset de l’ESP32 quand le telechargement commence ( quand s’affiche connecting avec des petits points et des underscore).

une fois le téléchargement effectué, retirer le shunt du FLASH MODE de l’ESP , et appuyer sur le bouton reset de la carte .

Ouvrir le moniteur série et repérer l’adresse IP de votre Caméra Serveur Web et les différents ports de communication

puis ouvrez le navigateur web de votre PC et taper l’adresse IP récupérée dans le moniteur série, vous voyez ce que vise la camera et vous pouvez ensuite “jouer” avec les paramètres vidéo dans le menu de gauche . a ce stade , vois pouvez débrancher le FTDI232 , ajouter une alim 5V sur les broches GND et 5V de l’ ESP32cam et le déconnecter de votre PC , il est maintenant autonome et connecté a votre réseau internet perso.

TELECHARGEMENT avec un ARDUINO UNO

si vous n’avez pas de FTDI232 ou si vous avez des problèmes avec un FTDI , l’autre solution pour le téléchargement c’est d’utiliser un ARDUINO UNO pour assurer le transfert USB .

Cablage de l’ensemble:

ce n’est pas précisé sur le schema , mais il faut bien entendu brancher l’arduino uno sur le port USB du PC via le cordon prévu a cet effet. petite précision, dans la partie téléchargement avec FTDI232 , sont fourni des paramètres de camera , ces paramètres sont susceptible de changer suivant la provenance des ESP32 cam et la date d’achat . par exemple sur le dernier lot acheté , dans les paramètres IDE voici l’ecran qui a permis de faire marcher le téléchargement,

ainsi que dans le programme arduino: la camera choisie : CAMERA_MODEL_WROVER_KIT.

si on compare a l’écran plus haut on constate des différences sensibles .tout ça pour dire que si vous avez des messages d’erreurs au téléchargement du pgme dans l’arduino , il faudra probablement faire des essais dans le menu “Outils/type de carte” avec différents types d’ESP32 et différents paramétrages , il faudra donc s’armer de courage pour les tests…:

quelques liens pour plus d’infos et de développements:

https://github.com/raphaelbs/esp32-cam-ai-thinker

https://randomnerdtutorials.com/projects-esp32-cam/

utilisation potentielles:

le module ESP32 cam peut par exemple être utilisé couplé a un détecteur IR HC-SR501 (voir rubrique dédiée) pour faire une camera automatique autonome a déclenchement par détection de mouvement . l’une des application potentielle étant par exemple une camera animalière autonome de ce type :

ou comme ICI en camera PAN/TILT de vidéo surveillance .