Sunteți pe pagina 1din 8

Ministerul Educaţiei, Culturii și Cercetării Universitatea

Tehnică a Moldovei Facultatea Calculatoare Informatică şi


Microelectronică Departamentul Ingineria Software şi
Automatică

Raport
Lucrarea de laborator nr.7
Disciplina: Internetul lucrurilor (IoT)
Tema: Comunicare

A elaborat: st. gr. SI-171, Iepuras Daniel

A verificat: conf. Serghei Dubac

Chișinău 2020
Enuntul problemei

Sa se realizeze o aplicatie ce va implementa comunicatiile intre echipamente dupa


cum urmeaza:
1. Protocol fizic de comunicare - Comunicarea intre DOUA Microcontrollere prin
interfata I2C
• MCU1 - implementeaza sensorul digital cu interfata I2C pentru sensorul
ultrasonic HCS-04, unde se ececuta colectarea datelor de la interfata sensorului
si se retransmite catre interfata I2C la detectarea unei cereri de citire a datelor.
• MCU2 - executa cererea prin interfata I2C catre sesorul digital ultrasonic
(MCU+HCS-04)
2. Protocol logic de comunicare - cererea de date prin interfata serial, in format text
respectand un protocol de comunicare care va avea campurile:

• indicator de start pachet


• indicator de sfarsit
• contorizare pachete
• ID emitator
• ID receptor
• tipul pachetului
• <alte campuri optional>
• date pachet - Payload
• suma de control - suma tuturor valorilor numerice din pachet
Realizarea Lucrarii
1.1 Materiale Necesare

Figura 1.1 – Componentele Necesare Circuitului

1.2 Structura Circuitului

Figura 1.2 – Structura Circuitului


1.3 Codul Arduino

1.3.1 Codul pentru Arduino Uno R3 Master

2. #include<Wire.h>
3.
4. #define SLAVE_ADDRESS 0x05
5. #define SONIC_STATUS_CMD "sonic_dist"
6. #define TIMEOUT 30
7. #define BYTE_ARR_SIZE 2
8.
9. #define SERIAL_BITS_NUM 9600
10. #define EOS "'\0'"
11. #define EOL '\n'
12. #define MAX_TASKS 10
13. #define length(arr) sizeof(arr)/sizeof(*arr)
14.
15. template<class T> inline Print &operator <<(Print &obj, T arg) { obj.print(arg); return ob
j; }
16.
17. HardwareSerial &operator >>(HardwareSerial &obj, String &arg) { arg=obj.readString(); retu
rn obj; }
18. HardwareSerial &operator >>(HardwareSerial &obj, int &arg) { arg=(int) obj.parseInt(); ret
urn obj; }
19. HardwareSerial &operator >>(HardwareSerial &obj, long &arg) { arg=obj.parseInt(); return o
bj; }
20. HardwareSerial &operator >>(HardwareSerial &obj, char &arg) { arg=obj.read(); return obj;
}
21. HardwareSerial &operator >>(HardwareSerial &obj, float &arg) { arg=obj.parseFloat(); retur
n obj; }
22.
23.
24. class TaskManager
25. {
26. private:
27. int ticks;
28.
29. unsigned long Timeout[MAX_TASKS][2] = {0};
30. void (*Tasks[MAX_TASKS])() = {0};
31.
32. public:
33. int tick()
34. {
35. unsigned long time_now = millis();
36.
37. for(int i = 0; i < MAX_TASKS; i++)
38. {
39. if(Tasks[i] != 0 && time_now >= Timeout[i][1])
40. {
41. Timeout[i][1] = time_now + Timeout[i][0];
42. (*Tasks[i])();
43. }
44.
45. }
46. }
47.
48. bool AddTask(void (*fun)(), unsigned long timeout )
49. {
50. int available = -1;
51.
52. for(int i = 0; i < MAX_TASKS; i++)
53. {
54. if(Tasks[i] == fun)
55. {
56. return false;
57. }
58. else
59. {
60. if(Tasks[i] == 0 && available == -1)
61. available = i;
62. }
63. }
64.
65. if(available != -1 && timeout != 0)
66. {
67. Tasks[available]=fun;
68. Timeout[available][0] = timeout;
69. Timeout[available][1] = millis() + timeout;
70. return true;
71. }
72.
73. return false;
74. }
75.
76. bool RemoveTask(void (*fun)())
77. {
78.
79. for(int i = 0; i < MAX_TASKS; i++)
80. {
81. if(Tasks[i] == fun)
82. {
83. Tasks[i] = 0;
84. return true;
85. }
86.
87. }
88.
89. return false;
90. }
91.
92. bool ChangeTimeout(void (*fun)(), unsigned long timeout)
93. {
94.
95. for(int i = 0; i < MAX_TASKS; i++)
96. {
97. if(Tasks[i] == fun)
98. {
99. Timeout[i][0] = timeout;
100. Timeout[i][1] = millis() + timeout;
101. return true;
102. }
103.
104. }
105.
106. return false;
107. }
108.
109. };
110.
111.
112. uint8_t Buffer[BYTE_ARR_SIZE];
113. int buff_it;
114. TaskManager manager;
115. bool sonic_cmd = false;
116.
117. void setup()
118. {
119. Serial.begin(SERIAL_BITS_NUM);
120. Wire.begin();
121. manager.AddTask(WaitCmd, TIMEOUT);
122. manager.AddTask(RequestData, TIMEOUT);
123. }
124.
125. void WaitCmd()
126. {
127. if (!Serial.available())
128. return;
129.
130. String cmd;
131. Serial >> cmd;
132. if(cmd.equals(SONIC_STATUS_CMD))
133. {
134. sonic_cmd = true;
135. }
136. else
137. {
138. Serial << "Unknown Command." << EOL;
139. }
140. }
141.
142. int Create_Int( const uint8_t Byte_hi, const uint8_t Byte_lo)
143. {
144. return (int)(( Byte_hi << 8 ) | Byte_lo & 0x00FF );
145. }
146.
147. void RequestData()
148. {
149. if(!sonic_cmd)
150. return;
151.
152. sonic_cmd = false;
153.
154. Wire.requestFrom(SLAVE_ADDRESS, BYTE_ARR_SIZE);
155. int i = 0;
156. while (Wire.available())
157. {
158. Buffer[i++] = Wire.read();
159. }
160.
161. int distance = Create_Int(Buffer[0], Buffer[1]);
162.
163. Serial << "Sonic Distance Received from Slave is : " << distance << EOL;
164. }
165.
166.
167. void loop()
168. {
169. manager.tick();
170. }
1.3.2 Codul pentru Arduino Uno R3 Slave

