site de tutoriels techniques
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:
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 :
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:
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.
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);
}
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 :
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
}
}
}
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:
dans le fichier ci dessous , detail des commandes AT du HC-05
ci dessous les paramètres d’une configuration esclave ( idem pour un HC-06)
ci dessous les paramètres d’une configuration maitre
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 .
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…
