Ressources ARDUINO

Ressources ARDUINO

Nombre de visites :
970

Liens utiles

http://electroniqueamateur.blogspot.ca/2013/06/lecture-de-fichiers-mp3-avec-arduino-et.html
 
Conversion HEXA => NUMERIQUE :
http://www.binaryhexconverter.com/hex-to-decimal-converter
Anti-rebond pour contact :
http://playground.arduino.cc/Code/Debounce

 
ULTRASONS :
http://www.instructables.com/id/Arduino-Using-shift-registers-with-ultrasonic-sens/
http://www.pale.org/?p=5755

http://arduino.sundh.com/tag/ultrasonic/
http://arduinobasics.blogspot.fr/2012/11/arduinobasics-hc-sr04-ultrasonic-sensor.html

http://www.tautvidas.com/blog/2012/08/distance-sensing-with-ultrasonic-sensor-and-arduino/

http://fritzing.org/projects/arduino-ultrasonic-distance-measurement

http://www.codingcolor.com/microcontrollers/an-arduino-pro-mini-ultra-sonic-beeping-thingamajiggy/
http://electronut.in/using-ultrasonic-distance-sensor-module-hc-sr04-with-an-arduino/
https://bitbucket.org/teckel12/arduino-new-ping/wiki/Home
http://robotfightleague.wordpress.com/2012/07/31/firsttest/
http://www.pihomeserver.fr/2013/08/10/raspberry-pi-home-server-arduino-uno-detecter-les-aliens-avec-un-hc-sr04/
http://arduinobasics.blogspot.fr/2012/11/arduinobasics-hc-sr04-ultrasonic-sensor.html
http://itechnofrance.wordpress.com/2013/03/12/utilisation-du-module-ultrason-hc-sr04-avec-larduino/comment-page-1/
http://www.buildcircuit.com/obstacle-sensor-using-arduino-and-hcsr04/

 
EFFET HALL (et autres capteurs) :
http://mchobby.be/wiki/index.php?title=Senseur_%C3%A0_Effet_Hall
http://www.cortoc.com/p/arduino.html
http://projet-arduino.blogspot.fr/2013/05/tuto-5-capteur-effet-de-hall.html
 
http://www.learningaboutelectronics.com/Articles/Hall-effect-sensor-circuit.php
 
http://www.bristolwatch.com/hall_effect/
 
http://www.icstation.com/product_info.php?products_id=1557#.VDVyoCV1PFY
 
http://www.hobbytronics.co.uk/arduino-tutorial11-hall-effect
 
http://www.learningaboutelectronics.com/Articles/Hall-effect-sensor-circuit.php
 
http://forum.arduino.cc/index.php/topic,234626.0.html
 
http://www.hobbytronics.co.uk/sensors

 
SERVO-MOTEURS
 
https://ardwinner.jimdo.com/arduino/v-les-servomoteurs/2-contr%C3%B4ler-un-servomoteur-via-un-potentiom%C3%A8tre-knob/
 
https://openclassrooms.com/fr/courses/2778161-programmez-vos-premiers-montages-avec-arduino/3285287-donnez-du-mouvement-a-vos-montages-avec-un-servo-moteur-et-la-fonction-switch
 
https://www.locoduino.org/spip.php?article62

 
INFRAROUGE
 
http://www.circuitbasics.com/arduino-ir-remote-receiver-tutorial/
 
https://www.electroschematics.com/arduino-control-leds-ir-remote/
https://learn.sparkfun.com/tutorials/ir-control-kit-hookup-guide/all?print=1

 
ATTINY
http://bateaux.trucs.free.fr/arduino_attiny.html
http://idehack.com/blog/utiliser-lide-arduino-pour-programmer-un-attiny85-digispark/
 
https://www.iot-experiments.com/attiny85-development-board/
http://digistump.com/wiki/digispark/tutorials/connecting (programmation DIGISPARK)
https://diyelec.fr/2018/03/13-comment-programmer-un-attiny-85
 

Arduino StepperLab3 Motor Library

Home / Lab / Interfaces Advanced
 
