GUO RAN

BARRIGA Ricardo
Elec5 - Systèmes
Embarqués
Objectif : L’objectif du TP est d’étudier la consommation des objets connectés et de concevoir
une application intégrant la gestion de la consommation.

I.- Introduction :
Dans ce TP nous allons étudier la consommation d’une carte Arduino mini pro qui contient une
antenne LoRa et que peut être compilé avec l’IDE Arduino. Nous allons envoyer des données en
utilisant le protocole LoRa afin d’étudier la consommation en faisant varier les paramètres de
configuration d’émission et réception.

II.- Développement :

Ex 1 : Etudier les programmes LoraSender.ino et LoraReceiver.ino. Télécharger ces programmes

sur deux cartes et vérifier le fonctionnement. Modifier ces programmes de façon à identifier vos
trames. Attention ne pas oublier de changer la fréquence LoRa.begin(866E6) lors de la mise en
route de la puce radio.

Pour commencer nous allons télécharger l’IDE Arduino et aussi le driver pour la carte. Ensuite
sur Arduino on a choisi comme gestionnaire de Carte Arduino Pro or Pro mini. Il faut installer
aussi la librairie LORA.h. Cela peut se faire avec le gestionnaire de bibliothèques. On a choisi
aussi le processeur Atmega328 les programmes LoraSender.ino et LoraReceiver.ino.

Nous pouvons voir ci-dessous le code du programme LoRaSender.ino

Nous avons choisi 865E6 comme fréquence d’émission pour ne pas perturber des autres
canaux.

Nous pouvons voir dans l’image ci-dessous le programme LoraReceiver.ino qui sera
téléchargé dans une autre carte UCA.
 Nous avons choisi 865E6 Hz comme fréquence pour recevoir le message dans le même
canal.

Nous modifions le message envoyé pour le reconnaitre. Donc on peut voir le message
reçu dans le moniteur série du récepteur. Nous pouvons voir aussi qu’on obtient le
RSSI(Received signal strength indication) qui est la puissance du signal en réception, ce qui va
sera affecté par les paramètres utilisés pour la transmission et des perturbations trouvés dans
le chemin.

Ex 2 : Après avoir étudié l’architecture de la plateforme, lister les différentes fonctions qui
nécessitent d’être caractérisées en consommation ainsi que les paramètres qui interviennent.

Dans cette partie nous allons étudier la consommation énergétique par rapport aux différents
paramètres de transmission. On sait que la portée d’une communication LoRa est déterminée
par sa bande passante, la puissance de sortie du signal ainsi que par le facteur d’étalement utilisé
– Spreading Factor (SF). L’étalement du signal augmente sa portée, au détriment du débit car il
est transmis sur une plus longue période. Au détriment également de l’autonomie de
l’équipement car la communication radio consume de l’énergie.

Nous avons donc une carte UCA émetteur et une carte UCA récepteur comme on peut voir dans
l’image ci-dessous :

Emetteur + Magnétique sensor Récepteur

D’abord on va modifier le Spreading factor de 6 to 12 avec la fonction
LoRa.setSpreadingFactor(int sf). On obtient donc la table suivante :
Spreading factor (delay=100)
SpreadingFactor A mAh mWh W A en emission v w en emission
6 0.027 19 87 0.13 0.031 5.03 0.16
7 0.047 21 108 0.211 0.071 5.03 0.291
8 0.042 23 117 0.303 0.075 5.03 0.336
9 0.05 25 126 0.258 0.098 5.03 0.485
10 0.059 27 139 0.296 0.107 5.03 0.536
11 0.059 31 156 0.371 0.108 5.03 0.541
12 0.068 34 172 0.405 0.108 5.03 0.541

Nous pouvons confirmer que plus on augmente le Spreading Factor, plus on consomme de
l’énergie avec un maximum de watts consommés dans 12SF.

Ensuite on modifie la puissance d’émission en variant de 4 à 20 dbm avec la fonction

