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

Bluetooth & HC-05

comme tout equipement a la pointe de la technologie, Arduino peut communiquer via bluetooth. il existe differents modules compatibles, ici nous allons voir l’utilisation du module HC-05. il est possible d’utiliser des modules HC-06 mais celui ci ne fonctionne qu’en mode esclave alors que le HC-05 peut etre utilisé en maitre et/ou en esclave , il est donc plus polyvalent . derniere possibilité comparable , l’utilisation d’un Module HM-10. ce module est compatible BT V4.0 et BT LE ce qui n’est pas le cas du HC-05 compatible uniquement BT V2.0

Le module Bluetooth HC-05 présente 6 broches :

  • VCC broche d’alimentation. Typiquement connectée à la broche 5V de l’Arduino.
  • GND masse. Typiquement connectée à la broche GND de l’Arduino
  • RX broche de réception. connecté à la broche de transmission (TX) de l’Arduino
  • TX broche de transmission. connecté à la broche de réception (RX) de l’Arduino
  • State retourne 1 lorsque le module est connecté
  • Key ou EN doit être alimentée pour entrer dans le mode de configuration et doit être déconnecté pour être en mode communication.

NOTA: dans les montage arduino , de façon a eviter de bloquer le moniteur serie de L’IDE arduino , au lieu d’utiliser les broches standard Tx et Rx de l’ARDUINO (broche D0 et D1), on va utiliser des borches compatibles du mode Tx et Rx , en general la broche D2 et la broche D3 et utiliser la bibliothèque “SoftwareSerial.h”.

SCHEMA DE CABLAGE POUR LE MODE CONFIGURATION

La configuration du module Bluetooth est utile pour modifier ses paramètres . pour passer le HC-05 en mode configuration , il faut connecter la broche KEY/EN au 3,3 V de l’arduino. et relier respectivement les broches GND et 5V du module a celles de l’arduino. puis ensuite le Tx du module au Rx de l’Uno (broche D2) et le RX du module au Tx arduino (broche D3) . Lorsque le module est en mode configuration, la LED s’allume deux secondes toutes les deux secondes.

la configuration du HC-05 va se faire au moyen de commandes AT . Ouvrez le moniteur série de l’Arduino et assurez vous que l’option de fin de ligne affiche « Nouvelle ligne » et que le baudrate est réglé à 9600. c’est le moniteur série qui va servir d’interface de configuration.

pour cela saisir le petit bout de programme suivant qui va permettre de saisir des commandes AT dans le moniteur serie et de visualiser le resultat en retour . le programme configure la vitesse de transmission. si vous rencontrez des problemes de connexion, verifier le cablage et la vitesse de communication.

#include <SoftwareSerial.h>
#define rxPin 2
#define txPin 3
String msg;
SoftwareSerial hc05(rxPin ,txPin);

void setup(){
  pinMode(rxPin,INPUT);
  pinMode(txPin,OUTPUT);  
  Serial.begin(9600);
  Serial.println("ENTER AT Commands:");
  hc05.begin(9600);
}

void loop(){
    readSerialPort();
    if(msg!="") hc05.println(msg);    
    if (hc05.available()>0){
      Serial.write(hc05.read());
    }
}

void readSerialPort(){
  msg="";
 while (Serial.available()) {
   delay(10);  
   if (Serial.available() >0) {
     char c = Serial.read();  //gets one byte from serial buffer
     msg += c; //makes the string readString
   }
 }
}

Commandes de configuration

le module Bluetooth HC-05 permet de connaître ses paramètres enregistrés:

taper dans le moniteur série “AT+<command>?“, vous obtenez la valeur enregistré dans le module , par exemple avec ” AT+PSWD? ” vous aurez le code PIN du module. suivant les modules , le “?” n’est pas nécessaire. sur certains module “AT+NAME?” ne retourne rien . mais la commande de parametrage du nom (voir ci dessous ) fonctionne.

Si vous tapez ” AT+<command>=<Param>” , vous définissez la valeur du module . par exemple ” AT+PWSD=1234 ” pour fixer le code PIN en 1234.

Voici les commandes AT principales:

  • Pour tester la communication: tapez AT , le module doit répondre OK si tout fonctionne
  • Pour modifier le nom du module, tapez AT+NAME=<Param> . exemple: Pour changer le nom du module en “HC5V01” tapez “AT+NAME=HC5V01
  • Pour modifier le code PIN du module, AT+PSWD=<Param> .
  • pour modifier le role du module (esclave ou maître):AT+ROLE=<Param>
  • Pour modifier la vitesse de communication AT+UART=<Param1>,<Param2>,<Param3> avec Param1, 2 et 3 = paramètres de communication série (baud rate, bit d’arrêt et bit de parité) 