The StepperLab3 stepper motor library is made for our SensorAktor Shield but it works also with other motor driver IC’s like the popular L293.

 
Compared to the standard Arduino stepper library we added some features for more convenient handling and getting most out of your stepper. The library functions are attached to an interrupt process what allows an accurate speed control and a non blocking behavior. If you tell the motor to go to a certain position this is done in the background while you can do other things in your code.

 
A ramp function allows a acceleration in a given number of steps to the speed which was set before. When you want to move masses with an inertia, a matched acceleration improves the dynamic behavior of your setup.

 
The Half step mode doubles the given step number of your motor. This improves not only the positional accuracy but leads also to a more smooth rotation. Because in the half step mode both motor coils can be activated together the library tries to provide a constant motor current.

 
The power control sets the motor current by using the PWM function of pin 9 and 10. This allows to adapt the motor current to different motor speeds or reduce the current when the motor is stopped. Be sure that the motor current does not exceed the limit of your driver IC. The L293 provides 600mA. In our shield we have a 500mA polyfuse to protect the driver IC.

 
Keep in mind that the library is using ATMEGAs timer1 and the corresponding interrupt. Some other libraries or arduino functions might work not correct.

 


 

Methods

attach(motor1_1,motor1_2,motor2_1,motor2_2);


 

void setPower(int power );// set motor torque 0..1023


 

void setSpeed(int speed );// set motor step speed [steps per second x 10]


 

void setRampSteps(int steps );//number of steps within the motor is accelerated to  setSpeed, 0= ramp  off


 

void setFullStep();//fullstep mode, normal operation


 

void setHalfStep();//double number of motor steps


 

void absoluteSteps(int steps );//move  to absolute target position


 

void relativeSteps(int steps );//move relative to last target


 

void rotate(int r ); // continous rotation, 1=fwd, -1=rev, 0=stop


 

int getSteps();// read current absolute position


 

int stepReady();// !=0  when stepper reached target position


 

Download the Library
Updated 1/12

StepperLab3


 

Examples
Ramp Test Example


 

/* stepper library StepperLab3

/*

* ramp example

*

* KHM Lab3 2010

* Kunsthochschule fuer Medien Koeln

* Academy of Media Arts Cologne

* http://interface.khm.de

*/

 

// import stepper library

#include "StepperLab3.h" // create instance for stepper

StepperLab3 myStepper;

int state=1;

int statea=0;

int cnt10ms;

int cnt2;

int ledGreen= 5;

int motor1_1=8;

int motor1_2= 13;

int motor2_1= 11;

int motor2_2= 12;

 

void setup(){

Serial.begin(115200);

Serial.println(" stepperLab3 library test");

pinMode(ledGreen,OUTPUT); // LED pin myStepper.attach(motor1_1,motor1_2,motor2_1,motor2_2);

myStepper.setPower(900);

myStepper.setSpeed(500);

myStepper.setFullStep();

}

 

// this block is executed in a loop after setup is called one time

void loop(){

delay(10);

cnt10ms++;

cnt2++;

 

if ( state != statea) { // print state

Serial.print("state:");

Serial.print(state);

Serial.println("");

}

statea=state;

 

// myStepper.debugger();

 

switch (state) {

case 1:

state = 300;

myStepper.setRampSteps(15);

break;

 

case 300: // start new position

myStepper.setPower(900); // power = 900 run

myStepper.setSpeed(1000); // speed = 1000* 100ms = 100 steps/second myStepper.absoluteSteps(100);

state=301;

break;

 

case 301: // wait unil position is reached

if (myStepper.stepReady() == 1) {

myStepper.setPower(500); // power = 500 idle

state=302;

}

break;

 

case 302: // start new position

myStepper.setPower(900); // power = 900 run

myStepper.absoluteSteps(0);

state=303;

break;

 

case 303: // wait unil position is reached

if (myStepper.stepReady() == 1) {

myStepper.setPower(500); // power = 500 idle

state=400;

cnt2=0;

}

break;

 

case 400: // 2 sec pause

if (cnt2 > 200) {

cnt2=0;

state=300;

}

break;

}

 

if (cnt10ms % 50==0) { // blink led 500 ms digitalWrite(ledGreen,!digitalRead(ledGreen));

}

}

//*********************************************************************



 

Serial Command Positon Example  Control of a stepper motor with terminal commands

 
Driver Schematic
Contact
Martin Nawrath KHM 11/2010, nawrath@khm.de
 
 

Capteur ULTRASONS