LoRa.setTxPower(int).
Puissance d’ émission
TxPower(Dbm) A mAh mWh W A en emission V w en emission RSSI
4 0.032 0 0 0.162 0.042 5.09 0.188 RSSI=-53
10 0.033 1 6 0.167 0.044 5.09 0.198 RSSI=-46
14 0.04 4 20 0.203 0.059 5.09 0.229 RSSI=-39
17 0.045 6 31 0.239 0.065 5.09 0.301 RSSI=-35
20 0.05 7 37 0.259 0.078 5.09 0.361 RSSI=-32

Nous pouvons voir que les watts et les ampères en émission augmentent considérablement.
Aussi on peut voir que le RSSI (puissance du signal en réception) augmente si on augmente la
puissance d’émission.

Ensuite on va modifier le coding rate. Le coding rate fait référence à la proportion de bits
transmis qui transportent réellement des informations. Le taux de codage peut être 6/8, 4/8,
etc. Donc, si CR est 4/8, nous transmettons deux fois plus de bits que ceux contenant des
informations. Donc on va modifier de 5 à 8 le Coding Rate et on obtient le tableau suivant :

Coding Rate ( 4 en numérateur)

denominateur A mAh mWh W A en emission V w en emission RSSI
5 0.034 9 47 0.229 0.064 5.09 0.365 -43
6 0.047 11 56 0.249 0.07 5.09 0.401 -56
7 0.051 13 66 0.264 0.078 5.09 0.436 -55
8 0.056 14 75 0.269 0.074 5.09 0.396 -53

On peut voir que si on augmente le Coding Rate on n’augmente pas significativement la

puissance consommée. Donc on peut dire que les paramètres qui affectent le plus à la
consommation énergétique sont le Spreading Factor et la puissance de transmission.

Nous pouvons voir ci-dessous les modèles de consommation par rapport aux différents
paramètres.
 Consommation en fonction du Spreading factor
0.7

Consommation en émission(W)
0.6 y = 0.0658x - 0.1795

0.5

0.4

0.3

0.2

0.1

0
0 2 4 6 8 10 12 14
Spreading Factor

Consommation énergetique en fonction du

Coding Rate
0.5
0.45
Consommation en émission

0.4 y = -0.019x2 + 0.2598x - 0.4627

0.35
0.3
0.25
0.2
0.15
0.1
0.05
0
0 1 2 3 4 5 6 7 8 9
Denominateur du CR

Consommation énergetique en fonction de la

puissance d'émission
0.4
Consommation en émission

0.35 y = 0.001x2 - 0.0129x + 0.2241

0.3
0.25
0.2
0.15
0.1
0.05
0
0 5 10 15 20 25
Puissance d'émission
Ex4 : Notion d’autonomie
Nous sommes dans un scenario dans lequel on veut capter un champ magnétique pour
déterminer s’il y a des objets dangereux dans un avion. Pour le faire nous allons utiliser un
capteur KY025. Nous avons choisi d’envoyer les données avec une puissance de 10dbm et un SF
de 8, en sachant que l’avion n’est pas plus grand que 4km. Par rapport à cette table :

Pour connecter notre capteur on a fait attention de ne pas utiliser les pins 3, 6, 7 qui sont utilisés
par l’antenne LoRa. C’est pour cette raison qu’on utilise le digital pin 5 et l’analogique pin A0.
Ensuite on va configurer dans le setup le digital pin 5 comme input et le 13 comme output pour
la led. Après on va afficher la valeur du A0 dans le moniteur série et on va allumer la Led en
utilisant le pin 13.

On montre le code complet en annexe 1 et 2.

Nous pouvons voir le résultat ci-dessous.

Quand on rapproche l’aimant on obtient des valeurs proches de 0 et quand on éloigne l’aimant
on obtient 1023.

On analyse l’énergie consommé et on trouve les valeurs suivantes :

Energie consommé
A mAh mWh W A en emission V w en emission RSSI
setTxPower=10 et SpreadFactor=8 0.060 7 37 0.305 0.08 5.09 0.417 RSSI=-55
Ex5
Proposer des évolutions des programmes développés afin d’augmenter la durée de vie de la batterie des
différents nœuds. Evaluer l’autonomie de vos nœuds pour deux batteries :

- 3,7V, 1200 mAh

