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…

le moniteurs serie , est un outil permettant de simuler un affichage avec votre montage arduino. il utilise le port USB (port serie) pour communiquer avec votre module ARDUINO.

il permet de visualiser des résultats, des variables , mais aussi d’envoyer des caracteres ou des commandes a votre arduino.

c’est une IHM (Interface Homme Machine) visuelle simple qui permet donc de dialoguer avec votre programme via votre ecran de PC sans avoir a brancher aucun module d’affichage a votre Arduino.

c’est le premier outil permettant de tester les fonctionnalités d’un programme avant d’ajouter un ecran et/ou un clavier connecté a l’arduino qui feront la fonction IHM définitive.

nous allons voir un petit câblage simple a base de potentiometre pour découvrir l’utilisation du moniteur série. pour cela un potentiomètre est branché entre 0V et 5V et son point variable sur la broche Analogique A0 .

avant de lancer le programme , il faudra paramétrer la valeur de transmission (bauds) dans l’écran du moniteur série , menu du bas fenetre avec la petite flèche permettant de choisir le niveau de Baud ( nbre de symboles par secondes transmis).

Le Montage

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.

la valeur s’affiche et défile dans la fenêtre du moniteur série .

nous allons voir ici comment faire une mesure de distance avec un capteur Ultrason.

nous examinerons 2 types de capteur , le capteur classique disponible dans tous les kit arduino, a savoir le HC-SR04 mais aussi un capteur un peu plus evolué , le capteur A02YY , qui est un capteur étanche a commande UART.

Capteur ULTRASON le principe

les capteur a ultrason sont des circuits électroniques comportant un Émetteur et un récepteur a Ultrasons.

l’émetteur envoie une impulsion sonore qui est réfléchie par les obstacles situés en face. le récepteur capte l’écho reçu en retour. on mesure le temps mis entre le départ du son et le retour, et connaissant la vitesse de propagation du son dans le milieu ou s’effectue la mesure on peut en déduire la distance.

Distance = (temps x vitesse du son) / 2

Le capteur HC-SR04

principe de commande:

le circuit du capteur est alimenté en 5V via ses broches Gnd et Vcc , il comporte une broche Trig (Trigger) permettant de commander l’envoi du signal , et une broche Echo permettant de détecter le signal du retour d’echo.

il suffit donc d’alimenter le capteur via le Gnd et le 5V de l’arduino et de brancher les broches Trig et Echo sur des sorties de l’arduino.

histoire de changer de l’éternel affichage dans le moniteur série , nous allons ici directement utiliser un petit écran Oled I2C 128×64 pixels pour afficher le résultat. le principe du Bus I2C est expliqué ici : Bus I2C

pour la gestion en I2C , nous utiliserons la librairie « Wire.h » et pour le petit écran Oled I2C nous utiliserons les librairies « Adafruit_SSD1306.h » et « Adafruit_GFX.h » . ces librairies seront a installer en préalable sur votre IDE arduino.

pour le pilotage globale , nous utiliserons un Arduino Nano ce qui permettra un ensemble très compact .

Cablage Arduino:

• la broche Trig du HC-SR04 est raccordée a la broche D7 de l’arduino nano
• la broche Echo du HC-SR04 est raccordée a la broche D6 de l’arduino nano
• la broche SCL de l’ecran OLED est raccordée a la broche A5 de l’arduino nano
• la broche SDA de l’ecran OLED est raccordée a la broche A4 de l’arduino nano
• les broches GND et Vcc des 2 composants sont a raccorder aux broches GND et 5V du Nano
• l’arduino Nano sera alimenté par le cable USB de telechargement du programme . pour un montage autonome , voir derniere photo en bas de page sur le cas du deuxieme capteur .

Programme:

#include <Wire.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_GFX.h>
#define OLED_ADDR   0x3C    // OLED display TWI address
Adafruit_SSD1306 display(-1);
#define ECHpin 6
#define TRIGpin 7
unsigned long duree ;
const float SOUND_SPEED = 343.00 / 1000;
float distance = 0.00;

void setup() {
 pinMode(ECHpin, INPUT);
 pinMode(TRIGpin, OUTPUT);
 digitalWrite(TRIGpin, LOW);
 Wire.begin( );                // démarre la communication I2C
 display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR); // initialize l'ecran OLED
 display.clearDisplay();     //efface l'affichage OLED
 display.display(); 
}

void loop() {
 digitalWrite(TRIGpin, HIGH);
 delayMicroseconds(10);
 digitalWrite(TRIGpin, LOW);
 // mesure du temps aller retour de l'impulsion US
 duree = pulseIn(ECHpin, HIGH);
 distance = duree  * SOUND_SPEED / 2.0 ;
 display.clearDisplay();
 display.display();  
 display.setTextColor(WHITE);
 display.setTextSize(1);
 display.setCursor(35,1);    
 display.print("DISTANCE" );
 display.display(); // actually display all of the above 
 display.setTextSize(2);
 display.setCursor(10,17);    
 display.print(distance);
 display.setCursor(85,17);    
 display.print(" mm");
 display.display();
 delay(5000);
}