Première utilisation du capteur à ultrasons HC-SR04
Hi!
Ça fait un bon moment que j’ai acheté le capteur HC-SR04 sur une site d’enchère bien connu. Pour moins de 3€, si je me souviens bien. Peut-être que ça fait un an. Peut-être même deux. Dans tous les cas, ça fait trop longtemps qu’il traine dans mes cartons ou sur mon bureau. Il était temps de le sortir et de l’utiliser !
 
Tout d’abord, une petite présentation. Le capteur HC-SR04, c’est quoi ? C’est une copie du capteur SRF04 conçu par Devantech. Un des deux petit cylindre sur la platine envoie des ultrasons, l’autre cylindre récupère ceux qui reviennent suite à la collision avec un objet. En fonction du temps que l’onde aura mise pour revenir, nous pourrons savoir la distance qu’elle a parcourue. Vous pouvez retrouver des explications théoriques intéressantes sur les capteurs ultrasons sur un site dédié au NXT.
 
Avant de commencer à jouer avec, j’ai évidemment cherché quelques sources. Et il y en a vraiment beaucoup. Le faible prix de ce capteur a attiré une grande foule de bidouilleurs et de chipoteurs en tout genre. J’ai lu pas mal de trucs un peu partout mais j’ai principalement utilisé ces deux liens : Le site autonomouS Multi Application Robot Team (S.M.A.R.T), le site iTechnoFrance.
 
Le montage :
 
Le montage est tout simple. Il faut alimenter le module (5V et GND), il faut une broche digitale pour envoyer le signal de départ (Trigger : 12) et une broche digitale pour lire le signal de retour (Echo : 11).
J’ai pour ma part utilisé une Arduino Mega 2560 mais le montage est le même.
Le code :
 
Je n’ai pas réinventé la roue. J’ai clairement repris le code du site iTechnoFrance.


/* Utilisation du capteur ultrasons HC-SR04
10 aout 2013 */

int trig = 12; //broche du Trigger
int echo = 11; //broche de l'Echo
long lecture_echo;
long cm;

void setup()
{
pinMode(trig, OUTPUT); //On défini le trigger comme étant une sortie
digitalWrite(trig, LOW);
pinMode(echo, INPUT); //L'echo est une entrée
Serial.begin(9600);
}

void loop()
{
digitalWrite(trig, HIGH); //On met le trigger à "1"
delayMicroseconds(10); //pendant 10µs
digitalWrite(trig, LOW); //puis on le remet à "0"
lecture_echo = pulseIn(echo, HIGH); //On lit le nombre de pulsations renvoyé
cm = lecture_echo / 58; //On divise par 58 pour avoir la distance en cm
Serial.print("Distance en cm : "); //On affiche la distance
Serial.println(cm);
delay(100);
}