1. #include <Wire.h>
2.
3. #define MASTER_ADDRESS 0x05
4. #define TRIG_PIN 3
5. #define ECHO_PIN 2
6. #define BYTE_ARR_SIZE 2
7.
8. int UltrasonicRead(int trig_pin, int echo_pin)
9. {
10. long duration;
11. int distance;
12.
13. digitalWrite(TRIG_PIN, LOW);
14. delayMicroseconds(2);
15.
16. digitalWrite(trig_pin, HIGH);
17. delayMicroseconds (10) ;
18. digitalWrite(trig_pin, LOW);
19.
20. duration = pulseIn(ECHO_PIN, HIGH);
21.
22. distance = duration * 0.034 / 2;
23. return distance;
24. }
25.
26.
27. uint8_t Buffer[BYTE_ARR_SIZE];
28.
29. void requestEvent() {
30. int distance = UltrasonicRead(TRIG_PIN, ECHO_PIN);
31. Buffer[0] = highByte(distance);
32. Buffer[1] = lowByte(distance);
33. Wire.write(Buffer,BYTE_ARR_SIZE);
34. }
35.
36. void setup() {
37. pinMode(TRIG_PIN, OUTPUT);
38. pinMode(ECHO_PIN, INPUT);
39. Wire.begin(MASTER_ADDRESS);
40. Wire.onRequest(requestEvent);
41. }
42.
43.
44. void loop(void){}

1.4 Rezultate

In cadrul circuitului dat a fost creata o conexiune fizica prin porturile A5 ale
ambele borduri si creata o conexiune logica prin comunica prin interfata dupa logica
master-slave. Astfel placa master cerea mesaj de la interfata seriala si daca utilizatorul
introducea comanda de afisare a rezultatelor atunci aceasta facea conexiune catre placa
slave pentru a citi datele de la sensorul ultrasonic. Astfel s-au creat doua taskuri pe
placa master, unul de receptare a comenzii de la interfata seriala si al doilea de cititre
date de la placa slave. Protocolul de comunicare logic consta in returnarea ca rezultat
spre placa master a unui array din doi octeti care vor contine primii opt biti superiori
si cei inferiori a valorii intregi citite de la ultrasonic, dupa care acestea vor fi parsate
inapoi in numar intreg pe placa master si afisat rezultatul la interfata seriala de pe
aceeasi placa.

Concluzie

In lucrarea data de laborator am studiat metodele si tehnicile de comunicare intre


mai multe borduri dupa anumite principii cum ar fi master-slave. Am realizat ca
aceasta comunicare este destul de importanta atunci cand unele componente sunt deja
instalate si sunt necesari alti senzori sau componente aditionale dar nu sunt
compatibile cu board-ul initial si este nevoie de alt board. Sau pur si simplu atunci
cand este nevoie de a lega mai multe noduri intre ele ca acestea sa poata comunica si a
partaja date intre ele.

S-ar putea să vă placă și