Now let’s examine the Wake On Radio at Wake On Radio (WOR) and power-saving, one of the essential features of our Ebyte E220 UART LoRa device based on LLCC68 Wireless Modules.
Then we must understand how to manage complex structures that are better optimized than string format data.
Ebyte LoRa E220 LLCC68 device manage Wake On Radio and sending structured data
Here a selection of LoRa devices E220-400T22D 433MHz 5Km - E220-400T30D 433MHz 10Km - E220-900T22D 868MHz 915MHz 5Km - E220-900T30D 868MHz 915MHz 10Km
If you have trouble with the device freezing , you must put a pull-up 4.7k resistor or better connect to the device AUX pin.
sx1278 sx1276 wireless lora uart module serial 3000m arduino 433 rf
As already said, these devices offer some exciting features to manage the power saving, and you can set M0 and M1 to do a wake-up from one device to another device in WOR receiving mode.
Mode M1 M0 Explanation Normal 0 0 UART and wireless channels are open, and transparent transmission is on WOR Transmitter 0 1 WOR Transmitter WOR Receiver 1 0 WOR Receiver (Supports wake up over air) Deep sleep mode 1 1 The module goes to sleep (automatically wake up when configuring parameters)
So we need to connect the sending device in WOR transmitting mode (If you fully connect the device, the library manage all modality for you) :
LoRa E32 Arduino Wake-Up connection
LoRa E32 Wemos D1 wake up the connection
LoRa E32 E220 ESP32 DEV KIT V1 Wake UP WOR transmitting mode on a breadboard
LoRa E32 E220 Arduino MKR WiFi 1010 Wake UP WOR transmitting mode on a breadboard
The receiver device must be in power saving/WOR receiving mode (If you fully connected the device, the library do all modality for you) :
LoRa E32 Arduino Power Saving connection
LoRa E32 Wemos D1 power saving connection
LoRa E32 E220 ESP32 DEV KIT V1 Power saving, WOR receiving mode on the breadboard
LoRa E32 E220 Arduino MKR WiFi 1010 Power saving WOR receiving mode on the breadboard
A critical configuration parameter is WOR Cycle, for the sender is essential because It adds a long preamble to the message (long as wake time). The handset uses the wake-up time as the cadence for checking a wake-up message. So if the receiver checks every 2000ms (polling time) if there is a message, the sender adds a 2000ms preamble. The receiver intercepts the message preamble, waits for the actual message to read, and returns to power save mode.
So If you want to maximize the power save, you must put minimal WOR Cycle. If you want more efficiency, you must do the inverse.
The sender and receiver in this device must have the same WOR Cycle.
Here is the configuration for the WOR transmitter:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
configuration.ADDL = 0x02;
configuration.ADDH = 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_200_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.enableLBT = LBT_DISABLED;
configuration.TRANSMISSION_MODE.WORPeriod = WOR_2000_011;
Sending sketch (if you don’t make a connection entirely , remember that first, you must set configuration in transmitting WOR mode and then return in specified modality)
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
#define DESTINATION_ADDL 3
#include "Arduino.h"
#include "LoRa_E220.h"
LoRa_E220 e220ttl(D3, D4, D5, D7, D6);
void setup() {
Serial.begin(9600);
delay(500);
e220ttl.begin();
e220ttl.setMode(MODE_1_WOR_TRANSMITTER);
Serial.println("Hi, I'm going to send WOR message!");
ResponseStatus rs = e220ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, "Hello, world? WOR!");
Serial.println(rs.getResponseDescription());
}
void loop() {
if (e220ttl.available()>1) {
ResponseContainer rc = e220ttl.receiveMessage();
if (rc.status.code!=1){
Serial.println(rc.status.getResponseDescription());
}else{
Serial.println(rc.status.getResponseDescription());
Serial.println(rc.data);
}
}
if (Serial.available()) {
String input = Serial.readString();
ResponseStatus rs = e220ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, input);
Serial.println(rs.getResponseDescription());
}
}
Now the receiver configuration:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
configuration.ADDL = 0x03;
configuration.ADDH = 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_200_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.enableLBT = LBT_DISABLED;
configuration.TRANSMISSION_MODE.WORPeriod = WOR_2000_011;
Arduino Nano 33 IoT on breadboard with Ebyte LoRa E22
And receiving sketch (if you don’t make a connection entirely , remember that first, you must set configuration in program/sleep mode and then return in specified modality) :
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
#define DESTINATION_ADDL 2
#define AUX_PIN 15
#include "Arduino.h"
#include "LoRa_E220.h"
LoRa_E220 e220ttl(&Serial2, 15, 21, 19);
bool interruptExecuted = false;
#ifdef ESP32
void IRAM_ATTR wakeUp() {
interruptExecuted = true;
detachInterrupt(AUX_PIN);
}
#elif define(ESP8266)
ICACHE_RAM_ATTR void wakeUp() {
interruptExecuted = true;
detachInterrupt(AUX_PIN);
}
#else
void wakeUp() {
interruptExecuted = true;
detachInterrupt(AUX_PIN);
}
#endif
void setup() {
Serial.begin(9600);
while (!Serial) {
;
}
delay(100);
e220ttl.begin();
e220ttl.setMode(MODE_2_WOR_RECEIVER);
delay(1000);
Serial.println();
Serial.println("Start sleep!");
delay(100);
attachInterrupt(AUX_PIN, wakeUp, FALLING);
}
void loop() {
if (e220ttl.available() > 1) {
Serial.println("Message arrived!");
ResponseContainer rs = e220ttl.receiveMessage();
String message = rs.data;
Serial.println(rs.status.getResponseDescription());
Serial.println(message);
e220ttl.setMode(MODE_0_NORMAL);
delay(1000);
ResponseStatus rsSend = e220ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, "We have received the message!");
Serial.println(rsSend.getResponseDescription());
}
if(interruptExecuted) {
Serial.println("WakeUp Callback, AUX pin go LOW and start receive message!");
Serial.flush();
interruptExecuted = false;
}
}
Pay attention to this receiver sketch only the LoRa E220 go in sleep mode, so in a real example, you must manage the sleep of the microcontroller. In the following articles, we will check the deep sleep of every microcontroller with detailed examples.
To send and receive, you must set the normal mode; if you make a complete connection, the library does the correct setting automatically.
Ebyte LoRa E32 E22 E220 Arduino UNO normal mode breadboard
M0 GND (Set normal mode) M1 GND (Set normal mode) TX PIN 2 (PullUP 4,7KΩ) RX PIN 3 (PullUP 4,7KΩ & Voltage divider) AUX Not connected (PullUP 4,7KΩ) VCC 5v GND GND
and this configuration for Wemos D1 mini:
Ebyte LoRa E32 E22 E220 Wemos D1 normal mode breadboard
M0 GND (Set normal mode) M1 GND (Set normal mode) TX PIN D2 (PullUP 4,7KΩ) RX PIN D3 (PullUP 4,7KΩ) AUX Not connected (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 (Set normal mode) M1 GND (Set normal mode) RX TX2 (PullUP 4,7KΩ) TX RX2 (PullUP 4,7KΩ) AUX Not connected (PullUP 4,7KΩ) VCC 3.3v/5v GND GND
Arduino MKR WiFi 1010:
Ebyte LoRa Exx Arduino MKR WiFi 1010 normal mode connected breadboard
We can use string as we want, use It as JSON format, and so on, but if you’re going to use structured messages in native mode (byte array), It’s more .
The example code for the sender can be:
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 = e220ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, &message, sizeof(Message));
Serial.println(rs.getResponseDescription());
and to receive:
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 (e220ttl.available()>1) {
#ifdef ENABLE_RSSI
ResponseStructContainer rsc = e220ttl.receiveMessageRSSI(sizeof(Message));
#else
ResponseStructContainer rsc = e220ttl.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
}
}
To manage Sender and Receiver, you can use the FIXED SENDER and FIXED RECEIVER configuration:
Sender:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
configuration.ADDL = 0x02;
configuration.ADDH = 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_200_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.enableLBT = LBT_DISABLED;
configuration.TRANSMISSION_MODE.WORPeriod = WOR_2000_011;
And you must uncomment the relative define in the sketch:
1
2
3
#define DESTINATION_ADDL 3
#define ROOM "Kitchen"
Receiver:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
configuration.ADDL = 0x03;
configuration.ADDH = 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_200_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.enableLBT = LBT_DISABLED;
configuration.TRANSMISSION_MODE.WORPeriod = WOR_2000_011;
And you must uncomment the relative define in the sketch
1
2
3
#define DESTINATION_ADDL 2
#define ROOM "Bathroo"
Complete sender and receiver sketch:
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 ROOM "Kitchen"
#include "Arduino.h"
#include "LoRa_E220.h"
LoRa_E220 e220ttl(&Serial2, 15, 21, 19);
struct Message {
char type[5];
char message[8];
float temperature;
};
void setup() {
Serial.begin(9600);
delay(500);
e220ttl.begin();
Serial.println("Hi, I'm going to send message!");
struct Message message = {"TEMP", ROOM, 19.2};
ResponseStatus rs = e220ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, &message, sizeof(Message));
Serial.println(rs.getResponseDescription());
}
void loop() {
if (e220ttl.available()>1) {
#ifdef ENABLE_RSSI
ResponseStructContainer rsc = e220ttl.receiveMessageRSSI(sizeof(Message));
#else
ResponseStructContainer rsc = e220ttl.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
}
}
if (Serial.available()) {
struct Message message = { "TEMP", ROOM, 0 };
message.temperature = Serial.parseFloat();
ResponseStatus rs = e220ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, &message, sizeof(Message));
Serial.println(rs.getResponseDescription());
}
}
But real life is not so simple, and probably you have multiple sensors with different structures in your home, so you need to receive various structures. A possible solution is to read the first part of the structure and instantiate the rest as you want.
esp32 DOIT DEV KIT v1 EByte LoRa E32 shield main
So if you would have the TYPE of structure you are going to read:
1
2
3
4
char type[5];
ResponseContainer rs = e220ttl.receiveInitialMessage(sizeof(type));
String typeStr = rs.data;
With this information, we can create specified structures from different devices, for example:
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 = e220ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, &messageT, sizeof(MessageTemperature));
Serial.println(rsT.getResponseDescription());
or
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 = e220ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, &message, sizeof(MessageHumidity));
Serial.println(rs.getResponseDescription());
And so you can load the specified structure from the receiver:
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 (e220ttl.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 = e220ttl.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 = e220ttl.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!!");
}
}
}
Here sender sketches that send humidity and temperature, read the first part, the type, and execute the correct code to retrieve the remaining data:
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
#define MESSAGE_TYPE "HUMI"
#define DESTINATION_ADDL 2
#define ROOM "Bathroo"
#include "Arduino.h"
#include "LoRa_E220.h"
LoRa_E220 e220ttl(&Serial1, 0, 2, 4);
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);
delay(500);
e220ttl.begin();
Serial.println("Hi, I'm going to send message!");
struct MessageHumidity message = { "HUMI", ROOM, 80 };
ResponseStatus rs = e220ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, &message, sizeof(MessageHumidity));
Serial.println(rs.getResponseDescription());
struct MessageTemperature messageT = { "TEMP", ROOM, 0 };
*(float*)(messageT.temperature) = 19.2;
ResponseStatus rsT = e220ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, &messageT, sizeof(MessageTemperature));
Serial.println(rsT.getResponseDescription());
}
void loop() {
if (e220ttl.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 = e220ttl.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 = e220ttl.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 = e220ttl.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 = e220ttl.sendFixedMessage(0, DESTINATION_ADDL, 23, &message, sizeof(MessageTemperature));
Serial.println(rs.getResponseDescription());
}
}
}
And this was the last part of my little tutorial. Next, we will examine the wake-up of the microcontroller in detail, not only the LoRa device.
Ebyte LoRa E220 device for Arduino, esp32 or esp8266: settings and basic usage Ebyte LoRa E220 device for Arduino, esp32 or esp8266: library Ebyte LoRa E220 device for Arduino, esp32 or esp8266: configuration Ebyte LoRa E220 device for Arduino, esp32 or esp8266: fixed transmission, broadcast, monitor, and RSSI Ebyte LoRa E220 device for Arduino, esp32 or esp8266: power-saving and sending structured data Ebyte LoRa E220 device for Arduino, esp32 or esp8266: WOR microcontroller and Arduino shield Ebyte LoRa E220 device for Arduino, esp32 or esp8266: WOR microcontroller and WeMos D1 shield Ebyte LoRa E220 device for Arduino, esp32 or esp8266: WOR microcontroller and esp32 dev v1 shield Github library