- 3,7V, 2850 mAh.

Nous voudrions connaitre la duré de vie de la batterie. Pour le savoir nous allons évaluer
l’autonomie de deux batteries : 3,7V, 1200 mAh et 3,7V, 2850 mAh.

D’abord on a trouvé que le courant en émission est de 0.053 et nous allons émettre pendant
100ms selon le tableau d’avant qui montre le time on air. Ensuite on a mis le LoRa en mode sleep
et aussi la carte pour mesurer le courant consommé quand on n’émet pas.

Comme on peut voir dans l’image ci-dessus on a réussi diminuer la consommation à 0.019A
minimum. Par rapport à notre projet nous allons envoyer les données chaque 5 secondes.

I(A)
Sending data Sleep mode
0.053A

0.019A
s
T(s)
0.1s 4.9s

Nous allons multiplier le courant fois le temps d’envoie et du temps en sleep mode. Ensuite nous
allons multiplier par le nombre d’envois dans une heure. Donc si on envoie des données chaque
5 secondes nous allons envoyer 720 fois les données dans une heure.
 𝐸 = 𝐼𝑒𝑛𝑣𝑜𝑖𝑒 ∗ 𝑇𝑒𝑛𝑣𝑜𝑖𝑒 + 𝐼𝑠𝑙𝑒𝑒𝑝 + 𝑇𝑠𝑙𝑒𝑒𝑝
𝐸 = (0.053𝐴 ∗ 0.1𝑠 + 0.019𝐴 ∗ 4.9𝑠) ∗ 3600/5
𝐸 = 0.0984𝐴𝑠 ∗ 720
𝐸 = 70.848𝐴ℎ
𝐸 = 70848𝑚𝐴ℎ
Ensuite nous allons choisir la batterie de 3,7V, 1200 mAh. Avec celui-ci nous allons diviser la
capacité de la batterie par l’énergie consommé dans une heure par notre système. On fait le
calcul suivant :

𝑁𝑜𝑚𝑏𝑟𝑒 𝑑′ ℎ𝑒𝑢𝑟𝑒𝑠𝑑′ 𝑎𝑢𝑡𝑜𝑛𝑜𝑚𝑖𝑒 = 1200𝑚𝐴ℎ / 70848𝑚𝑎ℎ

𝑁𝑜𝑚𝑏𝑟𝑒 𝑑′ ℎ𝑒𝑢𝑟𝑒𝑠 𝑑′ 𝑎𝑢𝑡𝑜𝑛𝑜𝑚𝑖𝑒 = 0.016ℎ𝑒𝑢𝑟𝑒𝑠
On refait le calcul cette fois-ci avec une batterie de 3,7V, 2850 mAh et on trouve que le Nombre
d’heures d’autonomie est de 0.04 heures.

Nous pouvons conclure que notre système consume beaucoup d’énergie. Il faudrait élargir
l’intervalle d’envoi de données et utiliser un spreading factor de 7 pour améliorer l’autonomie
de la batterie.

Ensuite nous voudrions capter quand il y a un danger et envoyer un mail à l’utilisateur. Pour le
faire nous allons utiliser python. Voici le code qui permet de voir si le champ magnétique est
trop bas.
 Alerte->envoyer mail

De même nous voudrions aussi envoyer une alerte quand le niveau de la batterie est trop bas.
Nous avons modifié le code de l’émetteur pour récupérer la tension de la batterie sur le pin A0.
Nous pouvons voir ci-dessous le code :

Nous pouvons voir le résultat dans le moniteur série

Ensuite sur python on va modifier aussi pour envoyer un mail quand le niveau de la batterie est
de 1.5V.
 Alerte->envoyer mail

Nous pouvons voir ci-dessous le squelette des 3 programmes

Emetteur :

• Initialiser les variables A0 et Digital pin 5

pour le capteur KY-025
• Déclarer les variables pour stocker la
mesure du capteur et la tension de la
batterie

Setup()

• Initialiser le Serial Communication

• Configurer le pin 5 comme INPUT
• Initialiser LoRa
• Configurer TxPower et SF

Loop()

