Arduino

Commander un relais avec un micro-contrôleur, savoir choisir ses composants

Programmer un micro-contrôleur c’est bien, mais pouvoir le faire interagir avec le monde extérieur c’est encore mieux, comme par exemple piloter une prise, un éclairage etc… Comme on peut s’en douter, un micro-controleur comme l’Atmega 328 qui équipe l’Arduino ne peux pas commander du 230V directement, il faut pour cela passer par un relais. Un relais c’est une sorte d’interrupteur télécommandé, qu’on pourra donc piloter avec notre Arduino.

Il existe des cartes relais toute faites, prêtes à être pilotées par l’Arduino, mais elles sont chères par rapport au prix des composants, et prennent pas mal de place dans le cas d’un montage embarqué.

carte_relai

Une carte 4 relais « préfabriquée »

Moi je vais vous montrer comment choisir vos composants pour arriver au même résultat, et surtout ce sera du sur-mesure !

Voici les composants minimum à avoir pour piloter un relais :

  • Un relais
  • Une résistance
  • Un transistor
  • Une diode

Petites explications concernant ces composants :

Le relais

 Comme on l’a dit plus haut, il joue le role d’interrupteur télécommandé 230V (dans notre cas). Il peut driver du 230V mais ne peut pas etre piloté directement par le micro controleur.

Le transistor

Pour notre montage, on va utiliser le transistor de la meme manière que notre relais, en interrupteur télécommandé. Dans notre cas, on va l’utiliser en mode saturé et en mode bloqué. Mais qu’est-ce que c’est ? Le mode saturé correspond à un interrupteur fermé, et le mode bloqué correspond à un interrupteur ouvert.

Le transistor est un composant à trois pattes : la base, le collecteur et l’emetteur. Pour l’utiliser en interrupteur télécommandé, appelé en commutation, la base est la commande, et l’interrupteur se situe entre le collecteur et l’émetteur. La jonction base – émetteur ce comporte comme une diode.

Photo 02-05-2014 13 36 57

Lorsque Vbe = 0V,  le transistor est bloqué, et comme du coup Ic = Ie = 0A, le transistor se comporte comme un interrupteur ouvert entre le collecteur et l’émetteur.

Lorsque Vbe = Vbe_max, alors le transistor est passant. Pour que le transistor soit saturé, il faut que Ib > Ic / Hfe. Il se comporte alors comme un interrupteur ferme.

Hfe, Vbe_max et d’autres valeurs barbares sont différentes suivant chaque type de transistor, elles sont données par le fabriquant. On les verra dans le calcul plus tard.

La resistance

Elle sera connectée a la base du transistor, et sera calculée pour obtenir Ib > Ic / Hfe.

La diode

On l’utilisera comme diode dite de roue libre. Elle supprime le pic de tension aux bornes de la bobine du relais lors de l’ouverture du circuit, et par consequent protege le transistor.

Pourquoi tout ça ?

Et bien c’est très simple. Une sortie d’un Arduino supporte 20mA au maximum, impossible donc d’exciter la bobine du relais. Pour se faire on va utiliser un transistor entre les deux; il a la particularité de laisser passer un courant fort venant de l’alimentation entre son collecteur et son émetteur alors qu’on envoie un petit courant sur la base. Un transistor type NPN 2N2222 par exemple supporte jusqu’a 800mA entre le collecteur et l’emetteur, largement suffisant pour piloter la bobine du relais.

Voici donc notre schéma pour piloter un relais avec un micro-controleur:


Photo 02-05-2014 14 25 42


Le choix des composants pour notre exemple

Ce qu’on veut :

  • Piloter une lampe de 60W en 230V à partir d’un Arduino

Ce qu’on sait :

  • L’Arduino tolère un maximum de 20mA@5V à ses sorties
  • Je dispose d’une alimention 5V pour mon circuit

Voilà nos données de base, on peut donc commencer à choisir ses composants dans un ordre bien précis.

Choix du relais

Pour choisir notre relais, il faut qu’il soit pilotable par le 5V de notre circuit de commande. Il faut également qu’il supporte la charge de notre ampoule de 60W.

Calcul de l’intensité consommée par notre ampoule :

Puissance = tension par intensité ( P=U*I), donc

I = P / U
I = 60 / 230
I = 0.26 A

Il nous faut un relais pilotable en 5V et supportant au moins 0,26A@230V : je choisi le LEG-5 de REYEX INC, qui est pilotable en 5V et supporte 7A@230V. On est large.

Choix du transistor

Il va commander la bobine du relais, il faut donc que l’intensité maximale admise par le collecteur soit supérieure à l’intensité parcourue par la bobine du relais. On va donc calculer cette intensité.

En regardant la documentation constructeur, la résistance de la bobine vaut 70 ohms, et on va dire qu’en théorie le transistor consomme 0V (Vce = 0V, ce qui donne une marge supérieure dans le calcul de l’intensité parcourant la bobine) donc:

