PROGRAMMATION ARDUINO
•
•
Bastian MURATORY
Zamayra HERNANDEZ SOLIS
INDICE
MONTAGE ET PREMIERS MESURES .......................................................................... 1
Code : Lecture (10 bits) du capteur LM35 en °C................................................................ 2
CHOIX DE LA RÉSOLUTION DES CAN........................................................................ 3
Code : Lecture (12 bits) du capteur LM35 en °C ................................................................ 3
PARAMÉTRAGE DES FRÉQUENCES DE LECTURE ET DE TRANSMISSION ......... 4
Code : Lecture (10 bits) du capteur LM35 en °C avec fréquence de lecture de 10................. 5
AJOUT DE LA LED TEMOIN ......................................................................................... 6
CONTRÔLE DE LA LED ................................................................................................. 8
Code : Contrôle de la led à partir du rapport température/luminosité ................................... 9
INTERFACE AVEC PROCESSING............................................................................... 11
COMMUNICATION SÉRIE AVEC PROCESSING ....................................................... 11
RÉCUPÉRATION DES DONNÉES............................................................................... 12
TRACÉ DE L’ÉVOLUTION DE LA TEMPÉRATURE.................................................. 13
ENVOIE DE COMMANDES À L’ARDUINO................................................................ 14
Code processing......................................................................................................... 14
Code Arduino ............................................................................................................ 15
INSTALATION D’UNE COMMANDE À DISTANCE .................................................. 17
TABLE DES ILUSTRATIONS
Illustration 1. Câblage du capteur LM35 ......................................................................... 1
Illustration 2. Câblage du capteur LM35 et led ................................................................ 6
Illustration 3. Table des résistances commerciales ........................................................... 7
Illustration 4. Code de couleurs pour des résistances à 4 bandes ..................................... 7
Illustration 5. Schema temperature-luminosité ................................................................. 8
Illustration 6. Duty cycle ( return de 0 - 255) ................................................................... 8
Programming Port
MONTAGE ET PREMIERS MESURES
Materiaux:
•
•
LM35
Arduino DUE
Objetifs :
•
•
Mesurer la température en °C avec une précision de 2 chiffres après la virgule.
Les mesures et les envoies de données seront réalisées une fois par seconde.
Conexions :
•
A0 lecture analogique du capteur LM35
Formule :
Par défaut, la conversion analogique/numérique (CAN) fonctionne en 10 bits. Pour faire
la conversion on va lire la valeur de analogRead(), laquelle va nous donne des valeurs
entre 0 et 1024 dû au fonctionnement de 10 bits (0 à (210 -1)), correspondant aux voltages
de 0-3.3v.
On sait que le capteur LM35 envoie 0 à 0v et la tension croit de 10mV par °C.
1. Alors pour le calcule on divise ce qu’on recois de analogRead() entre 1023 pour
avoir des valeurs compris entre 0 et 1.
2. On multiplie le résultat du pas 1 pour 3300, pour obtenir le résultat en mv (3.3 v =
3300 mV)
3. Et finalement on divise le résultat du pas 2 entre 10 car 1 dégrée = 10 mv.
Illustration 1. Câblage du capteur LM35
Page 1
Code : Lecture (10 bits) du capteur LM35 en °C
1. int thermoPin = A0;
2. float val;
3.
4. void setup()
5. {
6.
pinMode(thermoPin, INPUT);
7.
pinMode(13, OUTPUT);
8.
Serial.begin(9600);
9. }
10.
11. void loop()
12. {
13.
14. delay(1000);
15.
16. val = analogRead(thermoPin); // read the input pin valeur entre 0 et 1023 (
0 - (2^10-1)) On travaille avec 10 bits
17.
18. Serial.print("TEMPERATURE *C=");
19. Serial.println(temperature(val));
20. }
21.
22.
23.
24. float temperature(float val){
25. float temp;
26. val = val/1023; //passer a 1 ( on doit le divider par 1023 ) car on utilise
10 bits dans cette cas mais on peut aussi le faire avec 12 bits
27. val = val *3.3; // avoir la valeur de 0 a 3.3 v (multiplier par 3.3)
28. val = val * 1000; //avoir la valeur en mv
29.
30. //chaque 10 mv c'est 1 degrée
31. temp = val/10;
32. return temp;
33. }
Page 2
CHOIX DE LA RÉSOLUTION DES CAN
Avec l’Arduino DUE, il est possible de configurer la résolution des Convertisseurs
Analogique/Numérique (CAN) jusqu’à 12 bits avec analogReadResolution(12).
Code : Lecture (12 bits) du capteur LM35 en °C
1. int thermoPin = A0;
2. float val;
3.
4. void setup()
5. {
6.
pinMode(thermoPin, INPUT);
7.
pinMode(13, OUTPUT);
8.
Serial.begin(9600);
9. }
10.
11. void loop()
12. {
13.
14. delay(1000);
15.
16. analogReadResolution(12); //Resolution de 12 bits
17. val = analogRead(thermoPin); // read the input pin valeur entre 0 et 4095 (
0 - (2^12-1)) On travaille avec 12 bits
18.
19. Serial.print("TEMPERATURE *C=");
20. Serial.println(temperature(val));
21. }
22.
23.
24.
25. float temperature(float val){
26. float temp;
27. val = val/4095; //passer a 1 ( on doit le divider par 4095 ) car on utilise
12 bits dans cette cas.
28. val = val *3.3; // avoir la valeur de 0 a 3.3 v (multiplier par 3.3)
29. val = val * 1000; //avoir la valeur en mv
30.
31. //chaque 10 mv c'est 1 degrée
32. temp = val/10;
33. return temp;
34. }
Page 3
PARAMÉTRAGE DES FRÉQUENCES DE LECTURE ET DE
TRANSMISSION
Pour permettre d’augmenter la fréquence des prises de mesure, tout en évitant de
surcharger la ligne série, on souhaiterait désormais pouvoir paramétrer les fréquences de
lecture et de transmission des mesures indépendamment.
Le modèle de programmation Arduino ne permettant pas de programmer des interruptions
sur déclenchement de timer, nous nous contenterons d’un paramètrage du type « une
transmission toutes les n lectures » avec la possibilité de régler la fréquence des lectures
(par exemple : lecture à 10Hz, transmission toutes les 10 lectures => transmission à 1Hz).
Spécifications supplémentaires :
•
•
les paramètres seront déclarés comme des constantes dans le sketch
n transmettra la moyenne des n dernières mesures
Page 4
Code : Lecture (10 bits) du capteur LM35 en °C avec fréquence de lecture de 10
1. int thermoPin = A0;
2. float val;
3. int frequence=10; // nombre de valeures à lire avant une transmition
4. int somme=0; // moyenne des valeures lue durants les aqcuisitions
5. int count=0; // aquisition courante
6.
7.
8. void setup()
9. {
10. pinMode(thermoPin, INPUT);
11. Serial.begin(9600);
12. }
13.
14. void loop()
15. {
16.
17. delay(1000);//toutes les secondes (Frequence d’aquisition)
18.
19. count++;
20. somme+=analogRead(thermoPin);
21.
22. //******************************************************
23.
if(count<frequence){ // compte jusqu'a la frequence
24.
Serial.print("|");
25.
Serial.print(count);
26.
Serial.print("|");
27. }else{ // puis affiche la moyenne des valeures lue
28.
Serial.print("TEMPERATURE *C=");
29.
Serial.println(temperature(somme/frequence));
30.
count = 0;
31.
somme = 0;
32. }
33.
34. //*******************************************************
35.
36. }
37.
38. float temperature(float val){
39. float temp;
40. val = val/1023; // CHOIX DE LA RESOLUTION DES CAN - passer a 1 ( on doit le
divider par 1023 ) car on utilise (CAN) 10 bits dans cette cas mais on peut au
ssi le faire avec 12 bits
41. val = val *3.3; // avoir la valeur de 0 a 3.3 v (multiplier par 3.3)
42. val = val * 1000; //avoir la valeur en mv
43.
44. //chaque 10 mv c'est 1 degrée
45. temp = val/10;
46. return temp;
47. }
Page 5
AJOUT DE LA LED TEMOIN
On souhaite désormais ajouter une led au montage pour témoigner de la
température mesurée. L’intensité de la LED sera une fonction linéaire de la température.
RAPPELS D’ELECTRONIQUE
Quelques rappels sur la LED (Light-Emitting Diode), dans un contexte basse tension
continue. Une LED est un composant bi-polaire composé :
•
•
d’une Anode, en général elle correspond à la patte la plus longue. L’anode « reçoit
» le courant, on la relie au point haut ayant le potentiel le plus haut.
d’une (K)Cathode, en général il s’agit de la patte la plus courte, relié au potentiel
bas.
La LED s’allume, et laisse passer le courant, uniquement si la tension à ses bornes dépasse
sa tension de seuil. Cette tension de seuil (Forward Voltage dans les documentations
anglophones) est donc une caractéristique fondamentale à prendre en compte dans la
conception du circuit.
Une seconde caractéristique importante est le courant moyen pouvant traverser la led en
fonctionnement normal (i.e. sans occasionner de dommage). Il s’agit de l’Average
Forward Current. Dans un circuit, il est alors impératif de s’assurer que le courant
traversant la led n’excède pas cette valeur. En général, ceci est fait en branchant une
résistance en série à la led.
Illustration 2. Câblage du capteur LM35 et led
Le microcontrôleur SAM3X8E de l’arduino DUE comporte un convertisseur numériqueanalogique 12 bits (DAC) à deux sorties. La fréquence d'échantillonnage peut en principe
atteindre 1 MHz. Le niveau de tension de ces sorties d'étend de 0,6 V à 2,7 V environ,
pour un entier 12 bits allant de 0 à 4096. La valeur médiane (2048) est la moitié de la
tension d'alimentation du microcontrôleur, soit 1,65 V.
Page 6
Dans cette application on utilise la bronche numérique 2 pour émuler une sortie
analogique grâce a la fonction du PWM. Sur les cartes DUE le port 2 est le premier port
capable de faire un signal PWM, mais on aurait pu utiliser les broches 2 à 13.
Afin de protéger le micro-contrôleur et la LED, on souhaite limiter le courant sortant de
cette broche. On inclut donc une résistance en série.
Led monochrome 10 mm Rouge : Uf (20mA) : 2V
𝑅=
𝑉𝑎𝑙𝑖𝑚𝑒𝑛𝑡𝑎𝑡𝑖𝑜𝑛 − 𝑉𝑙𝑒𝑑 3.3𝑣 − 2𝑣
=
= 65 Ω
𝐼𝑙𝑒𝑑
0.02𝐴
Par le calcule, la résistance idéale est de 65Ω, dans le marché on trouve des résistances
de 68Ω, on peut utiliser cela mais pour sécurité on va utiliser une de majeure valeur.
Illustration 3. Table des résistances commerciales
Illustration 4. Code de couleurs pour des résistances à 4 bandes
Page 7
CONTRÔLE DE LA LED
Pour modifier l’intensité lumineuse de la LED, on utilise un signal PWM. Le rapport
cyclique de ce signal détermine alors le pourcentage d’intensité de la LED. On souhaite
asservir la luminosité de la led suivant le schéma suivant :
Illustration 5. Schema temperature-luminosité
Les valeurs des seuils de luminosité et de température seront implémentées en tant que
constante et auront pour valeur : Lmin = 0%, Lmax = 100%, Tmin = 20℃ et Tmax =
25℃.
Illustration 6. Duty cycle ( return de 0 - 255)
Page 8
Code : Contrôle de la led à partir du rapport température/luminosité
1. int thermoPin = A0;
2. int ledPin=3;
3. float val;
4. int frequence=10; // nombre de valeures à lire avant une transmition
5. int somme=0; // moyenne des valeures lue durants les aqcuisitions
6. int count=0; // aquisition courante
7.
8. float Lmin = 0;
9. float Lmax = 100; // en pourcentage
10. float Tmin = 20;
11. float Tmax = 25;
12.
13. void setup()
14. {
15. pinMode(thermoPin, INPUT);
16. pinMode(ledPin, OUTPUT);
17. Serial.begin(9600);
18. }
19.
20. void loop(){
21. //*********************************************************
22. //
FREQUENCE D'AQUISITION
23. //*******************************************************
24. float moyenne;
25. delay(250);//toutes les 0.25 secondes (Frequence d’aquisition)
26.
27. count++;
28. somme+=analogRead(thermoPin);
29.
30.
if(count<frequence){ // compte jusqu'a la frequence
31.
Serial.print("|");
32.
Serial.print(count);
33.
Serial.print("|");
34. }else{ // puis affiche la moyenne des valeures lue
35.
Serial.print("TEMPERATURE *C=");
36.
moyenne = somme/frequence;
37.
Serial.println(temp(moyenne));
38.
39.
int eclair = eclairement(temperature(moyenne)); //eclairage du led
40.
analogWrite(ledPin,eclair);
41.
42.
count = 0;
43.
somme = 0;
44. }
45.
46. //*******************************************************
47.
48. }
49.
50. float temperature(float val){
51. float temp;
52. val = val*3.3/1023*1000; // valeur lue * voltage d'alimentation * 1023 (10 b
its) * 1000 (pour le résultat en mV)
53.
54. //chaque 10 mv c'est 1 degrée
55. temp = val/10;
56.
57. return temp;
58. }
59.
60. // donne le rapport cyclique de la led en fonction de la temperature moyenne (
entre 0 et 255)
61. int eclairement(float temperature){
Page 9
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
if(temperature>Tmax){
return 255*Lmax/100;
}
if(temperature<Tmin){
return 255*Lmin/100;
}
// calcul pourcentage temperature
float ecartementTempMax = Tmax-Tmin;
float reste = Tmax-temperature;
float pourcentage_temperature = 1 - (reste/ecartementTempMax); //en décimal
73.
74.
75.
76.
77.
// calcul pourcentage lumière
float ecartementLumMax = Lmax-Lmin;
float pourcentage_lumiere = ecartementLumMax*pourcentage_temperature; // en
% pourcentage
78. float resultat = Lmin + pourcentage_lumiere; // en % pourcentage
79. float luminisence = resultat / 100 * 255; // en décimal pour faire la conver
sion après de 0 à 255
80. Serial.print("Alumage à :");
81. Serial.println(luminisence);
82. return luminisence;
83. }
84.
Page 10
INTERFACE AVEC PROCESSING
Afin de pouvoir visualiser l’évolution de la température à l’écran, on souhaite d ésormais
que le montage communique avec Processing.
COMMUNICATION SÉRIE AVEC PROCESSING
1. import processing.serial.*;
2.
3. Serial myPort; // Le port série pour faire la communication
4.
5. void setup() {
6.
size(640,480);
7.
8.
// ouverture du port série - activer la liasion
9.
myPort = new Serial(this, Serial.list()[0], 9600);
10.
11. }
12.
13. void draw() {
14. background(0);
15. //Tester la présence des donées dans le buffer d'entrée du port série.
16. while (myPort.available()>0){ //serial.available() - return le numero de bit
s disponibles
17.
int monOctet;
18.
19.
//Écrire un octet sur le port série
20.
myPort.write(10101010);
21.
22.
//Lire un octet sur le port série
23.
monOctet=myPort.read();
24.
println(monOctet);
25. }
26. }
Page 11
RÉCUPÉRATION DES DONNÉES
1. import processing.serial.*;
2.
3. Serial myPort; // Le port série pour faire la communication
4. String valeur_recu;
5.
6. void setup() {
7.
size(640,480);
8.
9.
// ouverture du port série - activer la liasion
10. myPort = new Serial(this, Serial.list()[0], 9600);
11.
12. //Configuration d'un évenément sur le port série
13. myPort.bufferUntil('\n');
14.
15. }
16.
17. void draw() {
18. background(0);
19.
20. //Affichage du titre
21. fill(0,0,0);
22. textSize(32);
23. text("Lecture des informations envoyer par Arduino", 220, 75);
24.
25. //Tester la présence des donées dans le buffer d'entrée du port série.
26. while (myPort.available()>0){
27.
text("Temperature : " + valeur_recu, 10,100);
28. }
29. }
30.
31. //Fontion appelé à chaque événement sur le port série
32. void serialEvent(Serial p){
33. //Lecture de tout ce qui a été reçu depuis la dernière lecture
34. valeur_recu=p.readString();
35.
36. }
Page 12
TRACÉ DE L’ÉVOLUTION DE LA TEMPÉRATURE
1. import processing.serial.*;
2.
3. Serial myPort; // Le port série pour faire la communication
4. String valeur_recu; //Valeur recu du port série
5.
6. float valMax=30; //Échelle des temperatures
7. float valMin=0;
8.
9.
10.
11. void setup() {
12. size(640,480);
13.
14. // ouverture du port série - activer la liasion
15. myPort = new Serial(this, Serial.list()[0], 9600);
16.
17. //Configuration d'un évenément sur le port série
18. myPort.bufferUntil('\n');
19.
20. }
21.
22. void draw() {
23. background(0);
24.
25. //Tester la présence des donées dans le buffer d'entrée du port série.
26. while (myPort.available()>0){
27.
int intValRecu= Integer.valueOf(valeur_recu);
28.
if((intValRecu<=valMax)&&(intValRecu>=valMin)){
29.
float grideY=height/(valMax-valMin);
30.
float Ypoint=height-((intValRecu-valMin)*grideY);
31.
float X0point=0; //point X d'avant
32.
33.
float Xpoint=X0point+1;
34.
X0point++;
35.
36.
37.
if (Xpoint==width){
38.
clear();
39.
Xpoint=0;
40.
}
41.
ellipse(Xpoint, Ypoint, 10, 10);
42.
}
43.
44.
45.
46.
}
47. }
48. }
49.
50. //Fontion appelé à chaque événement sur le port série
51. void serialEvent(Serial p){
52. //Lecture de tout ce qui a été reçu depuis la dernière lecture
53. valeur_recu=p.readString();
54. delay(1000);
55.
56. }
Page 13
ENVOIE DE COMMANDES À L’ARDUINO
Code processing
1. import processing.serial.*;
2.
3. Serial myPort; // Le port série pour faire la communication
4. String valeur_recu; //Valeur recu du port série
5.
6. float valMax=30; //Échelle des temperatures
7. float valMin=0;
8.
9.
10.
11. void setup() {
12. size(640,480);
13.
14. // ouverture du port série - activer la liasion
15. myPort = new Serial(this, Serial.list()[0], 9600);
16.
17. //Configuration d'un évenément sur le port série
18. myPort.bufferUntil('\n');
19.
20. }
21.
22. void draw() {
23. background(0);
24.
25. if(moussePressed==true){
26.
myPort.write("#");
27. }
28.
29. //Tester la présence des donées dans le buffer d'entrée du port série.
30. while (myPort.available()>0){
31.
if (valeur_recu!="#"){
32.
int intValRecu= Integer.valueOf(valeur_recu);
33.
if((intValRecu<=valMax)&&(intValRecu>=valMin)){
34.
float grideY=height/(valMax-valMin);
35.
float Ypoint=height-((intValRecu-valMin)*grideY);
36.
float X0point=0; //point X d'avant
37.
38.
float Xpoint=X0point+1;
39.
X0point++;
40.
41.
42.
if (Xpoint==width){
43.
clear();
44.
Xpoint=0;
45.
}
46.
ellipse(Xpoint, Ypoint, 10, 10);
47.
}
48.
49.
}
50.
51.
}
52. }
53.
54.
55. //Fontion appelé à chaque événement sur le port série
56. void serialEvent(Serial p){
57. //Lecture de tout ce qui a été reçu depuis la dernière lecture
58. valeur_recu=p.readString();
59.
60. }
Page 14
Code Arduino
1. char valProcessing; //data qu'on recoit du serial port
2. int thermoPin = A0;
3. int ledPin=3;
4. float val;
5. int frequence=10; // nombre de valeures à lire avant une transmition
6. int somme=0; // moyenne des valeures lue durants les aqcuisitions
7. int count=0; // aquisition courante
8.
9. float Lmin = 0;
10. float Lmax = 100; // en pourcentage
11. float Tmin = 20;
12. float Tmax = 25;
13.
14. void setup()
15. {
16. pinMode(thermoPin, INPUT);
17. pinMode(ledPin, OUTPUT);
18. Serial.begin(9600);
19. }
20.
21. void loop(){
22. if (Serial.available()){
23.
valProcessing=Serial.read();
24. }
25.
26. if (valProcessing=="#"){
27.
//********************************************* ************
28.
//
FREQUENCE D'AQUISITION
29.
//*******************************************************
30.
float moyenne;
31.
delay(250);//toutes les 0.25 secondes (Frequence d’aquisition)
32.
33.
count++;
34.
somme+=analogRead(thermoPin);
35.
36.
if(count<frequence){ // compte jusqu'a la frequence
37.
Serial.print("|");
38.
Serial.print(count);
39.
Serial.print("|");
40.
}else{ // puis affiche la moyenne des valeures lue
41.
Serial.print("TEMPERATURE *C=");
42.
moyenne = somme/frequence;
43.
Serial.println(temp(moyenne));
44.
45.
int eclair = eclairement(temperature(moyenne)); //eclairage du led
46.
analogWrite(ledPin,eclair);
47.
48.
count = 0;
49.
somme = 0;
50.
}
51.
52.
//*******************************************************
53. } else {
54.
digitalWrite(ledPin,LOW);
55. }
56. }
57.
58. float temperature(float val){
59. float temp;
60. val = val*3.3/1023*1000; // valeur lue * voltage d'alimentation * 1023 (10 b
its) * 1000 (pour le résultat en mV)
61.
62. //chaque 10 mv c'est 1 degrée
Page 15
63. temp = val/10;
64.
65. return temp;
66. }
67.
68. // donne le rapport cyclique de la led en fonction de la temperature moyenne (
entre 0 et 255)
69. int eclairement(float temperature){
70. if(temperature>Tmax){
71.
return 255*Lmax/100;
72. }
73. if(temperature<Tmin){
74.
return 255*Lmin/100;
75. }
76.
77. // calcul pourcentage temperature
78. float ecartementTempMax = Tmax-Tmin;
79. float reste = Tmax-temperature;
80. float pourcentage_temperature = 1 - (reste/ecartementTempMax); //en décimal
81.
82.
83.
84.
85.
// calcul pourcentage lumière
float ecartementLumMax = Lmax-Lmin;
float pourcentage_lumiere = ecartementLumMax*pourcentage_temperature; // en
% pourcentage
86. float resultat = Lmin + pourcentage_lumiere; // en % pourcentage
87. float luminisence = resultat / 100 * 255; // en décimal pour faire la conver
sion après de 0 à 255
88. Serial.print("Alumage à :");
89. Serial.println(luminisence);
90. return luminisence;
91. }
92.
Page 16
INSTALATION D’UNE COMMANDE À DISTANCE
Page 17