• Commencer tx LORa
• Lire données du capteur
• Lire Tension de la batterie
• Send packet LoRa
• Delay (200)

Récepteur :

Setup()

• Initialiser le Serial Communication

• Initialiser LoRa
• Configurer SF

Loop()

• Detecter si on a recu un message

• Lire les données
• Imprimer les données reçus dans le moniteur serie
• Delay(500)
Python :

• Initialiser la variable Serial()

• Configurer le baudrate et le port
• Ouvrir la communication serial

F Imprimer « Pas de
Alerte ?
danger »

• Configurer destinataire et émetteur du mail

• Send mail

Nous pouvons voir ci-dessous le mails reçus lors de l’exécution du programme python :
Aussi on a fait un code python pour pouvoir dessiner des graphiques de nos données. Nous
pouvons voir ci-dessous l’image de données du champ magnetique vs temps :

Nous pouvons voir qu’on a la forme de V puisque nous données diminuent trop vite de 1024 à
16 quand on approche un aimant au capteur. Le code complet se trouve en annexe.

Aussi en utilisant la library numpy nous pouvons enregistre dans un fichier .csv les données
mesurés. Nous pouvons voir ci-dessous le fichier généré :

Conclusion :
En conclusion, ce TP nous a permis d’analyser et comprendre le fonctionnement d’une
antenne LoRa et pouvoir évaluer la consommation énergétique en fonction des divers
paramètres utilisés tels que le spreading factor, la puissance d’émission, le coding rate, la bande
passante et le channel. Après avoir fait les modelés de consommation nous avons pu déterminer
que les paramètres qui affectent le plus à la consommation sont la puissance d’émission et le
spreading factor. Aussi nous avons pu développer une application Objet connectés dans lequel
nous avons utilisé un capteur de champ magnétique. Nous avons appris à calculer le rendement
de la batterie et à envoyer des alertes par mail en utilisant python dans le cas d’un danger, soit
pour un champ magnétique étrange ou pour un niveau de batterie trop bas.

Annexe 1 : Sender Magnétique data

 1. #include <SPI.h>
2. #include <LoRa.h>
3.
4. //temperature mesure
5.
6. int led = 13; // define the LED pin
7. int digitalPin = 5; // KY-025 digital interface
8. int analogPin = A0; // KY-025 analog interface
9. int digitalVal; // digital readings
10. int analogVal; //analog readings
11. int counter = 0;
12.
13. void setup() {
14. Serial.begin(9600);
15. while (!Serial);
16. pinMode(led, OUTPUT);
17. pinMode(digitalPin, INPUT);
18. Serial.println("LoRa Sender");
19.
20. if (!LoRa.begin(865E6)) {
21. Serial.println("Starting LoRa failed!");
22. while (1);
23. }
24.
25. LoRa.setTxPower(10);
26. LoRa.setSpreadingFactor(8);
27. // LoRa.setSignalBandwidth(125E3);
28. }
29.
30. void loop() {
31.
32. Serial.print("Sending packet: ");
33. Serial.println(counter);
34.
35. // send packet
36. LoRa.beginPacket();
37. LoRa.print("Hola ");
38. // Read the digital interface
39. digitalVal = digitalRead(digitalPin);
40. if(digitalVal == HIGH) // if magnetic field is detected
41. {
42. digitalWrite(led, HIGH); // turn ON Arduino's LED
43. }
44. else
45. {
46. digitalWrite(led, LOW); // turn OFF Arduino's LED
47. }
48.
49. // Read the analog interface
50. analogVal = analogRead(analogPin);
51. Serial.println(analogVal); // print analog value to serial
52. delay(100);
53. LoRa.print("analogVal: ");
54. LoRa.print(analogVal);
55. LoRa.print("counter: ");
56. LoRa.print(counter);
57. LoRa.endPacket();
58.
59. counter++;
60.
61. delay(200);
62. }

Annexe 2 : Receiver Magnetique data