Ibob = Ubob / Rbob
Ibob = (Vcc – Vce) / Rbob
Ibob = (5 – 0) / 70
Ibob = 0,071A

Il faut aussi qu’il supporte une tension de 5V entre la base et l’émetteur (tension de sortie de l’Arduino Vbe), et également une tension de 5V entre le collecteur et l’émetteur (tension du circuit Vce).

Je choisi un transistor NPN BC547B puisque son Ic_max = 100mA ( donc supérieur à Ibob), Vce_max = 45V (supérieur à notre 5V de circuit) et Vbe_max = 6V (supérieur à notre 5V de tension de commande Vbe).

Choix de la diode

La diode de roue libre va être branchée aux bornes de la bobine du relais.  Elle va devoir encaisser une tension de 5V et une intensité de 0,071 A. Je choisi la 1N4007 (parce que je l’ai déjà…) et surtout elle supporte 1000V et un courant de pointe de 50A.

Choix de la résistance

Pour cette partie j’espère que vous maitrisez la loi d’Ohm, qui est pour rappel U = R * I (tension = resistance multiplié par l’intensité).

Les caractéristiques de notre transistor BC547B:

  • Vce_sat = 0,7V
  • Vbe_sat = 0,2V
  • Gain Hfe_min = 200

On va d’abord calculer Ic:

Vcc = Vce_sat + Ubob
Vcc = Vce_sat + Rbob * Ib
Ic = Vcc – (Vce_sat) / Rbob
Ic = (5-0,2)/70
Ic = 0,069 A

Maintenant, on va calculer Ib_min, qui est l’intensité minimale à appliquer sur la base pour saturer le transistor dans notre cas. Elle est fonction de l’intensité sur le collecteur du transistor et de son gain Hfe, qui est une valeur donnée par le constructeur. J’applique également un coefficient de sécurité coeff_secu = 2 por prendre en compte les tolérances du transistor et la résistance.

Ib_min = Ic / Hfe * coeff_secu
Ib_min = 0,069 / 200 * 2
Ib_min = 0,0007 A

On a toute les données nécessaires au calcul de R :

Ve = Ur + Vbe avec Vbe = Vbe_sat
Ve = R * Ib_min + Vbe_sat
R = (Ve – Vbe_sat) / Ib_min
R = (5 – 0,7) / 0,0007
R = 6143 ohms

On va donc choisir la valeur de résistance juste en dessous, on prendra donc une résistance de 5,6 Kohms.

 


 

Quel est le cout de tout ça ?

  • Transistor BC547B : € 0,16
  • Relais LEG-5 : € 1,95
  • Diode 1N4007 : € 0,11
  • Résistance 5,6 KOhms : € 0,01

Total : €2,23

Ce n’est pas la ruine, et surtout on à maintenant un montage qui correspond totalement à notre utilisation. Et comme je suis gentil, je vous ai préparé un fichier Excel qui calcule notre résistance R en fonction des composants que vous aurez choisi : Calcul de résistance fonction transistor et relais

Publicités

Piloter ses prises et éclairages OTIO avec l’Arduino

Le voilà mon premier article !

Trève de plaisanterie, je vais essayer de vous expliquer (c’est la première fois que je tiens un blog) comment piloter des prises et des modules d’éclairage de la marque OTIO à partir d’un Arduino.

Après pas mal de recherches sur le net, je n’ai pas réussi à trouver le protocole des appareils domotiques OTIO, surement parce que leur distribution à l’air de se faire au compte-gouttes. Je me suis donc tourné vers l’excellente librairie rc-switch (à télécharger ici) qui est extrêmement simple d’utilisation et surtout qui permet de lire les codes envoyés par une télécommande (à l’aide d’un récepteur 433MHz mais ce n’est pas le sujet ici puisque je vous ai mâché le travail…). Vous pouvez tout de même la télécharger puisque nous en auront besoin également pour la partie émission.

 Pour arriver à nos fins, il faudra donc :

  • Un arduino (ahem…)
  • La librairie rc-switch (à télécharger ici)
  • Un émetteur 433 MHz (trouvable sur eBay pour moins de €5)
  • Une breadboard
  • Des fils
  • Et c’est tout !

Petit détour rapide sur l’emetteur 433MHz pour ceux qui sont pas sur d’acheter le bon :

Image

Et oui c’est ce petit objet minuscule… Tel quel, sa portée est pas trop mal (je commande mes éclairages à travers deux pièces). Il est possible d’augmenter la portée de deux manières, la plus simple étant de lui souder une antenne de 17,3cm au niveau du percage noté ANT, et la seconde manière étant d’augmenter sa tension d’alimentation à 12V. Mais attention, dans ce cas, la sortie DATA qui ira vers l’arduino sera elle aussi en 12V, et il aimera pas trop… Il faudra alors penser à mettre un pont diviseur entre l’arduino et la sortie DATA.

Passons à la partie cablage, ultra simple :

  • GND du transmetteur -> GND de l’Arduino
  • VCC du transmetteur -> 5V de l’Arduino
  • DATA du transmetteur -> pin #10 de l’Arduino

