Skip to content

Commit 37f9228

Browse files
aentingeraentinger
committed
Major simplification of existing code
1 parent be76df6 commit 37f9228

File tree

2 files changed

+90
-96
lines changed

2 files changed

+90
-96
lines changed

‎src/Arduino_LoRaConnectionHandler.cpp‎

Lines changed: 85 additions & 69 deletions
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,23 @@
2323

2424
#include "Arduino_LoRaConnectionHandler.h"
2525

26+
/******************************************************************************
27+
TYPEDEF
28+
******************************************************************************/
29+
30+
typedef enum
31+
{
32+
LORA_ERROR_ACK_NOT_RECEIVED = -1,
33+
LORA_ERROR_GENERIC = -2,
34+
LORA_ERROR_WRONG_PARAM = -3,
35+
LORA_ERROR_COMMUNICATION_BUSY = -4,
36+
LORA_ERROR_MESSAGE_OVERFLOW = -5,
37+
LORA_ERROR_NO_NETWORK_AVAILABLE = -6,
38+
LORA_ERROR_RX_PACKET = -7,
39+
LORA_ERROR_REASON_UNKNOWN = -8,
40+
LORA_ERROR_MAX_PACKET_SIZE = -20
41+
} LoRaCommunicationError;
42+
2643
/******************************************************************************
2744
CONSTANTS
2845
******************************************************************************/
@@ -58,57 +75,8 @@ LoRaConnectionHandler::LoRaConnectionHandler(char const * appeui, char const * a
5875
PUBLIC MEMBER FUNCTIONS
5976
******************************************************************************/
6077

61-
int LoRaConnectionHandler::write(const uint8_t *buf, size_t size) {
62-
int err;
63-
_modem.beginPacket();
64-
_modem.write(buf, size);
65-
err = _modem.endPacket(true);
66-
if (err != size) {
67-
switch (err) {
68-
case LoRaCommunicationError::LORA_ERROR_ACK_NOT_RECEIVED: {
69-
Debug.print(DBG_ERROR, "Message ack was not received, the message could not be delivered");
70-
} break;
71-
case LoRaCommunicationError::LORA_ERROR_GENERIC: {
72-
Debug.print(DBG_ERROR, "LoRa generic error (LORA_ERROR)");
73-
} break;
74-
case LoRaCommunicationError::LORA_ERROR_WRONG_PARAM: {
75-
Debug.print(DBG_ERROR, "LoRa malformed param error (LORA_ERROR_PARAM");
76-
} break;
77-
case LoRaCommunicationError::LORA_ERROR_COMMUNICATION_BUSY: {
78-
Debug.print(DBG_ERROR, "LoRa chip is busy (LORA_ERROR_BUSY)");
79-
} break;
80-
case LoRaCommunicationError::LORA_ERROR_MESSAGE_OVERFLOW: {
81-
Debug.print(DBG_ERROR, "LoRa chip overflow error (LORA_ERROR_OVERFLOW)");
82-
} break;
83-
case LoRaCommunicationError::LORA_ERROR_NO_NETWORK_AVAILABLE: {
84-
Debug.print(DBG_ERROR, "LoRa no network error (LORA_ERROR_NO_NETWORK)");
85-
} break;
86-
case LoRaCommunicationError::LORA_ERROR_RX_PACKET: {
87-
Debug.print(DBG_ERROR, "LoRa rx error (LORA_ERROR_RX)");
88-
} break;
89-
case LoRaCommunicationError::LORA_ERROR_REASON_UNKNOWN: {
90-
Debug.print(DBG_ERROR, "LoRa unknown error (LORA_ERROR_UNKNOWN)");
91-
} break;
92-
case LoRaCommunicationError::LORA_ERROR_MAX_PACKET_SIZE: {
93-
Debug.print(DBG_ERROR, "Message length is bigger than max LoRa packet!");
94-
} break;
95-
}
96-
} else {
97-
Debug.print(DBG_INFO, "Message sent correctly!");
98-
}
99-
return err;
100-
}
101-
102-
int LoRaConnectionHandler::read() {
103-
return _modem.read();
104-
}
105-
106-
bool LoRaConnectionHandler::available() {
107-
return _modem.available();
108-
}
109-
110-
NetworkConnectionState LoRaConnectionHandler::check() {
111-
78+
NetworkConnectionState LoRaConnectionHandler::check()
79+
{
11280
unsigned long const now = millis();
11381
unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast<unsigned int>(netConnectionState)];
11482

@@ -118,11 +86,11 @@ NetworkConnectionState LoRaConnectionHandler::check() {
11886

11987
switch (netConnectionState)
12088
{
121-
case NetworkConnectionState::INIT: netConnectionState = update_handleInit(); break;
122-
case NetworkConnectionState::CONNECTING: netConnectionState = update_handleConnecting(); break;
123-
case NetworkConnectionState::CONNECTED: netConnectionState = update_handleConnected(); break;
89+
case NetworkConnectionState::INIT: netConnectionState = update_handleInit(); break;
90+
case NetworkConnectionState::CONNECTING: netConnectionState = update_handleConnecting(); break;
91+
case NetworkConnectionState::CONNECTED: netConnectionState = update_handleConnected(); break;
12492
case NetworkConnectionState::DISCONNECTING: netConnectionState = update_handleDisconnecting(); break;
125-
case NetworkConnectionState::DISCONNECTED: netConnectionState = update_handleDisconnected(); break;
93+
case NetworkConnectionState::DISCONNECTED: netConnectionState = update_handleDisconnected(); break;
12694
case NetworkConnectionState::ERROR: break;
12795
case NetworkConnectionState::CLOSED: break;
12896
}
@@ -131,6 +99,44 @@ NetworkConnectionState LoRaConnectionHandler::check() {
13199
return netConnectionState;
132100
}
133101

102+
int LoRaConnectionHandler::write(const uint8_t * buf, size_t size)
103+
{
104+
_modem.beginPacket();
105+
_modem.write(buf, size);
106+
int const err = _modem.endPacket(true);
107+
108+
if (err != size)
109+
{
110+
switch (err)
111+
{
112+
case LoRaCommunicationError::LORA_ERROR_ACK_NOT_RECEIVED: Debug.print(DBG_ERROR, "Message ack was not received, the message could not be delivered"); break;
113+
case LoRaCommunicationError::LORA_ERROR_GENERIC: Debug.print(DBG_ERROR, "LoRa generic error (LORA_ERROR)"); break;
114+
case LoRaCommunicationError::LORA_ERROR_WRONG_PARAM: Debug.print(DBG_ERROR, "LoRa malformed param error (LORA_ERROR_PARAM"); break;
115+
case LoRaCommunicationError::LORA_ERROR_COMMUNICATION_BUSY: Debug.print(DBG_ERROR, "LoRa chip is busy (LORA_ERROR_BUSY)"); break;
116+
case LoRaCommunicationError::LORA_ERROR_MESSAGE_OVERFLOW: Debug.print(DBG_ERROR, "LoRa chip overflow error (LORA_ERROR_OVERFLOW)"); break;
117+
case LoRaCommunicationError::LORA_ERROR_NO_NETWORK_AVAILABLE: Debug.print(DBG_ERROR, "LoRa no network error (LORA_ERROR_NO_NETWORK)"); break;
118+
case LoRaCommunicationError::LORA_ERROR_RX_PACKET: Debug.print(DBG_ERROR, "LoRa rx error (LORA_ERROR_RX)"); break;
119+
case LoRaCommunicationError::LORA_ERROR_REASON_UNKNOWN: Debug.print(DBG_ERROR, "LoRa unknown error (LORA_ERROR_UNKNOWN)"); break;
120+
case LoRaCommunicationError::LORA_ERROR_MAX_PACKET_SIZE: Debug.print(DBG_ERROR, "Message length is bigger than max LoRa packet!"); break;
121+
}
122+
}
123+
else
124+
{
125+
Debug.print(DBG_INFO, "Message sent correctly!");
126+
}
127+
return err;
128+
}
129+
130+
int LoRaConnectionHandler::read()
131+
{
132+
return _modem.read();
133+
}
134+
135+
bool LoRaConnectionHandler::available()
136+
{
137+
return _modem.available();
138+
}
139+
134140
void LoRaConnectionHandler::connect()
135141
{
136142
if (netConnectionState != NetworkConnectionState::INIT && netConnectionState != NetworkConnectionState::CONNECTING)
@@ -148,13 +154,15 @@ void LoRaConnectionHandler::disconnect()
148154
PRIVATE MEMBER FUNCTIONS
149155
******************************************************************************/
150156

151-
NetworkConnectionState LoRaConnectionHandler::update_handleInit() {
157+
NetworkConnectionState LoRaConnectionHandler::update_handleInit()
158+
{
152159
Debug.print(DBG_VERBOSE, "::INIT");
153-
if (!_modem.begin(_band)) {
160+
if (!_modem.begin(_band))
161+
{
154162
Debug.print(DBG_VERBOSE, "Failed to start module");
155163
execCallback(NetworkConnectionEvent::ERROR, 0);
156164
Debug.print(DBG_ERROR, "Something went wrong; are you indoor? Move near a window, then reset and retry.");
157-
};
165+
}
158166
//A delay is required between _modem.begin(band) and _modem.joinOTAA(appeui, appkey) in order to let the chip to be correctly initialized before the connection attempt
159167
delay(100);
160168
_modem.configureClass(_device_class);
@@ -163,10 +171,12 @@ NetworkConnectionState LoRaConnectionHandler::update_handleInit() {
163171
return NetworkConnectionState::CONNECTING;
164172
}
165173

166-
NetworkConnectionState LoRaConnectionHandler::update_handleConnecting() {
174+
NetworkConnectionState LoRaConnectionHandler::update_handleConnecting()
175+
{
167176
Debug.print(DBG_VERBOSE, "::CONNECTING");
168177
bool const network_status = _modem.joinOTAA(_appeui, _appkey);
169-
if (network_status != true) {
178+
if (network_status != true)
179+
{
170180
execCallback(NetworkConnectionEvent::ERROR, 0);
171181
Debug.print(DBG_ERROR, "Something went wrong; are you indoor? Move near a window, then reset and retry.");
172182
return NetworkConnectionState::ERROR;
@@ -177,39 +187,45 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnecting() {
177187
return NetworkConnectionState::CONNECTED;
178188
}
179189

180-
NetworkConnectionState LoRaConnectionHandler::update_handleConnected() {
181-
190+
NetworkConnectionState LoRaConnectionHandler::update_handleConnected()
191+
{
182192
bool const network_status = _modem.connected();
183193
Debug.print(DBG_VERBOSE, "Connection state: %d", network_status);
184194
if (network_status != true) {
185195
execCallback(NetworkConnectionEvent::DISCONNECTED, 0);
186196

187197
Debug.print(DBG_ERROR, "Connection to the network lost.");
188-
if (_keep_alive) {
198+
if (_keep_alive)
199+
{
189200
Debug.print(DBG_ERROR, "Attempting reconnection");
190201
}
191202
return NetworkConnectionState::DISCONNECTED;
192203
}
193204
Debug.print(DBG_VERBOSE, "Connected to the network");
194-
195205
return NetworkConnectionState::CONNECTED;
196206
}
197207

198-
NetworkConnectionState LoRaConnectionHandler::update_handleDisconnecting() {
208+
NetworkConnectionState LoRaConnectionHandler::update_handleDisconnecting()
209+
{
199210
execCallback(NetworkConnectionEvent::DISCONNECTED, 0);
200211

201212
Debug.print(DBG_ERROR, "Connection to the network lost.");
202-
if (_keep_alive) {
213+
if (_keep_alive)
214+
{
203215
Debug.print(DBG_ERROR, "Attempting reconnection");
204216
}
205217
return NetworkConnectionState::DISCONNECTED;
206218
}
207219

208-
NetworkConnectionState LoRaConnectionHandler::update_handleDisconnected() {
209-
if (_keep_alive) {
220+
NetworkConnectionState LoRaConnectionHandler::update_handleDisconnected()
221+
{
222+
if (_keep_alive)
223+
{
210224
Debug.print(DBG_VERBOSE, "CHANGING STATE TO ::INIT");
211225
return NetworkConnectionState::INIT;
212-
} else {
226+
}
227+
else
228+
{
213229
Debug.print(DBG_VERBOSE, "Connection to the network terminated");
214230
return NetworkConnectionState::CLOSED;
215231
}

‎src/Arduino_LoRaConnectionHandler.h‎

Lines changed: 5 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -24,45 +24,26 @@
2424

2525
#include "Arduino_ConnectionHandler.h"
2626

27-
typedef enum {
28-
LORA_ERROR_ACK_NOT_RECEIVED = -1,
29-
LORA_ERROR_GENERIC = -2,
30-
LORA_ERROR_WRONG_PARAM = -3,
31-
LORA_ERROR_COMMUNICATION_BUSY = -4,
32-
LORA_ERROR_MESSAGE_OVERFLOW = -5,
33-
LORA_ERROR_NO_NETWORK_AVAILABLE = -6,
34-
LORA_ERROR_RX_PACKET = -7,
35-
LORA_ERROR_REASON_UNKNOWN = -8,
36-
LORA_ERROR_MAX_PACKET_SIZE = -20
37-
} LoRaCommunicationError;
38-
3927
/******************************************************************************
4028
CLASS DECLARATION
4129
******************************************************************************/
4230

43-
class LoRaConnectionHandler : public ConnectionHandler {
31+
class LoRaConnectionHandler : public ConnectionHandler
32+
{
4433
public:
34+
4535
LoRaConnectionHandler(char const * appeui, char const * appkey, _lora_band const band = _lora_band::EU868, _lora_class const device_class = _lora_class::CLASS_A);
4636

47-
virtual NetworkConnectionState check();
4837

38+
virtual NetworkConnectionState check();
4939
virtual int write(const uint8_t *buf, size_t size);
5040
virtual int read();
5141
virtual bool available();
52-
5342
virtual void disconnect();
5443
virtual void connect();
5544

56-
private:
5745

58-
const int CHECK_INTERVAL_IDLE = 100;
59-
const int CHECK_INTERVAL_INIT = 100;
60-
const int CHECK_INTERVAL_CONNECTING = 500;
61-
const int CHECK_INTERVAL_CONNECTED = 10000;
62-
const int CHECK_INTERVAL_RETRYING = 30000;
63-
const int CHECK_INTERVAL_DISCONNECTING = 500;
64-
const int CHECK_INTERVAL_DISCONNECTED = 1000;
65-
const int CHECK_INTERVAL_ERROR = 500;
46+
private:
6647

6748
char const * _appeui;
6849
char const * _appkey;
@@ -75,11 +56,8 @@ class LoRaConnectionHandler : public ConnectionHandler {
7556
NetworkConnectionState update_handleInit();
7657
NetworkConnectionState update_handleConnecting();
7758
NetworkConnectionState update_handleConnected();
78-
7959
NetworkConnectionState update_handleDisconnecting();
8060
NetworkConnectionState update_handleDisconnected();
81-
82-
8361
};
8462

8563
#endif /* ARDUINO_LORA_CONNECTION_HANDLER_H_ */

0 commit comments

Comments
 (0)