1. #include <SPI.h>
2. #include <LoRa.h>
3.
4. void setup() {
5. Serial.begin(9600);
6. while (!Serial);
7.
8. Serial.println("LoRa Receiver");
9.
10. if (!LoRa.begin( 865E6)) {
11. Serial.println("Starting LoRa failed!");
12. while (1);
13. }
14.
15. LoRa.setSpreadingFactor(8);
16. LoRa.setSignalBandwidth( 125E3);
17. }
18.
19. void loop() {
20. // try to parse packet
21. int packetSize = LoRa.parsePacket();
22. if (packetSize) {
23. // received a packet
24. Serial.print("Received packet '");
25.
26. // read packet
27. while (LoRa.available()) {
28. Serial.print((char)LoRa.read());
29. }
30.
31. // print RSSI of packet
32. Serial.print("' with RSSI ");
33. Serial.println(LoRa.packetRssi());
34. }
35. }
Annexe 3 : Send Niveau de batterie

1. #include <SPI.h>
2. #include <LoRa.h>
3.
4. //temperature mesure
5.
6. int led = 13; // define the LED pin
7. int digitalPin = 5; // KY-025 digital interface
8. int analogPin = A1; // KY-025 analog interface
9. int digitalVal; // digital readings
10. int analogVal; //analog readings
11. int counter = 0;
12. const float TMaxA0 = 3.3;
13.
14. void setup() {
15. Serial.begin(9600);
16. while (!Serial);
17. pinMode(led, OUTPUT);
18. pinMode(digitalPin, INPUT);
19. Serial.println("LoRa Sender");
20.
21. if (!LoRa.begin(865E6)) {
22. Serial.println("Starting LoRa failed!");
23. while (1);
24. }
25.
26. LoRa.setTxPower(10);
27. LoRa.setSpreadingFactor(8);
28. // LoRa.setSignalBandwidth(125E3);
29. }
30.
31. void loop() {
32.
33. //Serial.print("Sending packet: ");
34. Serial.println(counter);
35. unsigned int raw_bat = analogRead(A0);
36. float tension_bat = (raw_bat * ( TMaxA0 / 1024)) ;
37. Serial.print("Niveau de la batterie :");
38. Serial.print(tension_bat);
39. // send packet
40. LoRa.beginPacket();
41. // LoRa.print("Hola ");
42. // Read the digital interface
43. digitalVal = digitalRead(digitalPin);
44.
45. // Read the analog interface
46. analogVal = analogRead(analogPin);
47. Serial.println(analogVal); // print analog value to serial
48. delay(100);
49. //LoRa.print("analogVal: ");
50. LoRa.print(analogVal);
51. // LoRa.print("counter: ");
52. //LoRa.print(counter);
53. LoRa.endPacket();
54.
55. counter++;
56.
57. delay(200);
58. }
Annexe 3 : Code Python

1. import smtplib
2. from email.mime.text import MIMEText
3. from email.mime.multipart import MIMEMultipart
4.
5. import serial as s
6. ser=s.Serial()
7.
8. ser.baudrate = 9600 #Configuration du port (9600 bauds)
9. ser.port = "COM8" #Donner le port COM associé
10. ser.timeout=10 #Timeout : temps à partir duquel,
11. ser.open()
12.
13.
14. i=0
15. while i<10:
16. x=ser.readline().strip()
17. if x == b'16' or x == b'17':
18. print("Alerte")
19. print(x)
20. msg = MIMEMultipart()
21. msg['From'] = 'rbarrigaponcedeleon@gmail.com'
22. msg['To'] = 'guor1998@gmail.com'
23. msg['Subject'] = 'Alerte Champ magnetique detectée!!'
24. message = 'Valeur < 20'
25. msg.attach(MIMEText(message))
26. mailserver = smtplib.SMTP('smtp.gmail.com', 587)
27. mailserver.ehlo()
28. mailserver.starttls()
29. mailserver.ehlo()
30. mailserver.login('rbarrigaponcedeleon@gmail.com', 'xxxxx')
31. mailserver.sendmail('rbarrigaponcedeleon@gmail.com', 'guor1998@gmail.c
om',msg.as_string())
32. mailserver.quit()
33.
34. if x == b'1023' :
35. print("Pas de danger")
36. print(x)
37.
38. ser.close()