Image

Plûtot simple comme cablage ! Maintenant, avant de passer à la partie code, on va s’intéresser vite fait à la télécommande.

Image

Comme on peut le voir sur l’image du dessus la commande permet de commander 4 appareils appartenant à 4 familles, ce qui donne 16 appareils pilotables et donc 32 codes à trouver (on/off pour chaque appareil). Et comme je suis gentil, je partage.

 

Mode: 32 bit
Protocol: 2

A1 ON  :  919844896
A1 OFF :  1054062624
A2 ON  :  248756256
A2 OFF :  30652448
A3 ON  :  651409440
A3 OFF :  785627168
A4 ON  :  382973984
A4 OFF :  517191712
B1 ON  :  970176544
B1 OFF :  903067680
B2 ON  :  97761312
B2 OFF :  231979040
B3 ON  :  701741088
B3 OFF :  634632224
B4 ON  :  433305632
B4 OFF :  366196768
C1 ON  :  819181600
C1 OFF :  953399328
C2 ON  :  148092960
C2 OFF :  80984096
C3 ON  :  550746144
C3 OFF :  684963872
C4 ON  :  282310688
C4 OFF :  416528416
D1 ON  :  1020508192
D1 OFF :  852736032
D2 ON  :  47429664
D2 OFF :  181647392
D3 ON  :  752072736
D3 OFF :  584300576
D4 ON  :  483637280
D4 OFF :  315865120

GROUPE ON  :  332642336
GROUPE OFF :  601077792  

Ces donc ces fameux codes qui constituent le protocole de communication d’OTIO. Et ce sont ces mêmes codes que nous allons faire manger à la libraire rc-switch qui pilotera notre émetteur.

On peut donc passer au programme:

/*
Codes commandes OTIO 433MHz Ref. 09HA02
Ces codes peuvent etre utilisés avec la libraire RC-Switch
http://code.google.com/p/rc-switch/
Contactez moi sur Twitter: @SpoonS2K
-----------------------------------------------

Mode: 32 bit
Protocol: 2

A1 ON  :  919844896
A1 OFF :  1054062624
A2 ON  :  248756256
A2 OFF :  30652448
A3 ON  :  651409440
A3 OFF :  785627168
A4 ON  :  382973984
A4 OFF :  517191712
B1 ON  :  970176544
B1 OFF :  903067680
B2 ON  :  97761312
B2 OFF :  231979040
B3 ON  :  701741088
B3 OFF :  634632224
B4 ON  :  433305632
B4 OFF :  366196768
C1 ON  :  819181600
C1 OFF :  953399328
C2 ON  :  148092960
C2 OFF :  80984096
C3 ON  :  550746144
C3 OFF :  684963872
C4 ON  :  282310688
C4 OFF :  416528416
D1 ON  :  1020508192
D1 OFF :  852736032
D2 ON  :  47429664
D2 OFF :  181647392
D3 ON  :  752072736
D3 OFF :  584300576
D4 ON  :  483637280
D4 OFF :  315865120

GROUPE ON  :  332642336
GROUPE OFF :  601077792
*/

#include <RCSwitch.h> // on inclus la bibliotheque RC-Switch

RCSwitch rf_cmd = RCSwitch(); // initialisation
const char rf_mode = 32; // mode 32 bits
const char rf_pin = 10; // l'emetteur est connecte au pin 10 de l'arduino
const char arduino_led =  13;  // led de la carte Arduino

void setup() {
 
  Serial.begin(9600);
  rf_cmd.enableTransmit(rf_pin); // emetteur sur la broche 10
  rf_cmd.setProtocol(2); // par defaut le protocole utilisé est le 1, mais les commandes OTIO utilisent le 2
  rf_cmd.setRepeatTransmit(15); // on repete la transmission 15 fois pour etre sur qu'elle arrive bien
  rf_cmd.setPulseLength(700); //
 
  pinMode(arduino_led, OUTPUT); // la broche de la led est configuree en sortie
  digitalWrite(arduino_led, LOW); // on la met à l'état bas
 
}

/* cette fonction va envoyer le code voulu via le transmetteur et faire flasher la led de la carte arduino a chaque commande*/
void rf_send(unsigned long rf_code) {
  digitalWrite(arduino_led, HIGH);
  rf_cmd.send(rf_code, rf_mode);
  digitalWrite(arduino_led, LOW);
}

void loop() {
 
  // cette fonction d'exemple allume et eteint tout les recepteurs grace au code de groupe toute les trois secondes
 
  rf_send(332642336);
  delay(3000);
 
  rf_send(601077792);
  delay(3000);
 
}

Je pense avoir assez commenté le code, mais n’hésitez pas au besoin. A vous d’intégrer ces petits bouts de code dans votre projet maintenant !

J’utilise ce montage chez moi avec des récepteurs OTIO 09HA07 sans soucis, la portée est d’environ un étage.