Ora andremo a vedere il Wake On Radio (WOR) e il risparmio energetico, una delle caratteristiche essenziali del nostro dispositivo E22 UART LoRa basato sui popolari chip RF SX1262, SX1268 di Semtech.
Ebyte LoRa E22 power-saving WOR and structured data Poi capiremo come gestire strutture complesse che sono meglio ottimizzate rispetto ai dati in formato stringa.
Ecco una selezione dei dispositivi LoRa AliExpress (433MHz 5.5Km) - AliExpress (433MHz 10Km) - AliExpress (868MHz 915Mhz 5.5Km) - AliExpress (868MHz 915Mhz 10Km)
Se hai problemi con il freeze del dispositivo , devi mettere una resistenza di pull-up da 4,7k o meglio collegare il pin AUX del dispositivo.
sx1278 sx1276 wireless LoRa uart module serial 3000m Arduino 433 rf Questi dispositivi, rispetto a E32 ed E220, hanno una gestione diversa di WOR e sleep, è necessario impostare M0 e M1 per ricevitore e mittente allo stesso modo.
Modalità M1 M0 Spiegazione Normale 0 0 UART e il canale wireless sono aperti, la trasmissione trasparente è attiva (supporta la configurazione via etere tramite comando speciale) Modalità WOR 0 1 Può essere impostato come trasmettitore WOR e ricevitore WOR Modalità configurazione 1 0 Gli utenti possono accedere al registro tramite la porta seriale per controllare lo stato di funzionamento del modulo Modalità Deep sleep 1 1 Sleep mode
Quindi dobbiamo collegare il dispositivo di invio in modalità WOR.
Ebyte LoRa E22 Arduino UNO WOR mode connection Ebyte LoRa E22 Wemos D1: WOR mode connection LoRa E22 ESP32 DEV KIT V1 WOR mode breadboard Ebyte LoRa E22 Arduino Nano 33 IoT WOR mode connection LoRa E22 Arduino MKR WiFi 1010: WOR mode connection Un parametro di configurazione critico è WOR Cycle, per il mittente è essenziale perché aggiunge un lungo preambolo al messaggio (lungo come il tempo di attivazione), il ricevitore utilizza il wake time come tempo di intervallo di pull.
Quindi, se vuoi massimizzare il risparmio energetico, devi mettere un ciclo WOR minimo. Se vuoi una maggiore efficienza, devi fare il contrario.
Il mittente e il destinatario in questo dispositivo devono avere lo stesso ciclo WOR.
Ecco la configurazione per il trasmettitore WOR:
configuration.ADDL = 0x02;
configuration.ADDH = 0x00;
configuration.NETID = 0x00;
configuration.CHAN = 23;
configuration.SPED.uartBaudRate = UART_BPS_9600;
configuration.SPED.airDataRate = AIR_DATA_RATE_010_24;
configuration.SPED.uartParity = MODE_00_8N1;
configuration.OPTION.subPacketSetting = SPS_240_00;
configuration.OPTION.RSSIAmbientNoise = RSSI_AMBIENT_NOISE_DISABLED;
configuration.OPTION.transmissionPower = POWER_22;
configuration.TRANSMISSION_MODE.enableRSSI = RSSI_DISABLED;
configuration.TRANSMISSION_MODE.fixedTransmission = FT_FIXED_TRANSMISSION;
configuration.TRANSMISSION_MODE.enableRepeater = REPEATER_DISABLED;
configuration.TRANSMISSION_MODE.enableLBT = LBT_DISABLED;
configuration.TRANSMISSION_MODE.WORTransceiverControl = WOR_TRANSMITTER;
configuration.TRANSMISSION_MODE.WORPeriod = WOR_2000_011;
Sketch di invio:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#define DESTINATION_ADDL 3
#include "Arduino.h"
#include "LoRa_E22.h"
LoRa_E22 e22ttl(&Serial1, 2, 4, 6);
void setup() {
Serial.begin(9600);
delay(500);
e22ttl.begin();
e22ttl.setMode(MODE_1_WOR);
Serial.println("Hi, I'm going to send message!");
ResponseStatus rs = e22ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, "Hello, world?");
Serial.println(rs.getResponseDescription());
e22ttl.setMode(MODE_0_NORMAL);
}
void loop() {
if (e22ttl.available()>1) {
#ifdef ENABLE_RSSI
ResponseContainer rc = e22ttl.receiveMessageRSSI();
#else
ResponseContainer rc = e22ttl.receiveMessage();
#endif
if (rc.status.code!=1){
Serial.println(rc.status.getResponseDescription());
}else{
Serial.println(rc.status.getResponseDescription());
Serial.println(rc.data);
#ifdef ENABLE_RSSI
Serial.print("RSSI: "); Serial.println(rc.rssi, DEC);
#endif
}
}
if (Serial.available()) {
String input = Serial.readString();
ResponseStatus rsSend = e22ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, "We have received the message!");
Serial.println(rsSend.getResponseDescription());
}
}
Ora la configurazione del ricevitore:
configuration.ADDL = 0x03;
configuration.ADDH = 0x00;
configuration.NETID = 0x00;
configuration.CHAN = 23;
configuration.SPED.uartBaudRate = UART_BPS_9600;
configuration.SPED.airDataRate = AIR_DATA_RATE_010_24;
configuration.SPED.uartParity = MODE_00_8N1;
configuration.OPTION.subPacketSetting = SPS_240_00;
configuration.OPTION.RSSIAmbientNoise = RSSI_AMBIENT_NOISE_DISABLED;
configuration.OPTION.transmissionPower = POWER_22;
configuration.TRANSMISSION_MODE.enableRSSI = RSSI_DISABLED;
configuration.TRANSMISSION_MODE.fixedTransmission = FT_FIXED_TRANSMISSION;
configuration.TRANSMISSION_MODE.enableRepeater = REPEATER_DISABLED;
configuration.TRANSMISSION_MODE.enableLBT = LBT_DISABLED;
configuration.TRANSMISSION_MODE.WORTransceiverControl = WOR_RECEIVER;
configuration.TRANSMISSION_MODE.WORPeriod = WOR_2000_011;
esp32 DOIT DEV KIT v1 EByte LoRa E32 shield main E lo sketch del ricevitore con la sveglia per l’ESP32:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#define DESTINATION_ADDL 2
#include "Arduino.h"
#include "LoRa_E22.h"
#include <WiFi.h>
#include "soc/rtc_cntl_reg.h"
#include "soc/rtc.h"
#include "driver/rtc_io.h"
#define FPM_SLEEP_MAX_TIME 0xFFFFFFF
void callback() {
Serial.println("Callback");
Serial.flush();
}
LoRa_E22 e22ttl(&Serial2, 15, 21, 19);
void setup()
{
Serial.begin(9600);
while (!Serial) {
;
}
delay(100);
e22ttl.begin();
e22ttl.setMode(MODE_1_WOR);
delay(1000);
Serial.println();
Serial.println("Start sleep!");
delay(100);
esp_sleep_enable_ext0_wakeup(GPIO_NUM_15,LOW);
Serial.println("Going to sleep now");
delay(100);
esp_light_sleep_start();
delay(1);
Serial.println();
Serial.println("Wake and start listening!");
}
void loop()
{
if (e22ttl.available() > 1){
Serial.println("Message arrived!");
#ifdef ENABLE_RSSI
ResponseContainer rs = e22ttl.receiveMessageRSSI();
#else
ResponseContainer rs = e22ttl.receiveMessage();
#endif
String message = rs.data;
Serial.println(rs.status.getResponseDescription());
Serial.println(message);
e22ttl.setMode(MODE_0_NORMAL);
delay(1000);
e22ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, "We have received the message!");
}
}
Fai attenzione in questo sketch solo il LoRa E220 va in modalità sleep, quindi in un esempio reale, devi gestire lo sleep del microcontrollore. Nei seguenti articoli, verificheremo il sonno profondo di ogni microcontrollore con esempi dettagliati.
Per inviare e ricevere, è necessario impostare la modalità normale; se si effettua una connessione completa, la libreria esegue automaticamente l’impostazione corretta.
Ebyte LoRa E32 E22 E220 Arduino UNO normal mode breadboard M0 GND (Imposta il normal mode) M1 GND (Imposta il normal mode) TX PIN 2 (PullUP 4,7KΩ) RX PIN 3 (PullUP 4,7KΩ & partitore di tensione) AUX Non connesso (PullUP 4,7KΩ) VCC 5v GND GND
e questa configurazione per Wemos D1 mini:
Ebyte LoRa E32 E22 E220 Wemos D1 normal mode breadboard M0 GND (Imposta il normal mode) M1 GND (Imposta il normal mode) TX PIN D2 (PullUP 4,7KΩ) RX PIN D3 (PullUP 4,7KΩ) AUX Non connesso (PullUP 4,7KΩ) VCC 3.3v/5v GND GND
ESP-32:
Ebyte LoRa E32 E22 E220 ESP32 DEV KIT V1 normal mode breadboard M0 GND (Imposta il normal mode) M1 GND (Imposta il normal mode) RX TX2 (PullUP 4,7KΩ) TX RX2 (PullUP 4,7KΩ) AUX Non connesso (PullUP 4,7KΩ) VCC 3.3v/5v GND GND
Arduino MKR WiFi 1010:
Ebyte LoRa Exx Arduino MKR WiFi 1010 normal mode connected breadboard Possiamo usare la stringa come vogliamo, usarla come formato JSON e così via, ma se utilizzerai messaggi strutturati in modalità nativa (array di byte) è più efficiente.
Il codice di esempio per il mittente può essere:
1
2
3
4
5
6
7
8
9
10
11
12
struct Message {
char type[5];
char message[8];
float temperature;
};
struct Message message = {"TEMP", ROOM, 19.2};
ResponseStatus rs = e22ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, &message, sizeof(Message));
Serial.println(rs.getResponseDescription());
e per ricevere:
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
if (e22ttl.available()>1) {
#ifdef ENABLE_RSSI
ResponseStructContainer rsc = e22ttl.receiveMessageRSSI(sizeof(Message));
#else
ResponseStructContainer rsc = e22ttl.receiveMessage(sizeof(Message));
#endif
if (rsc.status.code!=1){
Serial.println(rsc.status.getResponseDescription());
}else{
Serial.println(rsc.status.getResponseDescription());
struct Message message = *(Message*) rsc.data;
Serial.println(message.type);
Serial.println(message.message);
Serial.println(message.temperature);
#ifdef ENABLE_RSSI
Serial.print("RSSI: "); Serial.println(rsc.rssi, DEC);
#endif
}
}
Per gestire Mittente e Ricevente è possibile utilizzare la configurazione FIXED SENDER e FIXED RECEIVER:
Mittente:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
configuration.ADDL = 0x02;
configuration.ADDH = 0x00;
configuration.NETID = 0x00;
configuration.CHAN = 23;
configuration.SPED.uartBaudRate = UART_BPS_9600;
configuration.SPED.airDataRate = AIR_DATA_RATE_010_24;
configuration.SPED.uartParity = MODE_00_8N1;
configuration.OPTION.subPacketSetting = SPS_240_00;
configuration.OPTION.RSSIAmbientNoise = RSSI_AMBIENT_NOISE_DISABLED;
configuration.OPTION.transmissionPower = POWER_22;
configuration.TRANSMISSION_MODE.enableRSSI = RSSI_DISABLED;
configuration.TRANSMISSION_MODE.fixedTransmission = FT_FIXED_TRANSMISSION;
configuration.TRANSMISSION_MODE.enableRepeater = REPEATER_DISABLED;
configuration.TRANSMISSION_MODE.enableLBT = LBT_DISABLED;
configuration.TRANSMISSION_MODE.WORTransceiverControl = WOR_TRANSMITTER;
configuration.TRANSMISSION_MODE.WORPeriod = WOR_2000_011;
E devi decommentare la relativa definizione nello sketch:
1
2
3
#define DESTINATION_ADDL 3
#define ROOM "Kitchen"
Ricevitore:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
configuration.ADDL = 0x03;
configuration.ADDH = 0x00;
configuration.NETID = 0x00;
configuration.CHAN = 23;
configuration.SPED.uartBaudRate = UART_BPS_9600;
configuration.SPED.airDataRate = AIR_DATA_RATE_010_24;
configuration.SPED.uartParity = MODE_00_8N1;
configuration.OPTION.subPacketSetting = SPS_240_00;
configuration.OPTION.RSSIAmbientNoise = RSSI_AMBIENT_NOISE_ENABLED;
configuration.OPTION.transmissionPower = POWER_22;
configuration.TRANSMISSION_MODE.enableRSSI = RSSI_DISABLED;
configuration.TRANSMISSION_MODE.fixedTransmission = FT_FIXED_TRANSMISSION;
configuration.TRANSMISSION_MODE.enableRepeater = REPEATER_DISABLED;
configuration.TRANSMISSION_MODE.enableLBT = LBT_DISABLED;
configuration.TRANSMISSION_MODE.WORTransceiverControl = WOR_RECEIVER;
configuration.TRANSMISSION_MODE.WORPeriod = WOR_2000_011;
E devi decommentare la relativa definizione nello schizzo
1
2
3
#define DESTINATION_ADDL 2
#define ROOM "Bathroo"
Schizzo completo di mittente e destinatario:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
#define DESTINATION_ADDL 3
#define ENABLE_RSSI true
#include "Arduino.h"
#include "LoRa_E22.h"
LoRa_E22 e22ttl(&Serial2, 15, 21, 19);
struct Message {
char type[5];
char message[8];
byte temperature[4];
} message;
void setup() {
Serial.begin(9600);
delay(500);
e22ttl100.begin();
Serial.println("Hi, I'm going to send message!");
struct Message {
char type[5] = "TEMP";
char message[8] = "Kitchen";
byte temperature[4];
} message;
*(float*)(message.temperature) = 19.2;
ResponseStatus rs = e22ttl100.sendFixedMessage(0, DESTINATION_ADDL, 23, &message, sizeof(Message));
Serial.println(rs.getResponseDescription());
}
void loop() {
if (e22ttl100.available()>1) {
#ifdef ENABLE_RSSI
ResponseStructContainer rsc = e22ttl100.receiveMessageRSSI(sizeof(Message));
#else
ResponseStructContainer rsc = e22ttl100.receiveMessage(sizeof(Message));
#endif
if (rsc.status.code!=1){
Serial.println(rsc.status.getResponseDescription());
}else{
Serial.println(rsc.status.getResponseDescription());
struct Message message = *(Message*) rsc.data;
Serial.println(message.type);
Serial.println(message.message);
Serial.println(*(float*)(message.temperature));
#ifdef ENABLE_RSSI
Serial.print("RSSI: "); Serial.println(rsc.rssi, DEC);
#endif
}
}
if (Serial.available()) {
struct Message {
char type[5] = "TEMP";
char message[8] = "Kitchen";
byte temperature[4];
} message;
*(float*)(message.temperature) = Serial.parseFloat();
ResponseStatus rs = e22ttl100.sendFixedMessage(0, DESTINATION_ADDL, 23, &message, sizeof(Message));
Serial.println(rs.getResponseDescription());
}
}
Ma la vita reale non è così semplice e probabilmente hai più sensori con strutture diverse nella tua casa, quindi devi ricevere varie strutture. Una possibile soluzione è leggere la prima parte della struttura e istanziare il resto come si vuole.
Arduino MKR WiFi 1010 on breadboard with Ebyte LoRa E22 Quindi se desideri il TIPO di struttura leggerai:
1
2
3
4
char type[5];
ResponseContainer rs = e22ttl.receiveInitialMessage(sizeof(type));
String typeStr = rs.data;
Con queste informazioni, possiamo creare strutture specifiche da diversi dispositivi, ad esempio:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct MessageTemperature {
char type[5];
char message[8];
byte temperature[4];
};
[...]
struct MessageTemperature messageT = { "TEMP", ROOM, 0 };
*(float*)(messageT.temperature) = 19.2;
ResponseStatus rsT = e22ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, &messageT, sizeof(MessageTemperature));
Serial.println(rsT.getResponseDescription());
o
1
2
3
4
5
6
7
8
9
10
11
12
13
struct MessageHumidity {
char type[5];
char message[8];
byte humidity;
};
[...]
struct MessageHumidity message = { "HUMI", ROOM, 80 };
ResponseStatus rs = e22ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, &message, sizeof(MessageHumidity));
Serial.println(rs.getResponseDescription());
E così puoi caricare la struttura specificata dal ricevitore:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
if (e22ttl.available() > 1) {
char type[5];
ResponseContainer rs = e220ttl.receiveInitialMessage(sizeof(type));
String typeStr = rs.data;
if (rs.status.code != 1) {
Serial.println(rs.status.getResponseDescription());
} else {
Serial.println(typeStr);
if (typeStr == "TEMP") {
struct MessageTemperaturePartial {
char message[8];
byte temperature[4];
};
ResponseStructContainer rsc = e22ttl.receiveMessage( sizeof(MessageTemperaturePartial));
struct MessageTemperaturePartial message = *(MessageTemperaturePartial*) rsc.data;
Serial.println(*(float*)(message.temperature));
Serial.println(message.message);
rsc.close();
} else if (typeStr == "HUMI") {
struct MessageHumidityPartial {
char message[8];
byte humidity;
};
ResponseStructContainer rsc = e22ttl.receiveMessage(sizeof(MessageHumidityPartial));
struct MessageHumidityPartial message = *(MessageHumidityPartial*) rsc.data;
Serial.println(message.humidity);
Serial.println(message.message);
rsc.close();
} else {
Serial.println("Something goes wrong!!");
}
}
}
Quindi con uno sketch mittente che invia umidità e temperatura, possiamo leggere la prima parte, il tipo, ed eseguiamo il codice corretto per recuperare il resto dei dati:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
#define MESSAGE_TYPE "HUMI"
#define DESTINATION_ADDL 3
#define ROOM "Kitchen"
#include "Arduino.h"
#include "LoRa_E22.h"
LoRa_E22 e22ttl(&Serial1, 2, 4, 6);
struct MessageTemperature {
char type[5];
char message[8];
byte temperature[4];
};
struct MessageHumidity {
char type[5];
char message[8];
byte humidity;
};
void setup() {
Serial.begin(9600);
while(!Serial);
delay(500);
e22ttl.begin();
Serial.println("Hi, I'm going to send message!");
struct MessageHumidity message = { "HUMI", ROOM, 80 };
ResponseStatus rs = e22ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, &message, sizeof(MessageHumidity));
Serial.println(rs.getResponseDescription());
delay(1000);
struct MessageTemperature messageT = { "TEMP", ROOM, 0 };
*(float*)(messageT.temperature) = 19.2;
ResponseStatus rsT = e22ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, &messageT, sizeof(MessageTemperature));
Serial.println(rsT.getResponseDescription());
}
void loop() {
if (e22ttl.available() > 1) {
char type[5];
ResponseContainer rs = e22ttl.receiveInitialMessage(sizeof(type));
String typeStr = rs.data;
if (rs.status.code != 1) {
Serial.println(rs.status.getResponseDescription());
} else {
Serial.println(typeStr);
if (typeStr == "TEMP") {
struct MessageTemperaturePartial {
char message[8];
byte temperature[4];
};
ResponseStructContainer rsc = e22ttl.receiveMessage( sizeof(MessageTemperaturePartial));
struct MessageTemperaturePartial message = *(MessageTemperaturePartial*) rsc.data;
Serial.println(*(float*)(message.temperature));
Serial.println(message.message);
rsc.close();
} else if (typeStr == "HUMI") {
struct MessageHumidityPartial {
char message[8];
byte humidity;
};
ResponseStructContainer rsc = e22ttl.receiveMessage(sizeof(MessageHumidityPartial));
struct MessageHumidityPartial message = *(MessageHumidityPartial*) rsc.data;
Serial.println(message.humidity);
Serial.println(message.message);
rsc.close();
} else {
Serial.println("Something goes wrong!!");
}
}
}
if (Serial.available()) {
if (MESSAGE_TYPE == "HUMI") {
struct MessageHumidity message = { "HUMI", ROOM, 0 };
message.humidity = Serial.parseInt();
ResponseStatus rs = e22ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, &message, sizeof(MessageHumidity));
Serial.println(rs.getResponseDescription());
} else {
struct MessageTemperature message = { "TEMP", ROOM, 0 };
*(float*)(message.temperature) = Serial.parseFloat();
ResponseStatus rs = e22ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, &message, sizeof(MessageTemperature));
Serial.println(rs.getResponseDescription());
}
}
}
E questa è stata l’ultima parte del mio piccolo tutorial. Successivamente, esamineremo in dettaglio il risparmio energetico dei vari microcontrollori, non solo del dispositivo LoRa.
Ebyte LoRa E22 per Arduino, esp32 o esp8266: specifiche ed utilizzo base Ebyte LoRa E22 per Arduino, esp32 o esp8266: libreria Ebyte LoRa E22 per Arduino, esp32 o esp8266: configurazione Ebyte LoRa E22 per Arduino, esp32 o esp8266: trasmissione fissa, broadcast, monitor e RSSI Ebyte LoRa E22 per Arduino, esp32 o esp8266: risparmio energetico ed invio di dati strutturati Ebyte LoRa E22 per Arduino, esp32 o esp8266: ripetitore e configurazione remota Ebyte LoRa E22 per Arduino, esp32 o esp8266: WOR il microcontrollore e lo shield per Arduino Ebyte LoRa E22 per Arduino, esp32 o esp8266: WOR il microcontrollore e lo shield per il WeMos D1 mini Ebyte LoRa E22 per Arduino, esp32 o esp8266: WOR il microcontrollore e lo shield per l’esp32 dev v1 Shield e PCB