Les essais :
Je n’ai actuellement pas eu de valeur au delà d’un bon mètre. Je suis loin des 3 mètres annoncés… Peut-être que ma main n’a pas assez grande pour attirer son attention. Il faut que j’essaye vers un mur ou vers d’autres objets. Sinon, ça réagit assez vite et ça semble assez précis pour jouer avec. Je sens qu’on va l’équiper bientôt sur un de nos robot. [Edit: J’ai testé en pointé le capteur vers une surface plane assez grande (un mur, une vitre, …) et j’ai pu aller jusqu’à 450cm ! Par contre, ça marche moins bien quand j’essaye de me mettre entre le mur et le capteur… Il renvoie 0 ou ~450 et me repère mal. (Peut-être qu’il faut rester immobile pendant un certain temps ?)
Je n’ai pas encore fini mes expérimentations mais c’est déjà très intéressant !

 
Liens utiles avec programmes :

 
http://tiptopboards.free.fr/arduino_forum/viewtopic.php?f=2&t=54

 
http://tiptopboards.free.fr/arduino_forum/viewtopic.php?f=2&t=8

 
http://itechnofrance.wordpress.com/2013/03/12/utilisation-du-module-ultrason-hc-sr04-avec-larduino/

Bibliothèques additonnelles

Pour moteurs pas à pas : 
 
StepperLab3_1_12.zip
Lien vers le site de Lab III

 
Pour écrans LCD : 
 
NewliquidCrystal_1.3.4.zip
Pour clavier 12 ou 16 touches : 
keypad.zip

 
Ressources pour codes SONY infra-rouges : 
 
RESSOURCES_pour_CODES_IR_SONY.zip
 

Arduino: reset logiciel et matériel

Il est courant de vouloir redémarrer une carte Arduino depuis le script, sans devoir appuyer sur le bouton.
 
Il y a trois manières de redémarrer la carte Arduino :
Méthode brute
Cette méthode permet le redémarrage logiciel mais ne remet pas à zéro les registres. Donc les états des pins (HIGH, LOW…) sont conservés et les shields externes ne sont pas redémarrés.

void (*softReset) (void) = 0;

Il vous suffit d’appeler la fonction softReset à l'endroit du script où cela est nécessaire.

softReset() ;

Le programme recommence juste depuis le début.
Exemple d'utilisation ICI.

 
Méthode watchdog
Le bootloader a une fonction watchdog : quand le programme semble planter, le watchdog redémarre la carte.
 
Cette méthode est toutefois dangereuse car si vous avez une boucle qui dure un certain temps dans votre programme (par exemple pour attendre un paquet par le port série) la carte Arduino redémarrera en boucle et il sera très difficile de télécharger un nouveau programme.
C’est pourquoi je n’en parlerai pas ici.

 
Méthode matérielle
Il y a un port « reset » sur la carte Arduino qui peut être utilisé de la même manière que le bouton.
Vous pouvez brancher tout simplement un port « digital » au port « reset », ou mettre un bouton entre les deux.
Partie code (pour l’exemple le port 12 est utilisé) :

pinMode(12, OUTPUT);

Attention: la carte redémarre quand on définit le pinMode, ne le placez pas au setup!
Cette méthode reset vraiment l’intégralité du circuit, c’est la plus efficace.
 

RESET par programme

 
 
If you want to RESET Arduino from the beginning without manually pressing the RESET button, there are a few ways. Here are two ways, using minimal wiring / circuitry. 
 
Step 1: Using 1 Wire Connected to the RESET Pin
If you want to RESET Arduino from the beginning without manually pressing the RESET button, there are a few ways. Here are two ways, using minimal wiring / circuitry. 
 
Step 1: Using 1 Wire Connected to the RESET Pin
Electronically, using only 1 wire connecting an OUTPUT pin (12 in this example) to the RESET pin. (see the circuit)

In this example :
  • pin 13, connected to the internal LED pin 13 is blinking ;
  • pin 12 gets connected to the RESET pin by one wire.
Typically, this would be a problem because when the application starts up, all pins get pulled LOW. This would therefore disable Arduino from every running. BUT, the trick is : in setup() function, the FIRST thing that happens is we write HIGH to the pin 12, which is called our reset pin (digitalWrite(resetPin, HIGH), thereby pulling the Arduino RESET pin HIGH. 

int led = 13;//pin 13 as OUTPUT LED pin

int resetPin = 12;

// the setup routine runs once when you press reset:

void setup() {  

  digitalWrite(resetPin, HIGH);

  delay(200);

  // initialize the digital pin as an output.

  pinMode(led, OUTPUT);    

  pinMode(resetPin, OUTPUT);     

  Serial.begin(9600);//initialize Serial Port

  Serial.println("reset");//print reset to know the program has been reset and 

  //the setup function happened

  delay(200);

}

 

// the loop routine runs over and over again forever:

void loop() {

  delay(10);

  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)

  Serial.println("on");

  delay(1000);               // wait for a second

  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW

  Serial.println("off");

  delay(1000);               // wait for a second

  Serial.println("resetting");

  delay(10);

  digitalWrite(resetPin, LOW);

  Serial.println("this never happens");

  //this never happens because Arduino resets

 

}

Step 2: Using Just Software
In this example, you do not need any extra wiring. We initialize the reset function, then call reset.


void(* resetFunc) (void) = 0;//declare reset function at address 0
...
resetFunc(); //call reset

// the setup routine runs once when you press reset:

void setup() {                

  // initialize the digital pin as an output.

  pinMode(led, OUTPUT);     

  Serial.begin(9600);//initialize the serial port

}

void(* resetFunc) (void) = 0; //declare reset function @ address 0

 

 

// the loop routine runs over and over again forever:

void loop() {

  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)

  Serial.println("on");

  delay(1000);               // wait for a second

 

  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW

  Serial.println("off");

  delay(1000);               // wait for a second

  Serial.println("resetting");

  resetFunc();  //call reset

  

  delay(100);

  Serial.println("never happens");

}
 

 

RESET script ARDUINO

 

Comment faire un Reset d'Arduino par logiciel - 3 options