dans le fichier ci dessous , detail des commandes AT du HC-05

Configuration du module en mode esclave

ci dessous les paramètres d’une configuration esclave ( idem pour un HC-06)

  • AT retourne OK
  • AT+NAME=HC05-Esclave
  • AT+UART=9600,0,0
  • AT+ROLE=0
  • AT+ADDR pour obtenir l’adresse du module esclave

Configuration du module maître

ci dessous les paramètres d’une configuration maitre

  • AT retourne OK
  • AT+NAME=HC05-Maitre
  • AT+UART=9600,0,0
  • AT+ROLE=1
  • Vous devez enregistrer l’adresse du module esclave pour que le module maître puisse s’appairer: exemple “AT+BIND=98d3,32,21450e “

SCHEMA DE CABLAGE POUR LE MODE COMMUNICATION

pas de gros changement par rapport au mode configuration, on débranche juste le câble entre Key/En et le 3,3V.

EXEMPLE d’application: communication entre 2 ARDUINO UNO

pour cet exemple, il faudra 2 ARDUINO UNO avec chacun leur module HC-05 connectés a 2 PC differents par exemple ,l’un configuré en mode maitre et l’autre configuré en mode esclave. puis telecharger dans chacun les 2 programmes ci dessous et ensuite ouvrir le moniteur serie sur chacun des PC puis taper du texte sur le monituer serie du maitre et voir l’affichage sur l’esclave.

Programme du maitre

#include <SoftwareSerial.h>
SoftwareSerial ArduinoSlave(2,3);
String answer;
String msg;

void setup(){
  Serial.begin(9600);
  Serial.println("ENTER Commands:");
  ArduinoSlave.begin(9600);                
}

void loop(){
   readSerialPort();  
   while (ArduinoSlave.available()) {
   delay(10);  
   if (ArduinoSlave.available() >0) {
     char c = ArduinoSlave.read();  //gets one byte from serial buffer
     answer += c; //makes the string readString
   }
 }
  if(msg!=""){
    Serial.print("Master sent : ");
    Serial.println(msg);
    ArduinoSlave.print(msg);
    msg="";
  }
  if(answer!=""){
    Serial.print("Slave recieved : ");
    Serial.println(answer);
    answer="";
  }
}

