ARDUINO-Basiques

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

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

ARDUINO – Moniteur Série

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

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

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

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

ARDUINO – capteur HC-SR501

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

DATA SHEET DU CAPTEUR:

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

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

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

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

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

ARDUINO – SERVO

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

cablage 1: le plus basique

programme simple :

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

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

cablage 2 : ajout d’un potentiomètre

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

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

ARDUINO – 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 – commande de pas a pas NEMA

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

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

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

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

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

COMMANDE D’UN NEMA 17 avec un POLOLU A4988:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ARDUINO – 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

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 – CAPTEUR DHT11

le DHT11 est un capteur température -humidité idéal pour réaliser une petite station météo en complément d’autres capteurs . il n’a que 3 broches pour ses fonctions de type analogiques et en fait quand on regarde la datasheet , on découvre qu’il utilise un simili protocole série sur sa patte de données. protocole qui necessite une bibliotheque spécipique pour pouvoir exploiter les données qui arrivent . il existe plusieurs bibliotheque pour ce capteur, dans les exemples plus bas nous en utiliserons 2 differentes.

protocole de données

L’état par défaut de la broche DATA est Haut. Lorsque la communication entre MCU et DHT11 commence, MCU abaisse la broche DATA pendant au moins 18 ms. Ensuite, le MCU remonte la broche DATA a l’etat haut pendant 20 à 40us pour attendre la réponse de DHT11.

Une fois que le DHT11 détecte le signal de démarrage, il abaissera la broche DATA en tant que «Signal de réponse», qui durera 80us. Ensuite, DHT11 remonte la broche DATA pour 80us et se préparera à l’envoi de données. Pendant la transition de données, chaque bit de données commence par le niveau de basse tension 50us et se termine par un signal de niveau de tension élevé. La longueur du signal de niveau de tension élevée détermine si le bit est «0» ou «1». Le bit de données «0» a une longueur haute de 26-28us, Alors que le bit de données «1» a une longueur haute de 70 us

Programme avec bibliotheque et moniteur serie ( kit ELEGOO)

librairie DHT11 ELOGOO:

programme ARDUINO

#include <dht_nonblocking.h>
#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);
}

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 )   {
    		Serial.print( "T = " );
   	 	Serial.print( temperature, 1 );
   	 	Serial.print( " deg. C, H = " );
    		Serial.print( humidity, 1 );    
Serial.println( "%" );
 	 }
}

Programme avec bibliotheque et ecran LCD (bibliotheque du KIT ELEGOO)

#include <dht_nonblocking.h>
#include <LiquidCrystal.h>
#define DHT_SENSOR_TYPE DHT_TYPE_11
static const int DHT_SENSOR_PIN = 2;
DHT_nonblocking dht_sensor( DHT_SENSOR_PIN, DHT_SENSOR_TYPE );
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

void setup( ) {
  Serial.begin( 9600);
    lcd.begin(16, 2);
}

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 )   {
        lcd.setCursor(0,0);
        lcd.print( "Temp: " );
        lcd.print( temperature,1);
        lcd.setCursor(0,1);
        lcd.print("Humidity: ");              
        lcd.print( humidity, 1 );    
        lcd.print( "%" );
        delay(500);
   }
}

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 .

il faudra bien entendu utiliser une carte SD mais en prenant en compte quelques précautions et limitations:

  • les cartes doivent etre compatible du protocole SPI
  • 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 …

  • Mettre une pile ronde plate CR1220 dans le logement prévu a cet effet pour la sauvegarde jour/heure du RTC si coupure de courant sur l’ARDUINO.
  • 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:

puis le télécharger dans l’Arduino et ouvrir le moniteur série ou devrait apparaitre un écran de ce type:

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

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:

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

ouvrir l’IDE ARDUINO puis dans l’option FICHIER aller sur preferences:

dans la fenetre qui s’ouvre, dans la case du bas ” additional Board manager, saisir l’adresse url ci dessous puis valider:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_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 :

GND FTDI <=> GND ESP32 , VCC FTDI <=> 5V ESP32 , TX FTDI<=> UOR ESP32 , RX FTDI<=> UOT ESP32 ,

et 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 pendant le téléchargement

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.

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

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

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

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 :