Dominique Meurisse (MCHobby) vendredi 28 juin 2013 ArduinoTutoriel
Il est parfois utile qu'un Arduino reboot tout seul sans avoir physiquement besoin de quelqu'un pour pousser sur le bouton Reset.

Il y a plusieurs façon d'atteindre ce but.

Option 1 - Reset de type logiciel

Cette solution (pas très "propre") consiste à déplacer le curseur d'exécution d'Arduino au début du programme à l'aide d'une instruction de saut (jump) en assembleur.

C'est une solution relativement incomplète parce qu'elle ne réinitialise pas le matériel connecté sur votre Arduino. Cela signifie que la configuration matérielle par défaut ne sera restaurée.

Voici la fonction pour faire ce reset logiciel.

 

// Redémarre le programme depuis le début mais ne

// réinitialiser pas les périphériques et les registres

void software_Reset()

{

asm volatile (" jmp 0");

}



 

Option 2 - Watchdog Arduino

Le Watchdog se traduit littéralement par "Chien de garde". Le but d'un chien de garde sur un matériel technique est de désactiver un processus s'il met trop de temps à répondre.
 
En gros, si votre programme Arduino prends trop de temps d'exécution alors le chien de garde (Watchdog) entrera en action et fera un "reset" de votre Arduino.

Je pense qu'il s'agit là d'une approche assez propre... le but du watchdog étant justement de faire le Reset en cas de problème.

Pour utiliser le watchdog, vous aurez besoin d'inclure le fichier avr/wdt.h et d'appeler ensuite la fonction  wdt_enable().

La fonction wdt_enable accepte le temps à attendre avant de lancer le Reset automatique de la carte s'il n'y a pas d'autre appel au watchdog.

Vous pouvez choisir entre plusieurs valeurs prédéfinies :


15mS    WDTO_15MS
30mS    WDTO_30MS
60mS    WDTO_60MS
120mS   WDTO_120MS
250mS   WDTO_250MS
500mS   WDTO_500MS
1S      WDTO_1S
2S      WDTO_2S
4S      WDTO_4S
8S      WDTO_8S


Pour forcer le reset de la carte, il suffit alors d'implémenter une courte boucle, le système reboot lorsque le temps choisi  expire (timeout).

L'exemple suivant utilise la plus petite valeur pour le timeout. Il suffit d'appeler la fonction software_Reboot pour rebooter la carte.

#include <avr/wdt.h>

void software_Reboot()

{

wdt_enable(WDTO_15MS);

while(1) { }

}

 

Option 3 - Reset matériel

Si vous utilisez déjà le Watchdog à d'autres fins alors vous pouvez encore faire un Reset matériel.
Il faut raccorder une résistance de 1K entre la broche « reset » et une broche digitale (ex: la pin 12).
Ensuite, il suffit d'utiliser le code suivant:

 

// Cette fonction simule la pression du bouton Reset 

void pushReset() 

int pin=12;  // active la broche en sortie (OUTPUT) 

pinMode(pin, OUTPUT); // Déactive le reset forçant la sortie au niveau bas digitalWrite(Pin, LOW);

 

HC-05 commandes AT​

[ Arduino Annexe G ] Utiliser un module bluetooth HC-05 avec Arduino
Posté par Eskimon le 7 octobre 2014, 1:00
Un fil USB pour communiquer c’est contraignant ! On est limité en distance et on ne peut pas mettre en boîte notre carte, une vraie laisse ! Heureusement, ce ne sont pas les solutions sans fil qui manquent ! Je vous propose dans cette annexe du tutoriel Arduino de découvrir, utiliser et paramétrer un module bluetooth qui coûte une poignée d’euros : le HC-05.
Sommaire
  • Le bluetooth et le module HC-05
  • Communication entre HC-05 et Arduino
  • Aller plus loin, la configuration AT

 
Le bluetooth et le module HC-05
Afin de bien débuter, voyons d’abord à quoi ressemble le bluetooth et découvrons de quoi est composé le nouveau module que nous allons utiliser.
Qu’est ce que le bluetooth ?
Le bluetooth est un protocole de communication sans fil. Il a vu le jour à la fin des années 1990 et n’a vraiment percé que dans les années 2000. Il a subi de nombreuses révisions et évolutions pour atteindre aujourd’hui la version 4.1 depuis la fin 2013.