void readSerialPort(){
 while (Serial.available()) {
   delay(10);  
   if (Serial.available() >0) {
     char c = Serial.read();  //gets one byte from serial buffer
     msg += c; //makes the string readString
   }
 }
 Serial.flush();

Programme de l’esclave

#include <SoftwareSerial.h>
SoftwareSerial ArduinoMaster(2,3);
String msg;

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

void loop(){
  readSerialPort();  
  if(msg!=""){
    Serial.print("Master sent : " );
    Serial.println(msg);
    ArduinoMaster.print(msg);
    msg=""; 
  }
}

void readSerialPort(){
 while (ArduinoMaster.available()) {
   delay(10); 
   if (ArduinoMaster.available() >0) {
     char c = ArduinoMaster.read();  //gets one byte from serial buffer
     msg += c; //makes the string readString
   }
 }
 ArduinoMaster.flush();
}

pour aller plus loin voir la rubrique Bluetooth et smartphone, qui développe la comm entre un smartphone et ARDUINO via l’appli REMOTE XY .

ARDUINO transmission radio

dans le cadre de communications sans fil , une alternative au wifi est la comm radio.

nous allons voir ici l’utilisation d’émetteur et récepteur 433MHz avec dans un premier temps la communication dans un seul sens , de l’émetteur vers le récepteur

les deux éléments utilisé sont :

un émetteur 433 MHz

un récepteur 433MHz

pour utiliser ces 2 éléments , il faut bien évidemment un arduino Uno branché a chacun d’entre eux , voici les schémas de branchement respectifs:

circuit d’émission

circuit de réception

EXEMPLE :

pour montrer un exemple concret de transmission, nous allons tout simplement envoyer la valeur lue d’un potentiomètre via l’Arduino émetteur et la recevoir et l’afficher dans le moniteur série sur l’Arduino de réception.

branchement du potentiomètre :

en plus de l’émetteur , nous allons ajouter un potentiomètre sur l’entrée analogique 0 de l’arduino:

programme coté émetteur:

programme coté récepteur:

les deux programmes utilisent la bibliotheque RCswitch

https://www.arduino.cc/reference/en/libraries/rc-switch/

charger le programme d’émission sur l’Arduino coté émetteur , débrancher l’Arduino du PC et ajouter une pile d’alimentation . brancher l’Arduino récepteur au port USB via le câble classique et charger le programme de réception .

démarrer le moniteur série et manipulez le potentiomètre coté Arduino émetteur, les valeurs sont lues puis envoyées par le circuit d’émission, reçues par ondes radio coté réception et affichées sur le moniteur série .

petite vidéo YouTube qui montre le processus complet:

voila rien de plus compliqué , on pourrait remplacer l’affichage par le pilotage d’un servo RC , voir par exemple ici l’utilisation d’un servo :

https://www.e-techno-tutos.com/2020/12/05/arduino-servo-libre/

il est possible de remplacer l’émetteur et le récepteur par deux circuits HC-12 qui ont la capacité de communication dans les 2 sens (modules bidirectionnels émission et réception) et ainsi bâtir des solutions de communication via onde radio…

REMOTE XY – smartphone IHM

difficile de parler ARDUINO sans aborder la liaison ARDUINO SMARTPHONE. la difficulté de la manip etant la partie soft du smartphone pour communiquer avec ARDUINO.

nous allons voir ici un utilitaire de programmation via interface Visuelle : REMOTE XY

coté microcontroleur ,le soft est compatible avec Arduino, ESP8266, ESP32
coté smatphone , il est compatible avec Android et iOS,

cet outil est un soft composé de 2 modules, une application payante ( 8 €) a installer sur son smartphone via google store pour android ou play store pour IOS , et un editeur graphique en ligne sur le site .

https://remotexy.com/en/

coté protocole de communication , il supporte:

  • Bluetooth via module HC-05 , HC-06 , HM-10 ou module integré au microcontroleur
  • Wi-Fi via ESP8266 ou module WIFI intégré ( ESP32 par exemple)
  • Ethernet via Ethernet Shield W5100
  • USB sur android uniquement et via cable OTG
  • internet a distance .

le principe est simple, une fois l’interface conçue via l’éditeur en ligne , le programme génère le code source ARDUINO qu’il ne reste plus qu’a télécharger dans l’ARDUINO via l’IDE ARDUINO . une fois le programme remote XY demarré sur le smartphone et la connexion bluetooth établie avec l’arduino , c’est le programme arduino qui va envoyer a l’application remote XY sur le smartphone les paramètres de configuration graphique et le smartphone va ensuite afficher l’écran graphique de communication avec l’arduino .

EXEMPLE : 2 bouttons d’allumage led

1°) création dans l’éditeur:

on commence par saisir les parametres globaux de la communication : type de microcontroleur (ARDUINO UNO), type de communication (bluetooth avec HC05) , et IDE ARDUINO et pour finir le type de comm ( software serial) , les broches arduino concernées ( RX -2 et TX 3 ) et la vitesse de communication série sur Tx et Rx ( 9600 bauds).

ensuite on choisi les widgets de controle (ici de simples boutons) , pour cela cliquer a gauche dans le menu des contrôles sur le “bouton” puis venir le déposer sur l’écran dans la fenêtre centrale

changer ensuite la désignation du bouton dans la partie droite des paramètres , ici on le nome A ( case caption) et on voit le nom de la variable dans la case au dessus (button_1) qui sera utilisée dans le programme arduino. on peut changer le nom de la variable si on le souhaite . on peut également changer la couleur du bouton , la forme (draw type) et le style de bordure ) puis on fini par affecter la broche de l’arduino au bouton ici la broche 4 (snap to pin)

de la même façon on créé un deuxième bouton B , rectangulaire , de couleur verte pour varier les plaisirs et affecté a la broche arduino 5.

on peut pour finir positionner les boutons ou on veut sur l’écran et modifier leur taille via les poignées de modif ( petit carrés dans les coins du cadre de bouton)

l’interface graphique est maintenant prête , on va generer le code arduino , pour cela , cliquer en haut a droite dans “get source code”

une nouvelle fenêtre s’affiche, avec le code arduino , et les instructions pour la suite :

  1. téléchargement du code
  2. installation de la librairie “Remote XY”
  3. compilation et téléchargement sur l’arduino
  4. connexion du module bluetooth a l’arduino et raccord des éléments a commander (2 led sur les broches D4 et D5 )
  5. installation de l’appli sur smartphone si pas déjà fait
  6. connexion a l’arduino et test

AUTRES EXEMPLE

d’autres exemples sont disponible directement sur le site XY REMOTE

https://remotexy.com/en/examples/