Résultat:

dans la photo ci dessous , le montage posé horizontalement sur une table, et qui mesure la hauteur au plafond en mm .

Nota: il faudra étalonner le montage en mesurant la cote réelle et modifier la vitesse du son en conséquence . il faut savoir que la vitesse du son dans l’air est fonction de la température et de la densité de l’air a l’endroit de la mesure. pour faire un appareil de mesure précis , il faudrait aussi mesurer la température et ajouter une table de correction …

.

Le capteur A02YY :

les differents Modeles :

dans la famille des capteurs A02YY , il existe 5 types dont voici un tableau récapitulatif des caractéristiques principales:

dans ce tutos , nous allons voir le modèle A02YYTW qui a l’avantage d’être commandable de la même façon que le capteur HC-SR04 et donc plus économe en énergie que par exemple le modèle UW qui lui est en émission réception constante et ou il faut récupérer les données a la volée.

brochage du câble du capteur

Principe de fonctionnement

ici la petite particularité par rapport au capteur HC-SR04, c’est que la carte electronique du A0221AT calcule directement la distance et l’envoie sous forme de chaine de 4 caractères sur le bus série avec un protocole de type Tx/Rx . dans le programme Arduino, il va donc falloir implémenter un protocole serie avec la bibliotheque « SoftwareSerial.h » et un protocole Myserial pour le bus serie du capteur , afin de lire les bits reçus du capteur et calculer la distance correspondante .

ci dessous un extrait de la data sheet du capteur qui explique cela pour les modules UART contrôlés.

Câblage Arduino:

il est similaire a celui du HC-RS04 plus haut avec :

• la broche Rx (cable jaune) du capteur (equivalent au Trig du HC-SR04) est raccordée a la broche D7 de l’arduino nano
• la broche Tx (cable blanc) du capteur (equivalent au Echo du HC-SR04) est raccordée a la broche D7 de l’arduino nano
• la broche SCL de l’écran OLED est raccordée a la broche A5 de l’arduino nano
• la broche SDA de l’écran OLED est raccordée a la broche A4 de l’arduino nano
• les broches GND et Vcc des 2 composants sont a raccorder aux broches GND et 5V du Nano

Programme:

#include <SoftwareSerial.h>
#include <Wire.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_GFX.h>
#define OLED_ADDR   0x3C    // OLED display TWI address
Adafruit_SSD1306 display(-1);
#define RXpin 6
#define TXpin 7
SoftwareSerial mySerial(RXpin,TXpin); // RX, TX connected to US sensor
unsigned char data[4]={};
float distance = 0.00;

void setup() {
 pinMode(RXpin, INPUT);
 pinMode(TXpin, OUTPUT);
 Wire.begin( );                // démarre la communication I2C
 Serial.begin(9600);
 mySerial.begin(9600); 
 display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR); // initialize
 display.clearDisplay();     //and clear display
 display.display(); 
}

void loop() {
 mySerial.flush();
 delay(30);
 digitalWrite(TXpin,HIGH);
 delay(30);
 digitalWrite(TXpin,LOW);
 delay(30);
  digitalWrite(TXpin,HIGH);
 delay(60);
     for(int i=0;i<4;i++)  {
       data[i]=mySerial.read();
     }
 distance = (data[1]*256)+data[2];
 display.clearDisplay();
 display.display();  
 display.setTextColor(WHITE);
 display.setTextSize(1);
 display.setCursor(35,1);    
 display.print("DISTANCE" );
 display.display(); // actually display all of the above 
 display.setTextSize(2);
 display.setCursor(10,17);    
 display.print(distance);
 display.setCursor(85,17);    
 display.print(" mm");
 display.display();
 delay(5000);
}

voici ci dessous, une photo d’une adaptation du montage et du programme ci dessus pour calculer le volume d’eau residuel dans une cuve rectangulaire de camping car.

a partir de la distance entre le dessus de cuve et la surface de l’eau, on calcule le volume d’air supérieur de la cuve que l’on retranche au volume global de la cuve .

pour l’alimentation electrique , sont utilisées 2 pile Li-ion 18650 de 3,7 V en série connectées a la broche GND et Vin du Nano. ce qui rends le dispositif autonome.

il est parfaitement imaginable de faire de même dans un puits de section cylindrique .

NOTA: le capteur fonctionne sur une plage de distance de 3cm a 4,5 mètres .

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

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

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

SCHÉMA DE BRANCHEMENT:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

voyons quelques exemples d’applications

EXEMPLE 1: compte tour

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

le programme :

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

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

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

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

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

.

EXEMPLE 2: compte tour avec afficheur LCD

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

le programme :

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

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

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

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

DATA SHEET DU CAPTEUR:

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

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

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

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

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