À l’origine, la société Ericsson cherchait à développer un moyen d’utiliser une voie série sans passer par un fil. Petit à petit, ses utilisations se sont étendues pour atteindre ce que l’on connais aujourd’hui, un moyen de connecter sans fil de nombreux appareils, allant d’une Arduino et sa voie série à un ordinateur, ou pour utiliser un casque audio ou encore une manette de jeu sur une console de salon.
Rentrons un peu dans le détail. Ce protocole est un cousin du Wi-Fi. En effet, ils respectent tous deux une même spécification IEEE et utilisent la même gamme de fréquences : 2.4 GHz (tout comme les téléphones portables et le zigbee par exemple). C’est une communication bidirectionnelle, deux modules peuvent communiquer ensemble en même temps. Le comportement utilisé est « maître/esclave ». Un esclave pourra parler avec un seul maître, mais un maître pourra dialoguer avec plusieurs esclaves.

Pour son utilisation, elle se passe en plusieurs étapes :
  1. Le maître se met en mode « reconnaissable »
  2. L’esclave trouve le maître et demande à s’y connecter
  3. Le maître accepte la connexion
  4. Les périphériques sont alors appairés (ou associés)
  5. La communication peut commencer
Ensuite, selon le type de composant que vous utilisez (une oreillette bluetooth, une manette de jeu-vidéo etc) la communication pourra se faire selon un protocole ou un autre. Dans notre cas cela consistera simplement en une liaison série. Au final, nous aurons donc le même fonctionnement qu’une liaison série habituelle (partie 3 du tuto Arduino) mais toute la partie « filaire » de la communication sera englobée dans des trames bluetooth gérées par le module. C’est totalement transparent pour nous (ou presque). Faisons donc un peu plus connaissance avec « HC-05 », le petit module bluetooth si pratique.
Présentation du module bluetooth HC-05
Comme expliqué plus tôt, le module utilisé se nomme HC-05 et est trouvable assez facilement pour quelques euros (via des sites d’import de Chine). Il est aussi gros que le pouce et est en fait un montage d’un module bluetooth sur un petit PCB. Cela permet de s’affranchir de certaines contraintes comme la soudure du module (qui est très délicate), la conversion 5V -> 3.3V, la régulation de l’alimentation (3.3V de nouveau) ou encore l’ajout de LEDs de signal. Tout cela est déjà intégré !

Alors que trouvons nous sur ce petit module ?

Tout d’abord, un ensemble de broches. VCC et GND pour l’alimentation (5V), Rx/Tx pour la communication. On y voit aussi une broche « Key » qui servira à envoyer des commandes de configuration au module (nous y reviendrons plus tard). La dernière broche nommée « Led » permet de brancher une LED pour obtenir un signal sur l’état du module.
Le module bluetooth HC-05
 
 
Brancher le module à l’Arduino
Voyons comment brancher tout ça. Tout d’abord, l’alimentation. C’est assez habituel, le VCC sera relié au 5V de l’Arduino et le GND à la masse. Ensuite, viennent les broches de transmission de données, Rx et Tx. Vous pourrez au choix les connecter aux broches de liaison série de l’Arduino (0 et 1) pour utiliser la voie série native, ou alors les brancher sur n’importe quelle autre pin afin de garder la voie série disponible pour du debug avec l’ordinateur (ce que je conseille). Nous reviendrons sur ce point. Il ne reste alors plus que les broches Key et Led. Led sert à connecter une LED de statut, vous pouvez la laisser déconnectée cela n’influencera pas le comportement du module. Key sert à utiliser le mode « commande » du module. Avec cette dernière vous pourrez reconfigurer la voie série (vitesse, parité etc…) et d’autres options liées au bluetooth (nom du module, mot de passe d’appairage, mode esclave/maître…). Cette broche est à connecter à n’importe quelle sortie numérique de l’Arduino.
Communication entre HC-05 et Arduino
Maintenant que le module est connecté, il est temps de le mettre en œuvre avec notre Arduino ! Pour garder les choses simples, nous allons simplement faire une connexion qui permet de renvoyer tout sur la voie série de l’ordinateur. Tout le long de ce tutoriel, seul le mode « esclave » sera utilisé mais le mode « maître » n’est pas beaucoup plus compliqué à atteindre.
Une question de voie série
Comme il a été dit et répété tout au long de la présentation, le module fonctionne via une voie série. Sur une Arduino Uno nous pouvons en trouver seulement une que nous allons garder pour faire du debugging avec l’ordinateur le temps de mettre en œuvre le module. Il y a donc un problème, comment allons nous faire pour communiquer avec le module si la voie série est déjà prise ?

La réponse est assez simple, nous allons émuler une voie série ! Ainsi, nous allons pouvoir utiliser deux broches numériques classiques pour créer une voie série par dessus. C’est une méthode assez habituelle de contournement, c’est équivalent à trouver une solution logicielle à un problème matériel.

Pour mettre en œuvre cela il y a deux écoles : Coder la nouvelle voie série soi-même ou utiliser une librairie existante. Si vous avez du temps, la première solution est réellement intéressante et formatrice. Pour ma part, le temps est une denrée ce faisant rare, je vais donc utiliser une bibliothèque existante qui a été codée par des professionnels et testée par des milliers de personnes à travers le monde : SoftwareSerial.
 
Utiliser la bibliothèque
Pour mettre en œuvre cette bibliothèque c’est assez simple. Il va tout d’abord falloir l’inclure dans vos projet. Au choix, soit en cliquant sur « Library/Import/SoftwareSerial » dans l’IDE Arduino (inclus de base) ou alors en ajoutant la ligne suivante en haut de votre programme :

1 #include <SoftwareSerial.h>

Une fois que la bibliothèque est là, il nous faudra l’utiliser. Cette bibliothèque nous donne l’accès à un objet nommé…SoftwareSerial (quelle coïncidence ). On peut donc créer une instance de cette objet en écrivant :

1 SoftwareSerial mavoieserie(Rx, Tx);

Rx et Tx seront les numéros des broches sur lesquelles sont connectées les broches d’émission/réception de votre module bluetooth. Par exemple j’ai pour ma part la broche Rx du module branchée sur la pin 10 de l’Arduino et la broche Tx reliée a 11. J’ai donc dans mon programme :
 

1 SoftwareSerial mavoieserie(10, 11);

Une fois cela fait, tout est prêt ! En effet, cette bibliothèque offre les mêmes fonctions que la voie série habituelle, la seule différence sera qu’au lieu d’utiliser Serial on utilisera mavoieserie, comme on peut le voir dans le listing ci-dessous :

1 mavoiserie.begin(speed);// démarre la voie série à la vitesse speed

2 mavoiserie.available(); // retourne le nombre de caractère à lire

3 mavoieserie.read();     // retourne le prochain caractère reçu

4 mavoiserie.write(val);  // envoie le char "val" sur la voie série

Notre module fonctionnant par défaut en 9600 bauds, nous allons pouvoir le préparer en écrivant :

1 #include <SoftwareSerial.h>

2

3 SoftwareSerial mavoieserie(10, 11);

4

5 void setup() { mavoiserie.begin(9600); }

Puis afin de tester tout cela, nous allons faire un petit code qui se contentera de faire un « echo » entre la voie série liée à l’ordinateur et celle liée au module bluetooth. Ainsi, chaque fois qu’un caractère/texte sera reçu sur la voie série de l’un, il sera renvoyé sur la voie série de l’autre. Notre Arduino servira alors de relais/adaptateur entre l’USB de l’ordinateur et le module bluetooth . Ce petit programme vous donne alors tout ce qu’il faut savoir pour faire vos premières applications avec . Juste une chose : branchez la broche « Key » à la masse pour que le module soit en mode « communication » et non pas en mode commande.

#include <SoftwareSerial.h>

 

SoftwareSerial mavoieserie(11, 10); // (RX, TX) (pin Rx BT, pin Tx BT)

 

void setup()

{

// Ouvre la voie série avec l'ordinateur

Serial.begin(9600);

 

// Ouvre la voie série avec le module BT

 

mavoieserie.begin(9600);

 

}

 

void loop() // run over and over

{ if (mavoieserie.available())

{

Serial.write(mavoieserie.read());

}

if (Serial.available())

{

mavoieserie.write(Serial.read());

}

}

Aller plus loin, la configuration (AT)
Si vous voulez pouvoir utiliser plus de fonctionnalités avec votre module, il va falloir modifier ses paramètres internes. Pour pouvoir être configuré, le module utilise un jeu de commandes plus ou moins standards que l’on appelle « commande AT » (ATtention) ou Commande Hayes du nom de leur inventeur. Pour les utiliser, il faudra que le module soit placé dans un mode particulier, le mode « commande ». Dans ce mode, toutes les informations envoyées au module seront interprétées pour faire de la configuration, rien ne sera envoyé en bluetooth à un autre appareil.
Les commandes AT portent plutôt bien leur nom. En effet, tous les ordres de configuration commencent par les caractères « AT+ » suivis de l’ordre en question puis un retour à la ligne via les caractères « rn ». Voyons cela plus en détail.
Passer en « mode commande »
Pour que le module décide que ce qu’il reçoit doit être traité comme un ordre de configuration et non comme un bout de texte à transmettre, il faudra le placer en mode « commande ». Dans ce mode, plus aucun texte ne sera transmis.

Afin d’établir cette communication, il existe deux méthodes.

La première consiste à démarrer le module avec sa broche « Key » à l’état HAUT (reliée au 5V). La LED présente sur le module devrait alors clignoter rapidement, signalant que le module est prêt à recevoir des ordres AT. Dans cette configuration, tous les messages envoyés seront interprétés comme des commandes et le seul moyen d’en sortir sera de redémarrer le module (en supprimant son alimentation). Attention, dans ce mode la connexion s’effectue à une vitesse de 38400 bauds ! N’oubliez pas de le prendre en compte dans votre programme. Je déconseille cette première méthode qui est finalement assez contraignante.
Une deuxième méthode, plus souple, sera d’utiliser la broche « Key » dans notre programme. Il faut donc dans un premiers temps déclarer cette dernière en sortie et la mettre à l’état bas par défaut. Elle sera connectée à la pin 12 pour ma part. Dans cette situation, la vitesse restera à 9600 bauds.

const int key = 12;

void setup()

{

pinMode(key, OUTPUT);

pinMode(key, LOW);

}

Maintenant, chaque fois que vous souhaiterez passer dans le mode « commande » vous devrez mettre cette broche à l’état haut et la maintenir dans cet état tant que vous envoyez des commandes.
Envoyer des commandes
Comme je l’écrivais plus tôt, chaque commande envoyée doit commencer par « AT+… » et finir par un retour à la ligne « rn ». Il existe plusieurs commandes que l’on trouve en général dans les documents fournis par le constructeur. Vous pourrez trouver ce jeu de commande en faisant une recherche du type « HC-05 AT commandes » dans votre moteur de recherche préféré.

Que voyons nous ici ? À partir de la page 3, on peut voir une série de commandes et leur retour. Essayons tout cela.

Pour cela, passez tout d’abord votre module en mode commande en mettant sa broche Key à 1.
Maintenant, en reprenant le programme vu plus haut faisant un echo dans la voie série, envoyons la chaîne suivante « AT+NAME ». Cette commande passée sans paramètre donne le nom visible du module. Par défaut vous devriez obtenir « HC-05 » en retour. Si maintenant nous voulions changer ce nom, nous ferions « AT+NAME=TEST » pour l’appeler « TEST » par exemple. Si tout se passe bien, le module doit vous répondre « OK ». C’est aussi simple que ça !

D’une manière générale, pour lire un paramètre on fera « AT+[paramètre] » et pour le changer on fera AT+[paramètre]=[valeur].

Lorsque vous utiliserez le module sans aucune liaison série externe pour vérifier, il peut être bon de s’assurer que tout se passe bien en vérifiant que le module renvoie bien « OK » lorsque vous changez un paramètre. Si au début du mode commande vous voulez vérifier que le module est bien présent et prêt à répondre, vous pouvez envoyer simplement « AT » et il vous répondra « OK » !
Vous devriez maintenant être en mesure d’utiliser votre module bluetooth HC-05. Il ne reste plus qu’a coder une petite application sur votre PC ou un téléphone et vous pourrez faire du pilotage à distance complètement autonome, sans fil relié à un ordinateur pour recevoir les ordres !
Une expérience (bonne ou mauvaise) à partager ? Des questions à poser ? Des conseils à donner ? Ne soyez pas timide !
 

 

 

© 2020 par Hubert SPERI – Créé avec Wix.com

WIX.png

Ce site ne contient aucun fichier avec des données personnelles et ne stocke aucune donnée personnelle lorsqu'on se connecte.

INYO_3.png
This site was designed with the
.com
website builder. Create your website today.
Start Now