From 5f421cfcf2f650dc2195bcf62c8551dfa6e51692 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Mon, 9 Mar 2020 13:38:07 +0100 Subject: [PATCH 01/54] Marking 'addConnectCallback', 'addDisconnectCallback' and 'addErrorCallback' as deprecated since the function 'addCallback' is covering the functionality of all three functions --- src/Arduino_ConnectionHandler.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h index 55d2ae1a..85c4d465 100644 --- a/src/Arduino_ConnectionHandler.h +++ b/src/Arduino_ConnectionHandler.h @@ -157,9 +157,9 @@ class ConnectionHandler { virtual void connect() = 0; virtual void disconnect() = 0; void addCallback(NetworkConnectionEvent const event, OnNetworkEventCallback callback); - void addConnectCallback(OnNetworkEventCallback callback); - void addDisconnectCallback(OnNetworkEventCallback callback); - void addErrorCallback(OnNetworkEventCallback callback); + void addConnectCallback(OnNetworkEventCallback callback) __attribute__((deprecated)); + void addDisconnectCallback(OnNetworkEventCallback callback) __attribute__((deprecated)); + void addErrorCallback(OnNetworkEventCallback callback) __attribute__((deprecated)); protected: OnNetworkEventCallback _on_connect_event_callback = NULL, From a040439335621c92930b4425eda9048a2ccaa960 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Mon, 9 Mar 2020 13:54:56 +0100 Subject: [PATCH 02/54] Make function pointer containing connection handler event callbacks private and access them via one generalised execCallback function --- src/Arduino_ConnectionHandler.cpp | 17 +++++++++++++---- src/Arduino_ConnectionHandler.h | 10 ++++++---- src/Arduino_GSMConnectionHandler.cpp | 6 +++--- src/Arduino_LoRaConnectionHandler.cpp | 10 +++++----- src/Arduino_NBConnectionHandler.cpp | 6 +++--- src/Arduino_WiFiConnectionHandler.cpp | 6 +++--- 6 files changed, 33 insertions(+), 22 deletions(-) diff --git a/src/Arduino_ConnectionHandler.cpp b/src/Arduino_ConnectionHandler.cpp index cfc6b707..46157975 100644 --- a/src/Arduino_ConnectionHandler.cpp +++ b/src/Arduino_ConnectionHandler.cpp @@ -47,9 +47,18 @@ void ConnectionHandler::addErrorCallback(OnNetworkEventCallback callback) { _on_error_event_callback = callback; } -void ConnectionHandler::execNetworkEventCallback(OnNetworkEventCallback & callback, void * callback_arg) { - if (callback) { - (*callback)(callback_arg); +/****************************************************************************** + PRIVATE MEMBER FUNCTIONS + ******************************************************************************/ + +void ConnectionHandler::execCallback(NetworkConnectionEvent const event, void * callback_arg) { + switch (event) { + case NetworkConnectionEvent::CONNECTED: if(_on_connect_event_callback) _on_connect_event_callback (callback_arg); break; + case NetworkConnectionEvent::DISCONNECTED: if(_on_disconnect_event_callback) _on_disconnect_event_callback(callback_arg); break; + case NetworkConnectionEvent::ERROR: if(_on_error_event_callback) _on_error_event_callback (callback_arg); break; + case NetworkConnectionEvent::INIT: break; + case NetworkConnectionEvent::CONNECTING: break; + case NetworkConnectionEvent::DISCONNECTING: break; + case NetworkConnectionEvent::CLOSED: break; } } - diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h index 85c4d465..e929551b 100644 --- a/src/Arduino_ConnectionHandler.h +++ b/src/Arduino_ConnectionHandler.h @@ -162,15 +162,17 @@ class ConnectionHandler { void addErrorCallback(OnNetworkEventCallback callback) __attribute__((deprecated)); protected: - OnNetworkEventCallback _on_connect_event_callback = NULL, - _on_disconnect_event_callback = NULL, - _on_error_event_callback = NULL; unsigned long lastValidTimestamp = 0; /* UNUSED */ NetworkConnectionState netConnectionState = NetworkConnectionState::INIT; - static void execNetworkEventCallback(OnNetworkEventCallback & callback, void * callback_arg); + void execCallback(NetworkConnectionEvent const event, void * callback_arg); + + private: + OnNetworkEventCallback _on_connect_event_callback = NULL, + _on_disconnect_event_callback = NULL, + _on_error_event_callback = NULL; }; #if defined(BOARD_HAS_WIFI) diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index ceb14933..96e6bc90 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -151,7 +151,7 @@ void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newStat } break; case NetworkConnectionState::CONNECTED: { - execNetworkEventCallback(_on_connect_event_callback, 0); + execCallback(NetworkConnectionEvent::CONNECTED, 0); newInterval = CHECK_INTERVAL_CONNECTED; } break; @@ -164,7 +164,7 @@ void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newStat } case NetworkConnectionState::DISCONNECTED: { if (netConnectionState == NetworkConnectionState::CONNECTED) { - execNetworkEventCallback(_on_disconnect_event_callback, 0); + execCallback(NetworkConnectionEvent::DISCONNECTED, 0); Debug.print(DBG_ERROR, "Disconnected from Cellular Network"); Debug.print(DBG_ERROR, "Attempting reconnection"); if (keepAlive) { @@ -175,7 +175,7 @@ void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newStat } break; case NetworkConnectionState::ERROR: { - execNetworkEventCallback(_on_error_event_callback, 0); + execCallback(NetworkConnectionEvent::ERROR, 0); Debug.print(DBG_ERROR, "GPRS attach failed\n\rMake sure the antenna is connected and reset your board."); } break; diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp index 4919ce04..32cab126 100644 --- a/src/Arduino_LoRaConnectionHandler.cpp +++ b/src/Arduino_LoRaConnectionHandler.cpp @@ -133,7 +133,7 @@ NetworkConnectionState LoRaConnectionHandler::update_handleInit() { Debug.print(DBG_VERBOSE, "::INIT"); if (!modem.begin(band)) { Debug.print(DBG_VERBOSE, "Failed to start module"); - execNetworkEventCallback(_on_error_event_callback, 0); + execCallback(NetworkConnectionEvent::ERROR, 0); Debug.print(DBG_ERROR, "Something went wrong; are you indoor? Move near a window, then reset and retry."); }; //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 @@ -149,14 +149,14 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnecting() { Debug.print(DBG_VERBOSE, "::CONNECTING"); bool networkStatus = modem.joinOTAA(appeui, appkey); if (networkStatus != true) { - execNetworkEventCallback(_on_error_event_callback, 0); + execCallback(NetworkConnectionEvent::ERROR, 0); Debug.print(DBG_ERROR, "Something went wrong; are you indoor? Move near a window, then reset and retry."); return NetworkConnectionState::ERROR; } Debug.print(DBG_INFO, "Connected to the network"); connectionTickTimeInterval = CHECK_INTERVAL_CONNECTED; - execNetworkEventCallback(_on_connect_event_callback, 0); + execCallback(NetworkConnectionEvent::CONNECTED, 0); return NetworkConnectionState::CONNECTED; } @@ -165,7 +165,7 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnected() { bool networkStatus = modem.connected(); Debug.print(DBG_VERBOSE, "Connection state: %d", networkStatus); if (networkStatus != true) { - execNetworkEventCallback(_on_disconnect_event_callback, 0); + execCallback(NetworkConnectionEvent::DISCONNECTED, 0); Debug.print(DBG_ERROR, "Connection to the network lost."); if (keepAlive) { @@ -180,7 +180,7 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnected() { } NetworkConnectionState LoRaConnectionHandler::update_handleDisconnecting() { - execNetworkEventCallback(_on_disconnect_event_callback, 0); + execCallback(NetworkConnectionEvent::DISCONNECTED, 0); Debug.print(DBG_ERROR, "Connection to the network lost."); if (keepAlive) { diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp index 7e493617..01add19e 100644 --- a/src/Arduino_NBConnectionHandler.cpp +++ b/src/Arduino_NBConnectionHandler.cpp @@ -159,7 +159,7 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState } break; case NetworkConnectionState::CONNECTED: { - execNetworkEventCallback(_on_connect_event_callback, 0); + execCallback(NetworkConnectionEvent::CONNECTED, 0); newInterval = CHECK_INTERVAL_CONNECTED; } break; @@ -172,7 +172,7 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState } case NetworkConnectionState::DISCONNECTED: { if (netConnectionState == NetworkConnectionState::CONNECTED) { - execNetworkEventCallback(_on_disconnect_event_callback, 0); + execCallback(NetworkConnectionEvent::DISCONNECTED, 0); Debug.print(DBG_ERROR, "Disconnected from Cellular Network"); Debug.print(DBG_ERROR, "Attempting reconnection"); if (keepAlive) { @@ -183,7 +183,7 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState } break; case NetworkConnectionState::ERROR: { - execNetworkEventCallback(_on_error_event_callback, 0); + execCallback(NetworkConnectionEvent::ERROR, 0); Debug.print(DBG_ERROR, "GPRS attach failed\n\rMake sure the antenna is connected and reset your board."); } break; diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp index 7b5a5efe..44165b0d 100644 --- a/src/Arduino_WiFiConnectionHandler.cpp +++ b/src/Arduino_WiFiConnectionHandler.cpp @@ -96,7 +96,7 @@ NetworkConnectionState WiFiConnectionHandler::update_handleInit() { #ifndef BOARD_ESP8266 Debug.print(DBG_INFO, "WiFi.status(): %d", WiFi.status()); if (WiFi.status() == NETWORK_HARDWARE_ERROR) { - execNetworkEventCallback(_on_error_event_callback, 0); + execCallback(NetworkConnectionEvent::ERROR, 0); Debug.print(DBG_ERROR, "WiFi Hardware failure.\nMake sure you are using a WiFi enabled board/shield."); Debug.print(DBG_ERROR, "Then reset and retry."); return NetworkConnectionState::ERROR; @@ -138,7 +138,7 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnecting() { } else { Debug.print(DBG_INFO, "Connected to \"%s\"", ssid); - execNetworkEventCallback(_on_connect_event_callback, 0); + execCallback(NetworkConnectionEvent::CONNECTED, 0); connectionTickTimeInterval = CHECK_INTERVAL_CONNECTED; return NetworkConnectionState::GETTIME; } @@ -149,7 +149,7 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnected() { Debug.print(DBG_VERBOSE, "WiFi.status(): %d", WiFi.status()); if (WiFi.status() != WL_CONNECTED) { - execNetworkEventCallback(_on_disconnect_event_callback, 0); + execCallback(NetworkConnectionEvent::DISCONNECTED, 0); Debug.print(DBG_VERBOSE, "WiFi.status(): %d", WiFi.status()); Debug.print(DBG_ERROR, "Connection to \"%s\" lost.", ssid); From fc61661b0fd4d427d12021ac0f6ae9fa2184a7a3 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Mon, 9 Mar 2020 14:05:29 +0100 Subject: [PATCH 03/54] Removing unused member variable 'lastValidTimestamp' --- src/Arduino_ConnectionHandler.h | 1 - 1 file changed, 1 deletion(-) diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h index e929551b..aee6f3c2 100644 --- a/src/Arduino_ConnectionHandler.h +++ b/src/Arduino_ConnectionHandler.h @@ -163,7 +163,6 @@ class ConnectionHandler { protected: - unsigned long lastValidTimestamp = 0; /* UNUSED */ NetworkConnectionState netConnectionState = NetworkConnectionState::INIT; void execCallback(NetworkConnectionEvent const event, void * callback_arg); From 07d54b5c2c48bf9ebb1c4c0bc2aecf5c9ec21991 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Mon, 9 Mar 2020 14:10:24 +0100 Subject: [PATCH 04/54] Removing typedef no longer required due to merging https://github.com/arduino-libraries/ArduinoIoTCloud/pull/98 --- src/Arduino_GSMConnectionHandler.h | 2 -- src/Arduino_LoRaConnectionHandler.h | 2 -- src/Arduino_NBConnectionHandler.h | 2 -- src/Arduino_WiFiConnectionHandler.h | 2 -- 4 files changed, 8 deletions(-) diff --git a/src/Arduino_GSMConnectionHandler.h b/src/Arduino_GSMConnectionHandler.h index f4c18ad1..9357e9e5 100644 --- a/src/Arduino_GSMConnectionHandler.h +++ b/src/Arduino_GSMConnectionHandler.h @@ -74,8 +74,6 @@ class GSMConnectionHandler : public ConnectionHandler { }; -typedef GSMConnectionHandler TcpIpConnectionHandler; - #endif /* #ifdef BOARD_HAS_GSM */ #endif /* #ifndef GSM_CONNECTION_MANAGER_H_ */ diff --git a/src/Arduino_LoRaConnectionHandler.h b/src/Arduino_LoRaConnectionHandler.h index ed885172..53a7b423 100644 --- a/src/Arduino_LoRaConnectionHandler.h +++ b/src/Arduino_LoRaConnectionHandler.h @@ -86,6 +86,4 @@ class LoRaConnectionHandler : public ConnectionHandler { }; -typedef LoRaConnectionHandler LPWANConnectionHandler; - #endif /* ARDUINO_LORA_CONNECTION_HANDLER_H_ */ diff --git a/src/Arduino_NBConnectionHandler.h b/src/Arduino_NBConnectionHandler.h index dfd1dae0..0811898f 100644 --- a/src/Arduino_NBConnectionHandler.h +++ b/src/Arduino_NBConnectionHandler.h @@ -75,8 +75,6 @@ class NBConnectionHandler : public ConnectionHandler { }; -typedef NBConnectionHandler TcpIpConnectionHandler; - #endif /* #ifdef BOARD_HAS_NB */ #endif /* #ifndef NB_CONNECTION_MANAGER_H_ */ diff --git a/src/Arduino_WiFiConnectionHandler.h b/src/Arduino_WiFiConnectionHandler.h index 08b40132..f36171f7 100644 --- a/src/Arduino_WiFiConnectionHandler.h +++ b/src/Arduino_WiFiConnectionHandler.h @@ -73,8 +73,6 @@ class WiFiConnectionHandler : public ConnectionHandler { }; -typedef WiFiConnectionHandler TcpIpConnectionHandler; - #endif /* #ifdef BOARD_HAS_WIFI */ #endif /* ARDUINO_WIFI_CONNECTION_HANDLER_H_ */ From 2aa54e1132f82af3c4810d77ed05755ba1519709 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Mon, 9 Mar 2020 14:27:18 +0100 Subject: [PATCH 05/54] Using table instead of individual constants for determining the check interval based on the current network connection state --- src/Arduino_ConnectionHandler.h | 18 +++++++++--------- src/Arduino_WiFiConnectionHandler.cpp | 22 +++++++++++++++------- src/Arduino_WiFiConnectionHandler.h | 7 ------- 3 files changed, 24 insertions(+), 23 deletions(-) diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h index aee6f3c2..9c84e846 100644 --- a/src/Arduino_ConnectionHandler.h +++ b/src/Arduino_ConnectionHandler.h @@ -113,15 +113,15 @@ TYPEDEFS ******************************************************************************/ -enum class NetworkConnectionState { - INIT, - CONNECTING, - CONNECTED, - GETTIME, - DISCONNECTING, - DISCONNECTED, - CLOSED, - ERROR +enum class NetworkConnectionState : unsigned int { + INIT = 0, + CONNECTING = 1, + CONNECTED = 2, + GETTIME = 3, + DISCONNECTING = 4, + DISCONNECTED = 5, + CLOSED = 6, + ERROR = 7 }; enum class NetworkConnectionEvent { diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp index 44165b0d..131e994b 100644 --- a/src/Arduino_WiFiConnectionHandler.cpp +++ b/src/Arduino_WiFiConnectionHandler.cpp @@ -23,6 +23,18 @@ #ifdef BOARD_HAS_WIFI /* Only compile if the board has WiFi */ +static unsigned int const CHECK_INTERVAL_TABLE[] = +{ + /* INIT */ 100, + /* CONNECTING */ 500, + /* CONNECTED */ 10000, + /* GETTIME */ 100, + /* DISCONNECTING */ 100, + /* DISCONNECTED */ 1000, + /* CLOSED */ 1000, + /* ERROR */ 1000 +}; + /****************************************************************************** CTOR/DTOR ******************************************************************************/ @@ -31,7 +43,6 @@ WiFiConnectionHandler::WiFiConnectionHandler(const char *_ssid, const char *_pas ssid(_ssid), pass(_pass), lastConnectionTickTime(millis()), - connectionTickTimeInterval(CHECK_INTERVAL_IDLE), keepAlive(_keepAlive) { } @@ -53,6 +64,8 @@ unsigned long WiFiConnectionHandler::getTime() { NetworkConnectionState WiFiConnectionHandler::check() { unsigned long const now = millis(); + unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(netConnectionState)]; + if((now - lastConnectionTickTime) > connectionTickTimeInterval) { lastConnectionTickTime = now; @@ -81,7 +94,6 @@ void WiFiConnectionHandler::connect() { return; } keepAlive = true; - connectionTickTimeInterval = CHECK_INTERVAL_INIT; netConnectionState = NetworkConnectionState::INIT; } @@ -117,7 +129,6 @@ NetworkConnectionState WiFiConnectionHandler::update_handleInit() { delay(1000); #endif /* ifndef BOARD_ESP8266 */ - connectionTickTimeInterval = CHECK_INTERVAL_CONNECTING; return NetworkConnectionState::CONNECTING; } @@ -133,13 +144,12 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnecting() { Debug.print(DBG_VERBOSE, "WiFi.status(): %d", WiFi.status()); if (WiFi.status() != NETWORK_CONNECTED) { Debug.print(DBG_ERROR, "Connection to \"%s\" failed", ssid); - Debug.print(DBG_INFO, "Retrying in \"%d\" milliseconds", connectionTickTimeInterval); + Debug.print(DBG_INFO, "Retrying in \"%d\" milliseconds", CHECK_INTERVAL_TABLE[static_cast(NetworkConnectionState::CONNECTING)]); return NetworkConnectionState::CONNECTING; } else { Debug.print(DBG_INFO, "Connected to \"%s\"", ssid); execCallback(NetworkConnectionEvent::CONNECTED, 0); - connectionTickTimeInterval = CHECK_INTERVAL_CONNECTED; return NetworkConnectionState::GETTIME; } } @@ -158,7 +168,6 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnected() { Debug.print(DBG_ERROR, "Attempting reconnection"); } - connectionTickTimeInterval = CHECK_INTERVAL_DISCONNECTED; return NetworkConnectionState::DISCONNECTED; } Debug.print(DBG_VERBOSE, "Connected to \"%s\"", ssid); @@ -184,7 +193,6 @@ NetworkConnectionState WiFiConnectionHandler::update_handleDisconnected() { WiFi.end(); #endif /* ifndef BOARD_ESP8266 */ if (keepAlive) { - connectionTickTimeInterval = CHECK_INTERVAL_INIT; return NetworkConnectionState::INIT; } else { diff --git a/src/Arduino_WiFiConnectionHandler.h b/src/Arduino_WiFiConnectionHandler.h index f36171f7..dbf5a56e 100644 --- a/src/Arduino_WiFiConnectionHandler.h +++ b/src/Arduino_WiFiConnectionHandler.h @@ -50,17 +50,10 @@ class WiFiConnectionHandler : public ConnectionHandler { private: - const int CHECK_INTERVAL_IDLE = 100; - const int CHECK_INTERVAL_INIT = 100; - const int CHECK_INTERVAL_CONNECTING = 500; - const int CHECK_INTERVAL_CONNECTED = 10000; - const int CHECK_INTERVAL_DISCONNECTED = 1000; - const char *ssid, *pass; unsigned long lastConnectionTickTime; WiFiClient wifiClient; - int connectionTickTimeInterval; bool keepAlive; From ed814145848aacba2851fde9164a11120c8a7520 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Mon, 9 Mar 2020 14:37:27 +0100 Subject: [PATCH 06/54] Rearranging member variables to provide an identical code look and feel all over the code --- src/Arduino_WiFiConnectionHandler.cpp | 39 ++++++++++++++------------- src/Arduino_WiFiConnectionHandler.h | 23 +++++++--------- 2 files changed, 29 insertions(+), 33 deletions(-) diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp index 131e994b..811a19f1 100644 --- a/src/Arduino_WiFiConnectionHandler.cpp +++ b/src/Arduino_WiFiConnectionHandler.cpp @@ -39,11 +39,13 @@ static unsigned int const CHECK_INTERVAL_TABLE[] = CTOR/DTOR ******************************************************************************/ -WiFiConnectionHandler::WiFiConnectionHandler(const char *_ssid, const char *_pass, bool _keepAlive) : - ssid(_ssid), - pass(_pass), - lastConnectionTickTime(millis()), - keepAlive(_keepAlive) { +WiFiConnectionHandler::WiFiConnectionHandler(char const * ssid, char const * pass, bool const keep_alive) +: _ssid{ssid} +, _pass{pass} +, _lastConnectionTickTime{millis()} +, _keep_alive{keep_alive} +{ + } /****************************************************************************** @@ -66,9 +68,9 @@ NetworkConnectionState WiFiConnectionHandler::check() { unsigned long const now = millis(); unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(netConnectionState)]; - if((now - lastConnectionTickTime) > connectionTickTimeInterval) + if((now - _lastConnectionTickTime) > connectionTickTimeInterval) { - lastConnectionTickTime = now; + _lastConnectionTickTime = now; switch (netConnectionState) { case NetworkConnectionState::INIT: netConnectionState = update_handleInit (); break; @@ -93,12 +95,12 @@ void WiFiConnectionHandler::connect() { if (netConnectionState == NetworkConnectionState::INIT || netConnectionState == NetworkConnectionState::CONNECTING) { return; } - keepAlive = true; + _keep_alive = true; netConnectionState = NetworkConnectionState::INIT; } void WiFiConnectionHandler::disconnect() { - keepAlive = false; + _keep_alive = false; netConnectionState = NetworkConnectionState::DISCONNECTING; } @@ -125,7 +127,7 @@ NetworkConnectionState WiFiConnectionHandler::update_handleInit() { Debug.print(DBG_ERROR, "WiFi status ESP: %d", WiFi.status()); WiFi.disconnect(); delay(300); - WiFi.begin(ssid, pass); + WiFi.begin(_ssid, _pass); delay(1000); #endif /* ifndef BOARD_ESP8266 */ @@ -137,18 +139,18 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnecting() { #ifndef BOARD_ESP8266 if (WiFi.status() != WL_CONNECTED) { - WiFi.begin(ssid, pass); + WiFi.begin(_ssid, _pass); } #endif /* ifndef BOARD_ESP8266 */ Debug.print(DBG_VERBOSE, "WiFi.status(): %d", WiFi.status()); if (WiFi.status() != NETWORK_CONNECTED) { - Debug.print(DBG_ERROR, "Connection to \"%s\" failed", ssid); + Debug.print(DBG_ERROR, "Connection to \"%s\" failed", _ssid); Debug.print(DBG_INFO, "Retrying in \"%d\" milliseconds", CHECK_INTERVAL_TABLE[static_cast(NetworkConnectionState::CONNECTING)]); return NetworkConnectionState::CONNECTING; } else { - Debug.print(DBG_INFO, "Connected to \"%s\"", ssid); + Debug.print(DBG_INFO, "Connected to \"%s\"", _ssid); execCallback(NetworkConnectionEvent::CONNECTED, 0); return NetworkConnectionState::GETTIME; } @@ -162,15 +164,14 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnected() { execCallback(NetworkConnectionEvent::DISCONNECTED, 0); Debug.print(DBG_VERBOSE, "WiFi.status(): %d", WiFi.status()); - Debug.print(DBG_ERROR, "Connection to \"%s\" lost.", ssid); + Debug.print(DBG_ERROR, "Connection to \"%s\" lost.", _ssid); - if (keepAlive) { + if (_keep_alive) { Debug.print(DBG_ERROR, "Attempting reconnection"); } return NetworkConnectionState::DISCONNECTED; } - Debug.print(DBG_VERBOSE, "Connected to \"%s\"", ssid); return NetworkConnectionState::CONNECTED; } @@ -183,7 +184,7 @@ NetworkConnectionState WiFiConnectionHandler::update_handleGetTime() { } NetworkConnectionState WiFiConnectionHandler::update_handleDisconnecting() { - Debug.print(DBG_VERBOSE, "Disconnecting from \"%s\"", ssid); + Debug.print(DBG_VERBOSE, "Disconnecting from \"%s\"", _ssid); WiFi.disconnect(); return NetworkConnectionState::DISCONNECTED; } @@ -192,11 +193,11 @@ NetworkConnectionState WiFiConnectionHandler::update_handleDisconnected() { #ifndef BOARD_ESP8266 WiFi.end(); #endif /* ifndef BOARD_ESP8266 */ - if (keepAlive) { + if (_keep_alive) { return NetworkConnectionState::INIT; } else { - Debug.print(DBG_VERBOSE, "Connection to \"%s\" closed", ssid); + Debug.print(DBG_VERBOSE, "Connection to \"%s\" closed", _ssid); return NetworkConnectionState::CLOSED; } } diff --git a/src/Arduino_WiFiConnectionHandler.h b/src/Arduino_WiFiConnectionHandler.h index dbf5a56e..e0907aec 100644 --- a/src/Arduino_WiFiConnectionHandler.h +++ b/src/Arduino_WiFiConnectionHandler.h @@ -32,30 +32,25 @@ class WiFiConnectionHandler : public ConnectionHandler { public: - WiFiConnectionHandler(const char *_ssid, const char *_pass, bool _keepAlive = true); + WiFiConnectionHandler(char const * ssid, char const * pass, bool const keep_alive = true); virtual void init(); virtual unsigned long getTime(); virtual NetworkConnectionState check(); - virtual Client &getClient() { - return wifiClient; - }; - virtual UDP &getUDP() { - return udp; - }; + virtual Client & getClient() { return _wifi_client; } + virtual UDP & getUDP() { return _wifi_udp; } virtual void disconnect(); virtual void connect(); - WiFiUDP udp; - private: - const char *ssid, *pass; - unsigned long lastConnectionTickTime; - - WiFiClient wifiClient; + char const * _ssid; + char const * _pass; + bool _keep_alive; + unsigned long _lastConnectionTickTime; - bool keepAlive; + WiFiUDP _wifi_udp; + WiFiClient _wifi_client; NetworkConnectionState update_handleInit (); NetworkConnectionState update_handleConnecting (); From 66263ba58ceef7a9c1925c19deaf91b323100932 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Mon, 9 Mar 2020 14:40:20 +0100 Subject: [PATCH 07/54] Eliminating unused method WiFiConnectionHandler::init since it's functionality is covered by update_handleInit --- src/Arduino_ConnectionHandler.h | 1 - src/Arduino_WiFiConnectionHandler.cpp | 3 --- src/Arduino_WiFiConnectionHandler.h | 1 - 3 files changed, 5 deletions(-) diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h index 9c84e846..2b9ba705 100644 --- a/src/Arduino_ConnectionHandler.h +++ b/src/Arduino_ConnectionHandler.h @@ -136,7 +136,6 @@ typedef void (*OnNetworkEventCallback)(void * /* arg */); class ConnectionHandler { public: - virtual void init() = 0; virtual NetworkConnectionState check() = 0; #if defined(BOARD_HAS_WIFI) || defined(BOARD_HAS_GSM) || defined(BOARD_HAS_NB) diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp index 811a19f1..f1e43056 100644 --- a/src/Arduino_WiFiConnectionHandler.cpp +++ b/src/Arduino_WiFiConnectionHandler.cpp @@ -52,9 +52,6 @@ WiFiConnectionHandler::WiFiConnectionHandler(char const * ssid, char const * pas PUBLIC MEMBER FUNCTIONS ******************************************************************************/ -void WiFiConnectionHandler::init() { -} - unsigned long WiFiConnectionHandler::getTime() { #if !defined(BOARD_ESP8266) return WiFi.getTime(); diff --git a/src/Arduino_WiFiConnectionHandler.h b/src/Arduino_WiFiConnectionHandler.h index e0907aec..8479a3b3 100644 --- a/src/Arduino_WiFiConnectionHandler.h +++ b/src/Arduino_WiFiConnectionHandler.h @@ -34,7 +34,6 @@ class WiFiConnectionHandler : public ConnectionHandler { public: WiFiConnectionHandler(char const * ssid, char const * pass, bool const keep_alive = true); - virtual void init(); virtual unsigned long getTime(); virtual NetworkConnectionState check(); virtual Client & getClient() { return _wifi_client; } From 1ddba2b480a20039a42346420616ff3979449ea3 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Mon, 9 Mar 2020 14:41:44 +0100 Subject: [PATCH 08/54] Adding keyword override to allow the determine to compiler if the methods actually overwrite another virtual method from the base class --- src/Arduino_WiFiConnectionHandler.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/Arduino_WiFiConnectionHandler.h b/src/Arduino_WiFiConnectionHandler.h index 8479a3b3..88f13751 100644 --- a/src/Arduino_WiFiConnectionHandler.h +++ b/src/Arduino_WiFiConnectionHandler.h @@ -34,12 +34,12 @@ class WiFiConnectionHandler : public ConnectionHandler { public: WiFiConnectionHandler(char const * ssid, char const * pass, bool const keep_alive = true); - virtual unsigned long getTime(); - virtual NetworkConnectionState check(); - virtual Client & getClient() { return _wifi_client; } - virtual UDP & getUDP() { return _wifi_udp; } - virtual void disconnect(); - virtual void connect(); + virtual unsigned long getTime() override; + virtual NetworkConnectionState check() override; + virtual Client & getClient() override{ return _wifi_client; } + virtual UDP & getUDP() override { return _wifi_udp; } + virtual void disconnect() override; + virtual void connect() override; private: From 617c08f1a0f50ff10b99608063680f16f8fede19 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 07:58:19 +0100 Subject: [PATCH 09/54] Move functionality of init() into update_handleInit() which also performs the state change --- src/Arduino_GSMConnectionHandler.cpp | 34 +++++++++++++++------------- src/Arduino_GSMConnectionHandler.h | 3 ++- 2 files changed, 20 insertions(+), 17 deletions(-) diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index 96e6bc90..8cd254eb 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -56,17 +56,6 @@ GSMConnectionHandler::GSMConnectionHandler(const char *pin, const char *apn, con PUBLIC MEMBER FUNCTIONS ******************************************************************************/ -void GSMConnectionHandler::init() { - char msgBuffer[120]; - if (gsmAccess.begin(pin) == GSM_READY) { - Debug.print(DBG_INFO, "SIM card ok"); - gsmAccess.setTimeout(CHECK_INTERVAL_RETRYING); - changeConnectionState(NetworkConnectionState::CONNECTING); - } else { - Debug.print(DBG_ERROR, "SIM not present or wrong PIN"); - } -} - unsigned long GSMConnectionHandler::getTime() { return gsmAccess.getTime(); } @@ -75,11 +64,9 @@ NetworkConnectionState GSMConnectionHandler::check() { unsigned long const now = millis(); int gsmAccessAlive; if (now - lastConnectionTickTime > connectionTickTimeInterval) { - switch (netConnectionState) { - case NetworkConnectionState::INIT: { - init(); - } - break; + switch (netConnectionState) + { + case NetworkConnectionState::INIT: netConnectionState = update_handleInit(); break; case NetworkConnectionState::CONNECTING: { // NOTE: Blocking Call when 4th parameter == true @@ -138,6 +125,21 @@ NetworkConnectionState GSMConnectionHandler::check() { PRIVATE MEMBER FUNCTIONS ******************************************************************************/ +NetworkConnectionState GSMConnectionHandler::update_handleInit() +{ + if (gsmAccess.begin(pin) == GSM_READY) + { + Debug.print(DBG_INFO, "SIM card ok"); + gsmAccess.setTimeout(CHECK_INTERVAL_RETRYING); + return NetworkConnectionState::CONNECTING; + } + else + { + Debug.print(DBG_ERROR, "SIM not present or wrong PIN"); + return NetworkConnectionState::ERROR; + } +} + void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newState) { int newInterval = CHECK_INTERVAL_IDLE; switch (_newState) { diff --git a/src/Arduino_GSMConnectionHandler.h b/src/Arduino_GSMConnectionHandler.h index 9357e9e5..9113cd3b 100644 --- a/src/Arduino_GSMConnectionHandler.h +++ b/src/Arduino_GSMConnectionHandler.h @@ -35,7 +35,6 @@ class GSMConnectionHandler : public ConnectionHandler { public: GSMConnectionHandler(const char *pin, const char *apn, const char *login, const char *pass, const bool keepAlive = true); - virtual void init(); virtual unsigned long getTime(); virtual NetworkConnectionState check(); virtual Client &getClient() { @@ -72,6 +71,8 @@ class GSMConnectionHandler : public ConnectionHandler { bool keepAlive; + NetworkConnectionState update_handleInit (); + }; #endif /* #ifdef BOARD_HAS_GSM */ From 07c2ccf68315a9bf3b121f9e60d43c4a18a252c1 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 08:05:09 +0100 Subject: [PATCH 10/54] Extracting functionality of state CONNECTING into function handle_updateConnecting() --- src/Arduino_GSMConnectionHandler.cpp | 56 ++++++++++++++-------------- src/Arduino_GSMConnectionHandler.h | 1 + 2 files changed, 30 insertions(+), 27 deletions(-) diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index 8cd254eb..4ffb4a57 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -66,33 +66,8 @@ NetworkConnectionState GSMConnectionHandler::check() { if (now - lastConnectionTickTime > connectionTickTimeInterval) { switch (netConnectionState) { - case NetworkConnectionState::INIT: netConnectionState = update_handleInit(); break; - - case NetworkConnectionState::CONNECTING: { - // NOTE: Blocking Call when 4th parameter == true - GSM3_NetworkStatus_t networkStatus; - networkStatus = gprs.attachGPRS(apn, login, pass, true); - Debug.print(DBG_DEBUG, "GPRS.attachGPRS(): %d", networkStatus); - if (networkStatus == GSM3_NetworkStatus_t::ERROR) { - // NO FURTHER ACTION WILL FOLLOW THIS - changeConnectionState(NetworkConnectionState::ERROR); - return netConnectionState; - } - Debug.print(DBG_INFO, "Sending PING to outer space..."); - int pingResult; - pingResult = gprs.ping("time.arduino.cc"); - Debug.print(DBG_INFO, "GSM.ping(): %d", pingResult); - if (pingResult < 0) { - Debug.print(DBG_ERROR, "PING failed"); - Debug.print(DBG_INFO, "Retrying in \"%d\" milliseconds", connectionTickTimeInterval); - return netConnectionState; - } else { - Debug.print(DBG_INFO, "Connected to GPRS Network"); - changeConnectionState(NetworkConnectionState::CONNECTED); - return netConnectionState; - } - } - break; + case NetworkConnectionState::INIT: netConnectionState = update_handleInit(); break; + case NetworkConnectionState::CONNECTING: netConnectionState = update_handleConnecting(); break; case NetworkConnectionState::CONNECTED: { gsmAccessAlive = gsmAccess.isAccessAlive(); Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", gsmAccessAlive); @@ -136,8 +111,35 @@ NetworkConnectionState GSMConnectionHandler::update_handleInit() else { Debug.print(DBG_ERROR, "SIM not present or wrong PIN"); + execCallback(NetworkConnectionEvent::ERROR, 0); + return NetworkConnectionState::ERROR; + } +} + +NetworkConnectionState GSMConnectionHandler::update_handleConnecting() +{ + GSM3_NetworkStatus_t const network_status = gprs.attachGPRS(apn, login, pass, true); + Debug.print(DBG_DEBUG, "GPRS.attachGPRS(): %d", network_status); + if (network_status == GSM3_NetworkStatus_t::ERROR) + { + execCallback(NetworkConnectionEvent::ERROR, 0); return NetworkConnectionState::ERROR; } + Debug.print(DBG_INFO, "Sending PING to outer space..."); + int const ping_result = gprs.ping("time.arduino.cc"); + Debug.print(DBG_INFO, "GPRS.ping(): %d", ping_result); + if (ping_result < 0) + { + Debug.print(DBG_ERROR, "PING failed"); + Debug.print(DBG_INFO, "Retrying in \"%d\" milliseconds", connectionTickTimeInterval); + return NetworkConnectionState::CONNECTING; + } + else + { + Debug.print(DBG_INFO, "Connected to GPRS Network"); + execCallback(NetworkConnectionEvent::CONNECTED, 0); + return NetworkConnectionState::CONNECTED; + } } void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newState) { diff --git a/src/Arduino_GSMConnectionHandler.h b/src/Arduino_GSMConnectionHandler.h index 9113cd3b..0be31716 100644 --- a/src/Arduino_GSMConnectionHandler.h +++ b/src/Arduino_GSMConnectionHandler.h @@ -72,6 +72,7 @@ class GSMConnectionHandler : public ConnectionHandler { bool keepAlive; NetworkConnectionState update_handleInit (); + NetworkConnectionState update_handleConnecting (); }; From 8e2af82df6091b90129eee8804aab2a3f60beb7f Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 08:08:48 +0100 Subject: [PATCH 11/54] Extracting functionality of state CONNECTED into function handle_updateConnected() --- src/Arduino_GSMConnectionHandler.cpp | 25 ++++++++++++++----------- src/Arduino_GSMConnectionHandler.h | 1 + 2 files changed, 15 insertions(+), 11 deletions(-) diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index 4ffb4a57..4e48365f 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -62,22 +62,12 @@ unsigned long GSMConnectionHandler::getTime() { NetworkConnectionState GSMConnectionHandler::check() { unsigned long const now = millis(); - int gsmAccessAlive; if (now - lastConnectionTickTime > connectionTickTimeInterval) { switch (netConnectionState) { case NetworkConnectionState::INIT: netConnectionState = update_handleInit(); break; case NetworkConnectionState::CONNECTING: netConnectionState = update_handleConnecting(); break; - case NetworkConnectionState::CONNECTED: { - gsmAccessAlive = gsmAccess.isAccessAlive(); - Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", gsmAccessAlive); - if (gsmAccessAlive != 1) { - changeConnectionState(NetworkConnectionState::DISCONNECTED); - return netConnectionState; - } - Debug.print(DBG_VERBOSE, "Connected to Cellular Network"); - } - break; + case NetworkConnectionState::CONNECTED: netConnectionState = update_handleConnected(); break; case NetworkConnectionState::DISCONNECTED: { //gprs.detachGPRS(); if (keepAlive) { @@ -142,6 +132,19 @@ NetworkConnectionState GSMConnectionHandler::update_handleConnecting() } } +NetworkConnectionState GSMConnectionHandler::update_handleConnected() +{ + int const is_gsm_access_alive = gsmAccess.isAccessAlive(); + Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", is_gsm_access_alive); + if (is_gsm_access_alive != 1) + { + execCallback(NetworkConnectionEvent::DISCONNECTED, 0); + return NetworkConnectionState::DISCONNECTED; + } + Debug.print(DBG_VERBOSE, "Connected to Cellular Network"); + return NetworkConnectionState::CONNECTED; +} + void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newState) { int newInterval = CHECK_INTERVAL_IDLE; switch (_newState) { diff --git a/src/Arduino_GSMConnectionHandler.h b/src/Arduino_GSMConnectionHandler.h index 0be31716..9359e5eb 100644 --- a/src/Arduino_GSMConnectionHandler.h +++ b/src/Arduino_GSMConnectionHandler.h @@ -73,6 +73,7 @@ class GSMConnectionHandler : public ConnectionHandler { NetworkConnectionState update_handleInit (); NetworkConnectionState update_handleConnecting (); + NetworkConnectionState update_handleConnected (); }; From 5c56b61d9c7e2b0c91b192f2d790c32db06e7be5 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 08:15:15 +0100 Subject: [PATCH 12/54] Extracting functionality of state DISCONNECTING into function handle_updateDisconnecting() --- src/Arduino_GSMConnectionHandler.cpp | 14 +++++++++++--- src/Arduino_GSMConnectionHandler.h | 1 + 2 files changed, 12 insertions(+), 3 deletions(-) diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index 4e48365f..f71bd678 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -65,9 +65,11 @@ NetworkConnectionState GSMConnectionHandler::check() { if (now - lastConnectionTickTime > connectionTickTimeInterval) { switch (netConnectionState) { - case NetworkConnectionState::INIT: netConnectionState = update_handleInit(); break; - case NetworkConnectionState::CONNECTING: netConnectionState = update_handleConnecting(); break; - case NetworkConnectionState::CONNECTED: netConnectionState = update_handleConnected(); break; + case NetworkConnectionState::INIT: netConnectionState = update_handleInit(); break; + case NetworkConnectionState::CONNECTING: netConnectionState = update_handleConnecting(); break; + case NetworkConnectionState::CONNECTED: netConnectionState = update_handleConnected(); break; + case NetworkConnectionState::GETTIME: /* Unused */ break; + case NetworkConnectionState::DISCONNECTING: netConnectionState = update_handleDisconnecting(); break; case NetworkConnectionState::DISCONNECTED: { //gprs.detachGPRS(); if (keepAlive) { @@ -145,6 +147,12 @@ NetworkConnectionState GSMConnectionHandler::update_handleConnected() return NetworkConnectionState::CONNECTED; } +NetworkConnectionState GSMConnectionHandler::update_handleDisconnecting() +{ + execCallback(NetworkConnectionEvent::DISCONNECTED, 0); + return NetworkConnectionState::DISCONNECTED; +} + void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newState) { int newInterval = CHECK_INTERVAL_IDLE; switch (_newState) { diff --git a/src/Arduino_GSMConnectionHandler.h b/src/Arduino_GSMConnectionHandler.h index 9359e5eb..08471d3f 100644 --- a/src/Arduino_GSMConnectionHandler.h +++ b/src/Arduino_GSMConnectionHandler.h @@ -74,6 +74,7 @@ class GSMConnectionHandler : public ConnectionHandler { NetworkConnectionState update_handleInit (); NetworkConnectionState update_handleConnecting (); NetworkConnectionState update_handleConnected (); + NetworkConnectionState update_handleDisconnecting(); }; From 148945fb94de23dd240b824f40b043ecce01f00e Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 08:18:15 +0100 Subject: [PATCH 13/54] Extracting functionality of state DISCONNECTED into function handle_updateDisconnected() --- src/Arduino_GSMConnectionHandler.cpp | 25 ++++++++++++++----------- src/Arduino_GSMConnectionHandler.h | 1 + 2 files changed, 15 insertions(+), 11 deletions(-) diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index f71bd678..de32a631 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -70,17 +70,7 @@ NetworkConnectionState GSMConnectionHandler::check() { case NetworkConnectionState::CONNECTED: netConnectionState = update_handleConnected(); break; case NetworkConnectionState::GETTIME: /* Unused */ break; case NetworkConnectionState::DISCONNECTING: netConnectionState = update_handleDisconnecting(); break; - case NetworkConnectionState::DISCONNECTED: { - //gprs.detachGPRS(); - if (keepAlive) { - Debug.print(DBG_VERBOSE, "keep alive > INIT"); - changeConnectionState(NetworkConnectionState::INIT); - } else { - changeConnectionState(NetworkConnectionState::CLOSED); - } - //changeConnectionState(NetworkConnectionState::CONNECTING); - } - break; + case NetworkConnectionState::DISCONNECTED: netConnectionState = update_handleDisconnected(); break; } lastConnectionTickTime = now; } @@ -153,6 +143,19 @@ NetworkConnectionState GSMConnectionHandler::update_handleDisconnecting() return NetworkConnectionState::DISCONNECTED; } +NetworkConnectionState GSMConnectionHandler::update_handleDisconnected() +{ + if (keepAlive) + { + Debug.print(DBG_VERBOSE, "keep alive > INIT"); + return NetworkConnectionState::INIT; + } + else + { + return NetworkConnectionState::CLOSED; + } +} + void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newState) { int newInterval = CHECK_INTERVAL_IDLE; switch (_newState) { diff --git a/src/Arduino_GSMConnectionHandler.h b/src/Arduino_GSMConnectionHandler.h index 08471d3f..bca96b88 100644 --- a/src/Arduino_GSMConnectionHandler.h +++ b/src/Arduino_GSMConnectionHandler.h @@ -75,6 +75,7 @@ class GSMConnectionHandler : public ConnectionHandler { NetworkConnectionState update_handleConnecting (); NetworkConnectionState update_handleConnected (); NetworkConnectionState update_handleDisconnecting(); + NetworkConnectionState update_handleDisconnected (); }; From 96f6babf433e2af242dfa92be0c1421a5074186d Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 08:26:26 +0100 Subject: [PATCH 14/54] Restructuring member variables and adding missing states to state machine --- src/Arduino_GSMConnectionHandler.cpp | 42 +++++++++++++++------------- src/Arduino_GSMConnectionHandler.h | 27 ++++++++---------- src/Arduino_NBConnectionHandler.cpp | 6 ++-- src/Arduino_NBConnectionHandler.h | 6 ++-- 4 files changed, 41 insertions(+), 40 deletions(-) diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index de32a631..94be93c7 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -42,14 +42,16 @@ static const unsigned long NETWORK_CONNECTION_INTERVAL = 30000; CTOR/DTOR ******************************************************************************/ -GSMConnectionHandler::GSMConnectionHandler(const char *pin, const char *apn, const char *login, const char *pass, bool _keepAlive) : - pin(pin), - apn(apn), - login(login), - pass(pass), - lastConnectionTickTime(millis()), - connectionTickTimeInterval(CHECK_INTERVAL_IDLE), - keepAlive(_keepAlive) { +GSMConnectionHandler::GSMConnectionHandler(const char * pin, const char * apn, const char * login, const char * pass, bool const keep_alive) +: _pin(pin) +, _apn(apn) +, _login(login) +, _pass(pass) +, lastConnectionTickTime(millis()) +, connectionTickTimeInterval(CHECK_INTERVAL_IDLE) +, _keep_alive(keep_alive) +{ + } /****************************************************************************** @@ -57,7 +59,7 @@ GSMConnectionHandler::GSMConnectionHandler(const char *pin, const char *apn, con ******************************************************************************/ unsigned long GSMConnectionHandler::getTime() { - return gsmAccess.getTime(); + return _gsm.getTime(); } NetworkConnectionState GSMConnectionHandler::check() { @@ -71,6 +73,8 @@ NetworkConnectionState GSMConnectionHandler::check() { case NetworkConnectionState::GETTIME: /* Unused */ break; case NetworkConnectionState::DISCONNECTING: netConnectionState = update_handleDisconnecting(); break; case NetworkConnectionState::DISCONNECTED: netConnectionState = update_handleDisconnected(); break; + case NetworkConnectionState::ERROR: break; + case NetworkConnectionState::CLOSED: break; } lastConnectionTickTime = now; } @@ -84,10 +88,10 @@ NetworkConnectionState GSMConnectionHandler::check() { NetworkConnectionState GSMConnectionHandler::update_handleInit() { - if (gsmAccess.begin(pin) == GSM_READY) + if (_gsm.begin(_pin) == GSM_READY) { Debug.print(DBG_INFO, "SIM card ok"); - gsmAccess.setTimeout(CHECK_INTERVAL_RETRYING); + _gsm.setTimeout(CHECK_INTERVAL_RETRYING); return NetworkConnectionState::CONNECTING; } else @@ -100,7 +104,7 @@ NetworkConnectionState GSMConnectionHandler::update_handleInit() NetworkConnectionState GSMConnectionHandler::update_handleConnecting() { - GSM3_NetworkStatus_t const network_status = gprs.attachGPRS(apn, login, pass, true); + GSM3_NetworkStatus_t const network_status = _gprs.attachGPRS(_apn, _login, _pass, true); Debug.print(DBG_DEBUG, "GPRS.attachGPRS(): %d", network_status); if (network_status == GSM3_NetworkStatus_t::ERROR) { @@ -108,7 +112,7 @@ NetworkConnectionState GSMConnectionHandler::update_handleConnecting() return NetworkConnectionState::ERROR; } Debug.print(DBG_INFO, "Sending PING to outer space..."); - int const ping_result = gprs.ping("time.arduino.cc"); + int const ping_result = _gprs.ping("time.arduino.cc"); Debug.print(DBG_INFO, "GPRS.ping(): %d", ping_result); if (ping_result < 0) { @@ -126,7 +130,7 @@ NetworkConnectionState GSMConnectionHandler::update_handleConnecting() NetworkConnectionState GSMConnectionHandler::update_handleConnected() { - int const is_gsm_access_alive = gsmAccess.isAccessAlive(); + int const is_gsm_access_alive = _gsm.isAccessAlive(); Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", is_gsm_access_alive); if (is_gsm_access_alive != 1) { @@ -145,7 +149,7 @@ NetworkConnectionState GSMConnectionHandler::update_handleDisconnecting() NetworkConnectionState GSMConnectionHandler::update_handleDisconnected() { - if (keepAlive) + if (_keep_alive) { Debug.print(DBG_VERBOSE, "keep alive > INIT"); return NetworkConnectionState::INIT; @@ -178,14 +182,14 @@ void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newStat break; case NetworkConnectionState::DISCONNECTING: { Debug.print(DBG_VERBOSE, "Disconnecting from Cellular Network"); - gsmAccess.shutdown(); + _gsm.shutdown(); } case NetworkConnectionState::DISCONNECTED: { if (netConnectionState == NetworkConnectionState::CONNECTED) { execCallback(NetworkConnectionEvent::DISCONNECTED, 0); Debug.print(DBG_ERROR, "Disconnected from Cellular Network"); Debug.print(DBG_ERROR, "Attempting reconnection"); - if (keepAlive) { + if (_keep_alive) { Debug.print(DBG_ERROR, "Attempting reconnection"); } } @@ -208,7 +212,7 @@ void GSMConnectionHandler::connect() { if (netConnectionState == NetworkConnectionState::INIT || netConnectionState == NetworkConnectionState::CONNECTING) { return; } - keepAlive = true; + _keep_alive = true; changeConnectionState(NetworkConnectionState::INIT); } @@ -216,7 +220,7 @@ void GSMConnectionHandler::disconnect() { //WiFi.end(); changeConnectionState(NetworkConnectionState::DISCONNECTING); - keepAlive = false; + _keep_alive = false; } #endif /* #ifdef BOARD_HAS_GSM */ \ No newline at end of file diff --git a/src/Arduino_GSMConnectionHandler.h b/src/Arduino_GSMConnectionHandler.h index bca96b88..6c7da95f 100644 --- a/src/Arduino_GSMConnectionHandler.h +++ b/src/Arduino_GSMConnectionHandler.h @@ -33,22 +33,12 @@ class GSMConnectionHandler : public ConnectionHandler { public: - GSMConnectionHandler(const char *pin, const char *apn, const char *login, const char *pass, const bool keepAlive = true); + GSMConnectionHandler(const char * pin, const char * apn, const char * login, const char * pass, bool const keep_alive = true); virtual unsigned long getTime(); virtual NetworkConnectionState check(); - virtual Client &getClient() { - return networkClient; - }; - virtual UDP &getUDP() { - return udp; - }; - - GSMClient networkClient; - GSM gsmAccess; - GPRS gprs; - GSMUDP udp; - + virtual Client &getClient() { return _gsm_client; }; + virtual UDP &getUDP() { return _udp; }; virtual void disconnect(); virtual void connect(); @@ -64,12 +54,19 @@ class GSMConnectionHandler : public ConnectionHandler { const int CHECK_INTERVAL_DISCONNECTED = 1000; const int CHECK_INTERVAL_ERROR = 500; - const char *pin, *apn, *login, *pass; + const char * _pin; + const char * _apn; + const char * _login; + const char * _pass; unsigned long lastConnectionTickTime; int connectionTickTimeInterval; + GSM _gsm; + GPRS _gprs; + GSMUDP _udp; + GSMClient _gsm_client; - bool keepAlive; + bool _keep_alive; NetworkConnectionState update_handleInit (); NetworkConnectionState update_handleConnecting (); diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp index 01add19e..50500a3c 100644 --- a/src/Arduino_NBConnectionHandler.cpp +++ b/src/Arduino_NBConnectionHandler.cpp @@ -91,7 +91,7 @@ NetworkConnectionState NBConnectionHandler::check() { case NetworkConnectionState::CONNECTING: { // NOTE: Blocking Call when 4th parameter == true NB_NetworkStatus_t networkStatus; - networkStatus = gprs.attachGPRS(true); + networkStatus = _gprs.attachGPRS(true); Debug.print(DBG_DEBUG, "GPRS.attachGPRS(): %d", networkStatus); if (networkStatus == NB_NetworkStatus_t::ERROR) { // NO FURTHER ACTION WILL FOLLOW THIS @@ -100,7 +100,7 @@ NetworkConnectionState NBConnectionHandler::check() { } Debug.print(DBG_INFO, "Sending PING to outer space..."); int pingResult; - // pingResult = gprs.ping("time.arduino.cc"); + // pingResult = _gprs.ping("time.arduino.cc"); // Debug.print(DBG_INFO, "NB.ping(): %d", pingResult); // if (pingResult < 0) { if (pingResult < 0) { @@ -125,7 +125,7 @@ NetworkConnectionState NBConnectionHandler::check() { } break; case NetworkConnectionState::DISCONNECTED: { - //gprs.detachGPRS(); + //_gprs.detachGPRS(); if (keepAlive) { Debug.print(DBG_VERBOSE, "keep alive > INIT"); changeConnectionState(NetworkConnectionState::INIT); diff --git a/src/Arduino_NBConnectionHandler.h b/src/Arduino_NBConnectionHandler.h index 0811898f..8c89951d 100644 --- a/src/Arduino_NBConnectionHandler.h +++ b/src/Arduino_NBConnectionHandler.h @@ -40,15 +40,15 @@ class NBConnectionHandler : public ConnectionHandler { virtual unsigned long getTime(); virtual NetworkConnectionState check(); virtual Client &getClient() { - return networkClient; + return _gsm_client; }; virtual UDP &getUDP() { return udp; }; - NBClient networkClient; + NBClient _gsm_client; NB nbAccess; - GPRS gprs; + GPRS _gprs; NBUDP udp; virtual void disconnect(); From 96f4763cb7b46a001a80bd7719578904f677cce0 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 08:28:19 +0100 Subject: [PATCH 15/54] Moving functionality concerning a disconnection into function disconnect --- src/Arduino_GSMConnectionHandler.cpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index 94be93c7..c14339ca 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -82,6 +82,14 @@ NetworkConnectionState GSMConnectionHandler::check() { return netConnectionState; } +void GSMConnectionHandler::disconnect() +{ + Debug.print(DBG_VERBOSE, "Disconnecting from Cellular Network"); + _gsm.shutdown(); + _keep_alive = false; + netConnectionState = NetworkConnectionState::DISCONNECTING; +} + /****************************************************************************** PRIVATE MEMBER FUNCTIONS ******************************************************************************/ @@ -181,8 +189,6 @@ void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newStat } break; case NetworkConnectionState::DISCONNECTING: { - Debug.print(DBG_VERBOSE, "Disconnecting from Cellular Network"); - _gsm.shutdown(); } case NetworkConnectionState::DISCONNECTED: { if (netConnectionState == NetworkConnectionState::CONNECTED) { @@ -216,11 +222,5 @@ void GSMConnectionHandler::connect() { changeConnectionState(NetworkConnectionState::INIT); } -void GSMConnectionHandler::disconnect() { - //WiFi.end(); - - changeConnectionState(NetworkConnectionState::DISCONNECTING); - _keep_alive = false; -} #endif /* #ifdef BOARD_HAS_GSM */ \ No newline at end of file From 346666a3266ce020d3022159da7651c2ee8aaa9f Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 08:30:21 +0100 Subject: [PATCH 16/54] Restructuring connect function --- src/Arduino_GSMConnectionHandler.cpp | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index c14339ca..abcace68 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -90,6 +90,15 @@ void GSMConnectionHandler::disconnect() netConnectionState = NetworkConnectionState::DISCONNECTING; } +void GSMConnectionHandler::connect() +{ + if (netConnectionState != NetworkConnectionState::INIT && netConnectionState != NetworkConnectionState::CONNECTING) + { + _keep_alive = true; + netConnectionState = NetworkConnectionState::INIT; + } +} + /****************************************************************************** PRIVATE MEMBER FUNCTIONS ******************************************************************************/ @@ -213,14 +222,4 @@ void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newStat netConnectionState = _newState; } - -void GSMConnectionHandler::connect() { - if (netConnectionState == NetworkConnectionState::INIT || netConnectionState == NetworkConnectionState::CONNECTING) { - return; - } - _keep_alive = true; - changeConnectionState(NetworkConnectionState::INIT); - -} - -#endif /* #ifdef BOARD_HAS_GSM */ \ No newline at end of file +#endif /* #ifdef BOARD_HAS_GSM */ From a202e6ee5bd0bb1bfc8d208eca56f48c6ae05cee Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 08:32:36 +0100 Subject: [PATCH 17/54] Eliminating changeConnectionState --- src/Arduino_GSMConnectionHandler.cpp | 56 ++++------------------------ 1 file changed, 8 insertions(+), 48 deletions(-) diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index abcace68..c0b8aac6 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -58,13 +58,16 @@ GSMConnectionHandler::GSMConnectionHandler(const char * pin, const char * apn, c PUBLIC MEMBER FUNCTIONS ******************************************************************************/ -unsigned long GSMConnectionHandler::getTime() { +unsigned long GSMConnectionHandler::getTime() +{ return _gsm.getTime(); } -NetworkConnectionState GSMConnectionHandler::check() { +NetworkConnectionState GSMConnectionHandler::check() +{ unsigned long const now = millis(); - if (now - lastConnectionTickTime > connectionTickTimeInterval) { + if (now - lastConnectionTickTime > connectionTickTimeInterval) + { switch (netConnectionState) { case NetworkConnectionState::INIT: netConnectionState = update_handleInit(); break; @@ -125,6 +128,8 @@ NetworkConnectionState GSMConnectionHandler::update_handleConnecting() Debug.print(DBG_DEBUG, "GPRS.attachGPRS(): %d", network_status); if (network_status == GSM3_NetworkStatus_t::ERROR) { + Debug.print(DBG_ERROR, "GPRS attach failed"); + Debug.print(DBG_ERROR, "Make sure the antenna is connected and reset your board."); execCallback(NetworkConnectionEvent::ERROR, 0); return NetworkConnectionState::ERROR; } @@ -177,49 +182,4 @@ NetworkConnectionState GSMConnectionHandler::update_handleDisconnected() } } -void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newState) { - int newInterval = CHECK_INTERVAL_IDLE; - switch (_newState) { - case NetworkConnectionState::INIT: { - newInterval = CHECK_INTERVAL_INIT; - } - break; - case NetworkConnectionState::CONNECTING: { - Debug.print(DBG_INFO, "Connecting to Cellular Network"); - newInterval = CHECK_INTERVAL_CONNECTING; - } - break; - case NetworkConnectionState::CONNECTED: { - execCallback(NetworkConnectionEvent::CONNECTED, 0); - newInterval = CHECK_INTERVAL_CONNECTED; - } - break; - case NetworkConnectionState::GETTIME: { - } - break; - case NetworkConnectionState::DISCONNECTING: { - } - case NetworkConnectionState::DISCONNECTED: { - if (netConnectionState == NetworkConnectionState::CONNECTED) { - execCallback(NetworkConnectionEvent::DISCONNECTED, 0); - Debug.print(DBG_ERROR, "Disconnected from Cellular Network"); - Debug.print(DBG_ERROR, "Attempting reconnection"); - if (_keep_alive) { - Debug.print(DBG_ERROR, "Attempting reconnection"); - } - } - newInterval = CHECK_INTERVAL_DISCONNECTED; - } - break; - case NetworkConnectionState::ERROR: { - execCallback(NetworkConnectionEvent::ERROR, 0); - Debug.print(DBG_ERROR, "GPRS attach failed\n\rMake sure the antenna is connected and reset your board."); - } - break; - } - connectionTickTimeInterval = newInterval; - lastConnectionTickTime = millis(); - netConnectionState = _newState; -} - #endif /* #ifdef BOARD_HAS_GSM */ From 483885b795dc0cd666bff06847d0e7826c8a5e78 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 08:37:45 +0100 Subject: [PATCH 18/54] Using lookup table for timeouts similiar to the WiFi connection handler --- src/Arduino_GSMConnectionHandler.cpp | 28 +++++++++++++++++++++------- src/Arduino_GSMConnectionHandler.h | 13 +------------ 2 files changed, 22 insertions(+), 19 deletions(-) diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index c0b8aac6..1b53ccee 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -36,7 +36,19 @@ CONSTANTS ******************************************************************************/ -static const unsigned long NETWORK_CONNECTION_INTERVAL = 30000; +static int const GSM_TIMEOUT = 30000; + +static unsigned int const CHECK_INTERVAL_TABLE[] = +{ + /* INIT */ 100, + /* CONNECTING */ 500, + /* CONNECTED */ 10000, + /* GETTIME */ 100, + /* DISCONNECTING */ 100, + /* DISCONNECTED */ 1000, + /* CLOSED */ 1000, + /* ERROR */ 1000 +}; /****************************************************************************** CTOR/DTOR @@ -47,8 +59,7 @@ GSMConnectionHandler::GSMConnectionHandler(const char * pin, const char * apn, c , _apn(apn) , _login(login) , _pass(pass) -, lastConnectionTickTime(millis()) -, connectionTickTimeInterval(CHECK_INTERVAL_IDLE) +, _lastConnectionTickTime(millis()) , _keep_alive(keep_alive) { @@ -66,8 +77,12 @@ unsigned long GSMConnectionHandler::getTime() NetworkConnectionState GSMConnectionHandler::check() { unsigned long const now = millis(); - if (now - lastConnectionTickTime > connectionTickTimeInterval) + unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(netConnectionState)]; + + if((now - _lastConnectionTickTime) > connectionTickTimeInterval) { + _lastConnectionTickTime = now; + switch (netConnectionState) { case NetworkConnectionState::INIT: netConnectionState = update_handleInit(); break; @@ -79,7 +94,6 @@ NetworkConnectionState GSMConnectionHandler::check() case NetworkConnectionState::ERROR: break; case NetworkConnectionState::CLOSED: break; } - lastConnectionTickTime = now; } return netConnectionState; @@ -111,7 +125,7 @@ NetworkConnectionState GSMConnectionHandler::update_handleInit() if (_gsm.begin(_pin) == GSM_READY) { Debug.print(DBG_INFO, "SIM card ok"); - _gsm.setTimeout(CHECK_INTERVAL_RETRYING); + _gsm.setTimeout(GSM_TIMEOUT); return NetworkConnectionState::CONNECTING; } else @@ -139,7 +153,7 @@ NetworkConnectionState GSMConnectionHandler::update_handleConnecting() if (ping_result < 0) { Debug.print(DBG_ERROR, "PING failed"); - Debug.print(DBG_INFO, "Retrying in \"%d\" milliseconds", connectionTickTimeInterval); + Debug.print(DBG_INFO, "Retrying in \"%d\" milliseconds", CHECK_INTERVAL_TABLE[static_cast(NetworkConnectionState::CONNECTING)]); return NetworkConnectionState::CONNECTING; } else diff --git a/src/Arduino_GSMConnectionHandler.h b/src/Arduino_GSMConnectionHandler.h index 6c7da95f..8507fab9 100644 --- a/src/Arduino_GSMConnectionHandler.h +++ b/src/Arduino_GSMConnectionHandler.h @@ -44,22 +44,11 @@ class GSMConnectionHandler : public ConnectionHandler { private: - void changeConnectionState(NetworkConnectionState _newState); - - const int CHECK_INTERVAL_IDLE = 100; - const int CHECK_INTERVAL_INIT = 100; - const int CHECK_INTERVAL_CONNECTING = 500; - const int CHECK_INTERVAL_CONNECTED = 10000; - const int CHECK_INTERVAL_RETRYING = 30000; - const int CHECK_INTERVAL_DISCONNECTED = 1000; - const int CHECK_INTERVAL_ERROR = 500; - const char * _pin; const char * _apn; const char * _login; const char * _pass; - unsigned long lastConnectionTickTime; - int connectionTickTimeInterval; + unsigned long _lastConnectionTickTime; GSM _gsm; GPRS _gprs; From 9d3f6b499e5452ebdbbaa05763fb7ab4d5cd5450 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 08:39:15 +0100 Subject: [PATCH 19/54] Adding keyword override to allow compiler check if really a base class function is overwritten --- src/Arduino_GSMConnectionHandler.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/Arduino_GSMConnectionHandler.h b/src/Arduino_GSMConnectionHandler.h index 8507fab9..6f9e58a0 100644 --- a/src/Arduino_GSMConnectionHandler.h +++ b/src/Arduino_GSMConnectionHandler.h @@ -35,12 +35,12 @@ class GSMConnectionHandler : public ConnectionHandler { public: GSMConnectionHandler(const char * pin, const char * apn, const char * login, const char * pass, bool const keep_alive = true); - virtual unsigned long getTime(); - virtual NetworkConnectionState check(); - virtual Client &getClient() { return _gsm_client; }; - virtual UDP &getUDP() { return _udp; }; - virtual void disconnect(); - virtual void connect(); + virtual unsigned long getTime() override; + virtual NetworkConnectionState check() override; + virtual Client & getClient() override { return _gsm_client; }; + virtual UDP & getUDP() override { return _udp; }; + virtual void disconnect() override; + virtual void connect() override; private: From 77a137806d4fca215cd1816468acba27dfbdee54 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 08:40:28 +0100 Subject: [PATCH 20/54] Rename _udp to _gsm_udp --- src/Arduino_GSMConnectionHandler.cpp | 2 +- src/Arduino_GSMConnectionHandler.h | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index 1b53ccee..96f0965c 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -59,8 +59,8 @@ GSMConnectionHandler::GSMConnectionHandler(const char * pin, const char * apn, c , _apn(apn) , _login(login) , _pass(pass) -, _lastConnectionTickTime(millis()) , _keep_alive(keep_alive) +, _lastConnectionTickTime(millis()) { } diff --git a/src/Arduino_GSMConnectionHandler.h b/src/Arduino_GSMConnectionHandler.h index 6f9e58a0..880514f9 100644 --- a/src/Arduino_GSMConnectionHandler.h +++ b/src/Arduino_GSMConnectionHandler.h @@ -38,7 +38,7 @@ class GSMConnectionHandler : public ConnectionHandler { virtual unsigned long getTime() override; virtual NetworkConnectionState check() override; virtual Client & getClient() override { return _gsm_client; }; - virtual UDP & getUDP() override { return _udp; }; + virtual UDP & getUDP() override { return _gsm_udp; }; virtual void disconnect() override; virtual void connect() override; @@ -48,14 +48,14 @@ class GSMConnectionHandler : public ConnectionHandler { const char * _apn; const char * _login; const char * _pass; + bool _keep_alive; unsigned long _lastConnectionTickTime; GSM _gsm; GPRS _gprs; - GSMUDP _udp; + GSMUDP _gsm_udp; GSMClient _gsm_client; - bool _keep_alive; NetworkConnectionState update_handleInit (); NetworkConnectionState update_handleConnecting (); From ccd6b87a38f823a5ebac380f918f00ca3fdd4695 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 08:44:32 +0100 Subject: [PATCH 21/54] Fixing formatting/braces for better readability --- src/Arduino_GSMConnectionHandler.h | 8 ++-- src/Arduino_WiFiConnectionHandler.cpp | 67 +++++++++++++++++---------- src/Arduino_WiFiConnectionHandler.h | 7 ++- 3 files changed, 52 insertions(+), 30 deletions(-) diff --git a/src/Arduino_GSMConnectionHandler.h b/src/Arduino_GSMConnectionHandler.h index 880514f9..3aad1f36 100644 --- a/src/Arduino_GSMConnectionHandler.h +++ b/src/Arduino_GSMConnectionHandler.h @@ -31,10 +31,13 @@ CLASS DECLARATION ******************************************************************************/ -class GSMConnectionHandler : public ConnectionHandler { +class GSMConnectionHandler : public ConnectionHandler +{ public: + GSMConnectionHandler(const char * pin, const char * apn, const char * login, const char * pass, bool const keep_alive = true); + virtual unsigned long getTime() override; virtual NetworkConnectionState check() override; virtual Client & getClient() override { return _gsm_client; }; @@ -42,6 +45,7 @@ class GSMConnectionHandler : public ConnectionHandler { virtual void disconnect() override; virtual void connect() override; + private: const char * _pin; @@ -56,13 +60,11 @@ class GSMConnectionHandler : public ConnectionHandler { GSMUDP _gsm_udp; GSMClient _gsm_client; - NetworkConnectionState update_handleInit (); NetworkConnectionState update_handleConnecting (); NetworkConnectionState update_handleConnected (); NetworkConnectionState update_handleDisconnecting(); NetworkConnectionState update_handleDisconnected (); - }; #endif /* #ifdef BOARD_HAS_GSM */ diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp index f1e43056..a9b6e700 100644 --- a/src/Arduino_WiFiConnectionHandler.cpp +++ b/src/Arduino_WiFiConnectionHandler.cpp @@ -52,7 +52,8 @@ WiFiConnectionHandler::WiFiConnectionHandler(char const * ssid, char const * pas PUBLIC MEMBER FUNCTIONS ******************************************************************************/ -unsigned long WiFiConnectionHandler::getTime() { +unsigned long WiFiConnectionHandler::getTime() +{ #if !defined(BOARD_ESP8266) return WiFi.getTime(); #else @@ -60,8 +61,8 @@ unsigned long WiFiConnectionHandler::getTime() { #endif } -NetworkConnectionState WiFiConnectionHandler::check() { - +NetworkConnectionState WiFiConnectionHandler::check() +{ unsigned long const now = millis(); unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(netConnectionState)]; @@ -69,7 +70,8 @@ NetworkConnectionState WiFiConnectionHandler::check() { { _lastConnectionTickTime = now; - switch (netConnectionState) { + switch (netConnectionState) + { case NetworkConnectionState::INIT: netConnectionState = update_handleInit (); break; case NetworkConnectionState::CONNECTING: netConnectionState = update_handleConnecting (); break; case NetworkConnectionState::CONNECTED: netConnectionState = update_handleConnected (); break; @@ -88,25 +90,29 @@ NetworkConnectionState WiFiConnectionHandler::check() { PRIVATE MEMBER FUNCTIONS ******************************************************************************/ -void WiFiConnectionHandler::connect() { - if (netConnectionState == NetworkConnectionState::INIT || netConnectionState == NetworkConnectionState::CONNECTING) { - return; +void WiFiConnectionHandler::connect() +{ + if (netConnectionState != NetworkConnectionState::INIT && netConnectionState != NetworkConnectionState::CONNECTING) + { + _keep_alive = true; + netConnectionState = NetworkConnectionState::INIT; } - _keep_alive = true; - netConnectionState = NetworkConnectionState::INIT; } -void WiFiConnectionHandler::disconnect() { +void WiFiConnectionHandler::disconnect() +{ _keep_alive = false; netConnectionState = NetworkConnectionState::DISCONNECTING; } -NetworkConnectionState WiFiConnectionHandler::update_handleInit() { +NetworkConnectionState WiFiConnectionHandler::update_handleInit() +{ Debug.print(DBG_VERBOSE, "::INIT"); #ifndef BOARD_ESP8266 Debug.print(DBG_INFO, "WiFi.status(): %d", WiFi.status()); - if (WiFi.status() == NETWORK_HARDWARE_ERROR) { + if (WiFi.status() == NETWORK_HARDWARE_ERROR) + { execCallback(NetworkConnectionEvent::ERROR, 0); Debug.print(DBG_ERROR, "WiFi Hardware failure.\nMake sure you are using a WiFi enabled board/shield."); Debug.print(DBG_ERROR, "Then reset and retry."); @@ -115,7 +121,8 @@ NetworkConnectionState WiFiConnectionHandler::update_handleInit() { Debug.print(DBG_ERROR, "Current WiFi Firmware: %s", WiFi.firmwareVersion()); - if (WiFi.firmwareVersion() < WIFI_FIRMWARE_VERSION_REQUIRED) { + if (WiFi.firmwareVersion() < WIFI_FIRMWARE_VERSION_REQUIRED) + { Debug.print(DBG_ERROR, "Latest WiFi Firmware: %s", WIFI_FIRMWARE_VERSION_REQUIRED); Debug.print(DBG_ERROR, "Please update to the latest version for best performance."); delay(5000); @@ -131,30 +138,34 @@ NetworkConnectionState WiFiConnectionHandler::update_handleInit() { return NetworkConnectionState::CONNECTING; } -NetworkConnectionState WiFiConnectionHandler::update_handleConnecting() { +NetworkConnectionState WiFiConnectionHandler::update_handleConnecting() +{ Debug.print(DBG_VERBOSE, "::CONNECTING"); #ifndef BOARD_ESP8266 - if (WiFi.status() != WL_CONNECTED) { + if (WiFi.status() != WL_CONNECTED) + { WiFi.begin(_ssid, _pass); } #endif /* ifndef BOARD_ESP8266 */ Debug.print(DBG_VERBOSE, "WiFi.status(): %d", WiFi.status()); - if (WiFi.status() != NETWORK_CONNECTED) { + if (WiFi.status() != NETWORK_CONNECTED) + { Debug.print(DBG_ERROR, "Connection to \"%s\" failed", _ssid); Debug.print(DBG_INFO, "Retrying in \"%d\" milliseconds", CHECK_INTERVAL_TABLE[static_cast(NetworkConnectionState::CONNECTING)]); return NetworkConnectionState::CONNECTING; } - else { + else + { Debug.print(DBG_INFO, "Connected to \"%s\"", _ssid); execCallback(NetworkConnectionEvent::CONNECTED, 0); return NetworkConnectionState::GETTIME; } } -NetworkConnectionState WiFiConnectionHandler::update_handleConnected() { - +NetworkConnectionState WiFiConnectionHandler::update_handleConnected() +{ Debug.print(DBG_VERBOSE, "WiFi.status(): %d", WiFi.status()); if (WiFi.status() != WL_CONNECTED) { @@ -163,7 +174,8 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnected() { Debug.print(DBG_VERBOSE, "WiFi.status(): %d", WiFi.status()); Debug.print(DBG_ERROR, "Connection to \"%s\" lost.", _ssid); - if (_keep_alive) { + if (_keep_alive) + { Debug.print(DBG_ERROR, "Attempting reconnection"); } @@ -172,7 +184,8 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnected() { return NetworkConnectionState::CONNECTED; } -NetworkConnectionState WiFiConnectionHandler::update_handleGetTime() { +NetworkConnectionState WiFiConnectionHandler::update_handleGetTime() +{ Debug.print(DBG_VERBOSE, "NetworkConnectionState::GETTIME"); #ifdef BOARD_ESP8266 configTime(0, 0, "time.arduino.cc", "pool.ntp.org", "time.nist.gov"); @@ -180,20 +193,24 @@ NetworkConnectionState WiFiConnectionHandler::update_handleGetTime() { return NetworkConnectionState::CONNECTED; } -NetworkConnectionState WiFiConnectionHandler::update_handleDisconnecting() { +NetworkConnectionState WiFiConnectionHandler::update_handleDisconnecting() +{ Debug.print(DBG_VERBOSE, "Disconnecting from \"%s\"", _ssid); WiFi.disconnect(); return NetworkConnectionState::DISCONNECTED; } -NetworkConnectionState WiFiConnectionHandler::update_handleDisconnected() { +NetworkConnectionState WiFiConnectionHandler::update_handleDisconnected() +{ #ifndef BOARD_ESP8266 WiFi.end(); #endif /* ifndef BOARD_ESP8266 */ - if (_keep_alive) { + if (_keep_alive) + { return NetworkConnectionState::INIT; } - else { + else + { Debug.print(DBG_VERBOSE, "Connection to \"%s\" closed", _ssid); return NetworkConnectionState::CLOSED; } diff --git a/src/Arduino_WiFiConnectionHandler.h b/src/Arduino_WiFiConnectionHandler.h index 88f13751..b4f20eb6 100644 --- a/src/Arduino_WiFiConnectionHandler.h +++ b/src/Arduino_WiFiConnectionHandler.h @@ -30,10 +30,13 @@ CLASS DECLARATION ******************************************************************************/ -class WiFiConnectionHandler : public ConnectionHandler { +class WiFiConnectionHandler : public ConnectionHandler +{ public: + WiFiConnectionHandler(char const * ssid, char const * pass, bool const keep_alive = true); + virtual unsigned long getTime() override; virtual NetworkConnectionState check() override; virtual Client & getClient() override{ return _wifi_client; } @@ -41,6 +44,7 @@ class WiFiConnectionHandler : public ConnectionHandler { virtual void disconnect() override; virtual void connect() override; + private: char const * _ssid; @@ -57,7 +61,6 @@ class WiFiConnectionHandler : public ConnectionHandler { NetworkConnectionState update_handleGetTime (); NetworkConnectionState update_handleDisconnecting(); NetworkConnectionState update_handleDisconnected (); - }; #endif /* #ifdef BOARD_HAS_WIFI */ From 6051c2021180b623100035c438de9c90e35b5851 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 08:50:30 +0100 Subject: [PATCH 22/54] Removing unused function init --- src/Arduino_LoRaConnectionHandler.cpp | 3 --- src/Arduino_LoRaConnectionHandler.h | 1 - 2 files changed, 4 deletions(-) diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp index 32cab126..e121706f 100644 --- a/src/Arduino_LoRaConnectionHandler.cpp +++ b/src/Arduino_LoRaConnectionHandler.cpp @@ -48,9 +48,6 @@ LoRaConnectionHandler::LoRaConnectionHandler(const char *_appeui, const char *_a PUBLIC MEMBER FUNCTIONS ******************************************************************************/ -void LoRaConnectionHandler::init() { -} - unsigned long LoRaConnectionHandler::getTime() { return 0; } diff --git a/src/Arduino_LoRaConnectionHandler.h b/src/Arduino_LoRaConnectionHandler.h index 53a7b423..fcc882d8 100644 --- a/src/Arduino_LoRaConnectionHandler.h +++ b/src/Arduino_LoRaConnectionHandler.h @@ -44,7 +44,6 @@ class LoRaConnectionHandler : public ConnectionHandler { public: LoRaConnectionHandler(const char *_appeui, const char *_appkey, _lora_band = _lora_band::EU868, _lora_class = _lora_class::CLASS_A); - virtual void init(); virtual unsigned long getTime(); virtual NetworkConnectionState check(); From 74208bd62de4d9c2f26f47ba07cd94c5c7efe5ed Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 08:52:13 +0100 Subject: [PATCH 23/54] Deleting function getTime which is not necessary for the LoRa_ConnectionHandler --- src/Arduino_LoRaConnectionHandler.cpp | 4 ---- src/Arduino_LoRaConnectionHandler.h | 1 - 2 files changed, 5 deletions(-) diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp index e121706f..03d5f12a 100644 --- a/src/Arduino_LoRaConnectionHandler.cpp +++ b/src/Arduino_LoRaConnectionHandler.cpp @@ -48,10 +48,6 @@ LoRaConnectionHandler::LoRaConnectionHandler(const char *_appeui, const char *_a PUBLIC MEMBER FUNCTIONS ******************************************************************************/ -unsigned long LoRaConnectionHandler::getTime() { - return 0; -} - int LoRaConnectionHandler::write(const uint8_t *buf, size_t size) { int err; modem.beginPacket(); diff --git a/src/Arduino_LoRaConnectionHandler.h b/src/Arduino_LoRaConnectionHandler.h index fcc882d8..adafeac6 100644 --- a/src/Arduino_LoRaConnectionHandler.h +++ b/src/Arduino_LoRaConnectionHandler.h @@ -44,7 +44,6 @@ class LoRaConnectionHandler : public ConnectionHandler { public: LoRaConnectionHandler(const char *_appeui, const char *_appkey, _lora_band = _lora_band::EU868, _lora_class = _lora_class::CLASS_A); - virtual unsigned long getTime(); virtual NetworkConnectionState check(); virtual int write(const uint8_t *buf, size_t size); From 5ea16559e1b0734ec876576ca719b1b7b82ae25a Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 08:53:51 +0100 Subject: [PATCH 24/54] Deleting initalisation of netConnectionState to NetworkConnectionState::INIT since this is already done in the base class --- src/Arduino_LoRaConnectionHandler.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp index 03d5f12a..36b68f87 100644 --- a/src/Arduino_LoRaConnectionHandler.cpp +++ b/src/Arduino_LoRaConnectionHandler.cpp @@ -40,8 +40,9 @@ LoRaConnectionHandler::LoRaConnectionHandler(const char *_appeui, const char *_a deviceClass(deviceClass), lastConnectionTickTime(millis()), connectionTickTimeInterval(CHECK_INTERVAL_IDLE), - keepAlive(false) { - netConnectionState = NetworkConnectionState::INIT; + keepAlive(false) +{ + } /****************************************************************************** From 1419ec38c7ff79907dcb5b762e04ac4cdac321ae Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 09:02:02 +0100 Subject: [PATCH 25/54] Fixing up member variables --- src/Arduino_LoRaConnectionHandler.cpp | 66 +++++++++++++-------------- src/Arduino_LoRaConnectionHandler.h | 19 ++++---- 2 files changed, 42 insertions(+), 43 deletions(-) diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp index 36b68f87..2df0469e 100644 --- a/src/Arduino_LoRaConnectionHandler.cpp +++ b/src/Arduino_LoRaConnectionHandler.cpp @@ -33,14 +33,14 @@ static const unsigned long NETWORK_CONNECTION_INTERVAL = 30000; /* NOT USED CTOR/DTOR ******************************************************************************/ -LoRaConnectionHandler::LoRaConnectionHandler(const char *_appeui, const char *_appkey, _lora_band band, _lora_class deviceClass) : - appeui(_appeui), - appkey(_appkey), - band(band), - deviceClass(deviceClass), - lastConnectionTickTime(millis()), - connectionTickTimeInterval(CHECK_INTERVAL_IDLE), - keepAlive(false) +LoRaConnectionHandler::LoRaConnectionHandler(char const * appeui, char const * appkey, _lora_band const band, _lora_class const device_class) +: _appeui(appeui) +, _appkey(appkey) +, _band(band) +, _device_class(device_class) +, _lastConnectionTickTime(millis()) +, _connectionTickTimeInterval(CHECK_INTERVAL_IDLE) +, _keep_alive(false) { } @@ -51,9 +51,9 @@ LoRaConnectionHandler::LoRaConnectionHandler(const char *_appeui, const char *_a int LoRaConnectionHandler::write(const uint8_t *buf, size_t size) { int err; - modem.beginPacket(); - modem.write(buf, size); - err = modem.endPacket(true); + _modem.beginPacket(); + _modem.write(buf, size); + err = _modem.endPacket(true); if (err != size) { switch (err) { case LoRaCommunicationError::LORA_ERROR_ACK_NOT_RECEIVED: { @@ -91,20 +91,20 @@ int LoRaConnectionHandler::write(const uint8_t *buf, size_t size) { } int LoRaConnectionHandler::read() { - return modem.read(); + return _modem.read(); } bool LoRaConnectionHandler::available() { - return modem.available(); + return _modem.available(); } NetworkConnectionState LoRaConnectionHandler::check() { unsigned long const now = millis(); int networkStatus = 0; - if (now - lastConnectionTickTime > connectionTickTimeInterval) { /* time bracket */ + if (now - _lastConnectionTickTime > _connectionTickTimeInterval) { /* time bracket */ - lastConnectionTickTime = now; + _lastConnectionTickTime = now; switch (netConnectionState) { case NetworkConnectionState::INIT: netConnectionState = update_handleInit(); break; case NetworkConnectionState::CONNECTING: netConnectionState = update_handleConnecting(); break; @@ -125,47 +125,47 @@ NetworkConnectionState LoRaConnectionHandler::check() { NetworkConnectionState LoRaConnectionHandler::update_handleInit() { Debug.print(DBG_VERBOSE, "::INIT"); - if (!modem.begin(band)) { + if (!_modem.begin(_band)) { Debug.print(DBG_VERBOSE, "Failed to start module"); execCallback(NetworkConnectionEvent::ERROR, 0); Debug.print(DBG_ERROR, "Something went wrong; are you indoor? Move near a window, then reset and retry."); }; - //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 + //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 delay(100); - modem.configureClass(deviceClass); + _modem.configureClass(_device_class); delay(100); Debug.print(DBG_INFO, "Connecting to the network"); - connectionTickTimeInterval = CHECK_INTERVAL_CONNECTING; + _connectionTickTimeInterval = CHECK_INTERVAL_CONNECTING; return NetworkConnectionState::CONNECTING; } NetworkConnectionState LoRaConnectionHandler::update_handleConnecting() { Debug.print(DBG_VERBOSE, "::CONNECTING"); - bool networkStatus = modem.joinOTAA(appeui, appkey); - if (networkStatus != true) { + bool const network_status = _modem.joinOTAA(_appeui, _appkey); + if (network_status != true) { execCallback(NetworkConnectionEvent::ERROR, 0); Debug.print(DBG_ERROR, "Something went wrong; are you indoor? Move near a window, then reset and retry."); return NetworkConnectionState::ERROR; } Debug.print(DBG_INFO, "Connected to the network"); - connectionTickTimeInterval = CHECK_INTERVAL_CONNECTED; + _connectionTickTimeInterval = CHECK_INTERVAL_CONNECTED; execCallback(NetworkConnectionEvent::CONNECTED, 0); return NetworkConnectionState::CONNECTED; } NetworkConnectionState LoRaConnectionHandler::update_handleConnected() { - bool networkStatus = modem.connected(); - Debug.print(DBG_VERBOSE, "Connection state: %d", networkStatus); - if (networkStatus != true) { + bool const network_status = _modem.connected(); + Debug.print(DBG_VERBOSE, "Connection state: %d", network_status); + if (network_status != true) { execCallback(NetworkConnectionEvent::DISCONNECTED, 0); Debug.print(DBG_ERROR, "Connection to the network lost."); - if (keepAlive) { + if (_keep_alive) { Debug.print(DBG_ERROR, "Attempting reconnection"); } - connectionTickTimeInterval = CHECK_INTERVAL_DISCONNECTED; + _connectionTickTimeInterval = CHECK_INTERVAL_DISCONNECTED; return NetworkConnectionState::DISCONNECTED; } Debug.print(DBG_VERBOSE, "Connected to the network"); @@ -177,17 +177,17 @@ NetworkConnectionState LoRaConnectionHandler::update_handleDisconnecting() { execCallback(NetworkConnectionEvent::DISCONNECTED, 0); Debug.print(DBG_ERROR, "Connection to the network lost."); - if (keepAlive) { + if (_keep_alive) { Debug.print(DBG_ERROR, "Attempting reconnection"); } - connectionTickTimeInterval = CHECK_INTERVAL_DISCONNECTED; + _connectionTickTimeInterval = CHECK_INTERVAL_DISCONNECTED; return NetworkConnectionState::DISCONNECTED; } NetworkConnectionState LoRaConnectionHandler::update_handleDisconnected() { - if (keepAlive) { + if (_keep_alive) { Debug.print(DBG_VERBOSE, "CHANGING STATE TO ::INIT"); - connectionTickTimeInterval = CHECK_INTERVAL_INIT; + _connectionTickTimeInterval = CHECK_INTERVAL_INIT; return NetworkConnectionState::INIT; } else { Debug.print(DBG_VERBOSE, "Connection to the network terminated"); @@ -200,8 +200,8 @@ void LoRaConnectionHandler::connect() { if (netConnectionState == NetworkConnectionState::INIT || netConnectionState == NetworkConnectionState::CONNECTING) { return; } - keepAlive = true; - connectionTickTimeInterval = CHECK_INTERVAL_INIT; + _keep_alive = true; + _connectionTickTimeInterval = CHECK_INTERVAL_INIT; netConnectionState = NetworkConnectionState::INIT; } diff --git a/src/Arduino_LoRaConnectionHandler.h b/src/Arduino_LoRaConnectionHandler.h index adafeac6..78dd5ccd 100644 --- a/src/Arduino_LoRaConnectionHandler.h +++ b/src/Arduino_LoRaConnectionHandler.h @@ -42,7 +42,7 @@ typedef enum { class LoRaConnectionHandler : public ConnectionHandler { public: - LoRaConnectionHandler(const char *_appeui, const char *_appkey, _lora_band = _lora_band::EU868, _lora_class = _lora_class::CLASS_A); + LoRaConnectionHandler(char const * appeui, char const * appkey, _lora_band const band = _lora_band::EU868, _lora_class const device_class = _lora_class::CLASS_A); virtual NetworkConnectionState check(); @@ -64,15 +64,14 @@ class LoRaConnectionHandler : public ConnectionHandler { const int CHECK_INTERVAL_DISCONNECTED = 1000; const int CHECK_INTERVAL_ERROR = 500; - LoRaModem modem; - const char *appeui, *appkey; - _lora_band band; - _lora_class deviceClass; - unsigned long lastConnectionTickTime; - - int connectionTickTimeInterval; - - bool keepAlive; + char const * _appeui; + char const * _appkey; + _lora_band _band; + _lora_class _device_class; + unsigned long _lastConnectionTickTime; + int _connectionTickTimeInterval; + bool _keep_alive; + LoRaModem _modem; NetworkConnectionState update_handleInit(); NetworkConnectionState update_handleConnecting(); From 80ab4d8672da328d9d2988398c8afa6224598fde Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 09:03:22 +0100 Subject: [PATCH 26/54] Cleanup connect/disconnect methods --- src/Arduino_LoRaConnectionHandler.cpp | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp index 2df0469e..378c4c10 100644 --- a/src/Arduino_LoRaConnectionHandler.cpp +++ b/src/Arduino_LoRaConnectionHandler.cpp @@ -119,6 +119,19 @@ NetworkConnectionState LoRaConnectionHandler::check() { return netConnectionState; } +void LoRaConnectionHandler::connect() +{ + if (netConnectionState != NetworkConnectionState::INIT && netConnectionState != NetworkConnectionState::CONNECTING) + { + _keep_alive = true; + netConnectionState = NetworkConnectionState::INIT; + } +} +void LoRaConnectionHandler::disconnect() +{ + /* Do nothing */ +} + /****************************************************************************** PRIVATE MEMBER FUNCTIONS ******************************************************************************/ @@ -196,17 +209,4 @@ NetworkConnectionState LoRaConnectionHandler::update_handleDisconnected() { } -void LoRaConnectionHandler::connect() { - if (netConnectionState == NetworkConnectionState::INIT || netConnectionState == NetworkConnectionState::CONNECTING) { - return; - } - _keep_alive = true; - _connectionTickTimeInterval = CHECK_INTERVAL_INIT; - netConnectionState = NetworkConnectionState::INIT; - -} -void LoRaConnectionHandler::disconnect() { - // do nothing - return; -} #endif From be76df641647199b763141e86c1e4f293d80aca0 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 09:05:57 +0100 Subject: [PATCH 27/54] Using table for check interval times instead of member variable --- src/Arduino_LoRaConnectionHandler.cpp | 28 ++++++++++++++++----------- src/Arduino_LoRaConnectionHandler.h | 1 - src/Arduino_WiFiConnectionHandler.cpp | 4 ++++ 3 files changed, 21 insertions(+), 12 deletions(-) diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp index 378c4c10..d2da8e5f 100644 --- a/src/Arduino_LoRaConnectionHandler.cpp +++ b/src/Arduino_LoRaConnectionHandler.cpp @@ -27,7 +27,17 @@ CONSTANTS ******************************************************************************/ -static const unsigned long NETWORK_CONNECTION_INTERVAL = 30000; /* NOT USED */ +static unsigned int const CHECK_INTERVAL_TABLE[] = +{ + /* INIT */ 100, + /* CONNECTING */ 500, + /* CONNECTED */ 10000, + /* GETTIME */ 100, + /* DISCONNECTING */ 100, + /* DISCONNECTED */ 1000, + /* CLOSED */ 1000, + /* ERROR */ 1000 +}; /****************************************************************************** CTOR/DTOR @@ -39,7 +49,6 @@ LoRaConnectionHandler::LoRaConnectionHandler(char const * appeui, char const * a , _band(band) , _device_class(device_class) , _lastConnectionTickTime(millis()) -, _connectionTickTimeInterval(CHECK_INTERVAL_IDLE) , _keep_alive(false) { @@ -101,11 +110,14 @@ bool LoRaConnectionHandler::available() { NetworkConnectionState LoRaConnectionHandler::check() { unsigned long const now = millis(); - int networkStatus = 0; - if (now - _lastConnectionTickTime > _connectionTickTimeInterval) { /* time bracket */ + unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(netConnectionState)]; + if((now - _lastConnectionTickTime) > connectionTickTimeInterval) + { _lastConnectionTickTime = now; - switch (netConnectionState) { + + switch (netConnectionState) + { case NetworkConnectionState::INIT: netConnectionState = update_handleInit(); break; case NetworkConnectionState::CONNECTING: netConnectionState = update_handleConnecting(); break; case NetworkConnectionState::CONNECTED: netConnectionState = update_handleConnected(); break; @@ -148,7 +160,6 @@ NetworkConnectionState LoRaConnectionHandler::update_handleInit() { _modem.configureClass(_device_class); delay(100); Debug.print(DBG_INFO, "Connecting to the network"); - _connectionTickTimeInterval = CHECK_INTERVAL_CONNECTING; return NetworkConnectionState::CONNECTING; } @@ -162,7 +173,6 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnecting() { } Debug.print(DBG_INFO, "Connected to the network"); - _connectionTickTimeInterval = CHECK_INTERVAL_CONNECTED; execCallback(NetworkConnectionEvent::CONNECTED, 0); return NetworkConnectionState::CONNECTED; } @@ -178,7 +188,6 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnected() { if (_keep_alive) { Debug.print(DBG_ERROR, "Attempting reconnection"); } - _connectionTickTimeInterval = CHECK_INTERVAL_DISCONNECTED; return NetworkConnectionState::DISCONNECTED; } Debug.print(DBG_VERBOSE, "Connected to the network"); @@ -193,20 +202,17 @@ NetworkConnectionState LoRaConnectionHandler::update_handleDisconnecting() { if (_keep_alive) { Debug.print(DBG_ERROR, "Attempting reconnection"); } - _connectionTickTimeInterval = CHECK_INTERVAL_DISCONNECTED; return NetworkConnectionState::DISCONNECTED; } NetworkConnectionState LoRaConnectionHandler::update_handleDisconnected() { if (_keep_alive) { Debug.print(DBG_VERBOSE, "CHANGING STATE TO ::INIT"); - _connectionTickTimeInterval = CHECK_INTERVAL_INIT; return NetworkConnectionState::INIT; } else { Debug.print(DBG_VERBOSE, "Connection to the network terminated"); return NetworkConnectionState::CLOSED; } - } #endif diff --git a/src/Arduino_LoRaConnectionHandler.h b/src/Arduino_LoRaConnectionHandler.h index 78dd5ccd..1ec7653a 100644 --- a/src/Arduino_LoRaConnectionHandler.h +++ b/src/Arduino_LoRaConnectionHandler.h @@ -69,7 +69,6 @@ class LoRaConnectionHandler : public ConnectionHandler { _lora_band _band; _lora_class _device_class; unsigned long _lastConnectionTickTime; - int _connectionTickTimeInterval; bool _keep_alive; LoRaModem _modem; diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp index a9b6e700..dff4d343 100644 --- a/src/Arduino_WiFiConnectionHandler.cpp +++ b/src/Arduino_WiFiConnectionHandler.cpp @@ -23,6 +23,10 @@ #ifdef BOARD_HAS_WIFI /* Only compile if the board has WiFi */ +/****************************************************************************** + CONSTANTS + ******************************************************************************/ + static unsigned int const CHECK_INTERVAL_TABLE[] = { /* INIT */ 100, From 37f9228bc91813207b93409adaea259805f2a3f9 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 09:12:29 +0100 Subject: [PATCH 28/54] Major simplification of existing code --- src/Arduino_LoRaConnectionHandler.cpp | 154 ++++++++++++++------------ src/Arduino_LoRaConnectionHandler.h | 32 +----- 2 files changed, 90 insertions(+), 96 deletions(-) diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp index d2da8e5f..c3145031 100644 --- a/src/Arduino_LoRaConnectionHandler.cpp +++ b/src/Arduino_LoRaConnectionHandler.cpp @@ -23,6 +23,23 @@ #include "Arduino_LoRaConnectionHandler.h" +/****************************************************************************** + TYPEDEF + ******************************************************************************/ + +typedef enum +{ + LORA_ERROR_ACK_NOT_RECEIVED = -1, + LORA_ERROR_GENERIC = -2, + LORA_ERROR_WRONG_PARAM = -3, + LORA_ERROR_COMMUNICATION_BUSY = -4, + LORA_ERROR_MESSAGE_OVERFLOW = -5, + LORA_ERROR_NO_NETWORK_AVAILABLE = -6, + LORA_ERROR_RX_PACKET = -7, + LORA_ERROR_REASON_UNKNOWN = -8, + LORA_ERROR_MAX_PACKET_SIZE = -20 +} LoRaCommunicationError; + /****************************************************************************** CONSTANTS ******************************************************************************/ @@ -58,57 +75,8 @@ LoRaConnectionHandler::LoRaConnectionHandler(char const * appeui, char const * a PUBLIC MEMBER FUNCTIONS ******************************************************************************/ -int LoRaConnectionHandler::write(const uint8_t *buf, size_t size) { - int err; - _modem.beginPacket(); - _modem.write(buf, size); - err = _modem.endPacket(true); - if (err != size) { - switch (err) { - case LoRaCommunicationError::LORA_ERROR_ACK_NOT_RECEIVED: { - Debug.print(DBG_ERROR, "Message ack was not received, the message could not be delivered"); - } break; - case LoRaCommunicationError::LORA_ERROR_GENERIC: { - Debug.print(DBG_ERROR, "LoRa generic error (LORA_ERROR)"); - } break; - case LoRaCommunicationError::LORA_ERROR_WRONG_PARAM: { - Debug.print(DBG_ERROR, "LoRa malformed param error (LORA_ERROR_PARAM"); - } break; - case LoRaCommunicationError::LORA_ERROR_COMMUNICATION_BUSY: { - Debug.print(DBG_ERROR, "LoRa chip is busy (LORA_ERROR_BUSY)"); - } break; - case LoRaCommunicationError::LORA_ERROR_MESSAGE_OVERFLOW: { - Debug.print(DBG_ERROR, "LoRa chip overflow error (LORA_ERROR_OVERFLOW)"); - } break; - case LoRaCommunicationError::LORA_ERROR_NO_NETWORK_AVAILABLE: { - Debug.print(DBG_ERROR, "LoRa no network error (LORA_ERROR_NO_NETWORK)"); - } break; - case LoRaCommunicationError::LORA_ERROR_RX_PACKET: { - Debug.print(DBG_ERROR, "LoRa rx error (LORA_ERROR_RX)"); - } break; - case LoRaCommunicationError::LORA_ERROR_REASON_UNKNOWN: { - Debug.print(DBG_ERROR, "LoRa unknown error (LORA_ERROR_UNKNOWN)"); - } break; - case LoRaCommunicationError::LORA_ERROR_MAX_PACKET_SIZE: { - Debug.print(DBG_ERROR, "Message length is bigger than max LoRa packet!"); - } break; - } - } else { - Debug.print(DBG_INFO, "Message sent correctly!"); - } - return err; -} - -int LoRaConnectionHandler::read() { - return _modem.read(); -} - -bool LoRaConnectionHandler::available() { - return _modem.available(); -} - -NetworkConnectionState LoRaConnectionHandler::check() { - +NetworkConnectionState LoRaConnectionHandler::check() +{ unsigned long const now = millis(); unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(netConnectionState)]; @@ -118,11 +86,11 @@ NetworkConnectionState LoRaConnectionHandler::check() { switch (netConnectionState) { - case NetworkConnectionState::INIT: netConnectionState = update_handleInit(); break; - case NetworkConnectionState::CONNECTING: netConnectionState = update_handleConnecting(); break; - case NetworkConnectionState::CONNECTED: netConnectionState = update_handleConnected(); break; + case NetworkConnectionState::INIT: netConnectionState = update_handleInit(); break; + case NetworkConnectionState::CONNECTING: netConnectionState = update_handleConnecting(); break; + case NetworkConnectionState::CONNECTED: netConnectionState = update_handleConnected(); break; case NetworkConnectionState::DISCONNECTING: netConnectionState = update_handleDisconnecting(); break; - case NetworkConnectionState::DISCONNECTED: netConnectionState = update_handleDisconnected(); break; + case NetworkConnectionState::DISCONNECTED: netConnectionState = update_handleDisconnected(); break; case NetworkConnectionState::ERROR: break; case NetworkConnectionState::CLOSED: break; } @@ -131,6 +99,44 @@ NetworkConnectionState LoRaConnectionHandler::check() { return netConnectionState; } +int LoRaConnectionHandler::write(const uint8_t * buf, size_t size) +{ + _modem.beginPacket(); + _modem.write(buf, size); + int const err = _modem.endPacket(true); + + if (err != size) + { + switch (err) + { + case LoRaCommunicationError::LORA_ERROR_ACK_NOT_RECEIVED: Debug.print(DBG_ERROR, "Message ack was not received, the message could not be delivered"); break; + case LoRaCommunicationError::LORA_ERROR_GENERIC: Debug.print(DBG_ERROR, "LoRa generic error (LORA_ERROR)"); break; + case LoRaCommunicationError::LORA_ERROR_WRONG_PARAM: Debug.print(DBG_ERROR, "LoRa malformed param error (LORA_ERROR_PARAM"); break; + case LoRaCommunicationError::LORA_ERROR_COMMUNICATION_BUSY: Debug.print(DBG_ERROR, "LoRa chip is busy (LORA_ERROR_BUSY)"); break; + case LoRaCommunicationError::LORA_ERROR_MESSAGE_OVERFLOW: Debug.print(DBG_ERROR, "LoRa chip overflow error (LORA_ERROR_OVERFLOW)"); break; + case LoRaCommunicationError::LORA_ERROR_NO_NETWORK_AVAILABLE: Debug.print(DBG_ERROR, "LoRa no network error (LORA_ERROR_NO_NETWORK)"); break; + case LoRaCommunicationError::LORA_ERROR_RX_PACKET: Debug.print(DBG_ERROR, "LoRa rx error (LORA_ERROR_RX)"); break; + case LoRaCommunicationError::LORA_ERROR_REASON_UNKNOWN: Debug.print(DBG_ERROR, "LoRa unknown error (LORA_ERROR_UNKNOWN)"); break; + case LoRaCommunicationError::LORA_ERROR_MAX_PACKET_SIZE: Debug.print(DBG_ERROR, "Message length is bigger than max LoRa packet!"); break; + } + } + else + { + Debug.print(DBG_INFO, "Message sent correctly!"); + } + return err; +} + +int LoRaConnectionHandler::read() +{ + return _modem.read(); +} + +bool LoRaConnectionHandler::available() +{ + return _modem.available(); +} + void LoRaConnectionHandler::connect() { if (netConnectionState != NetworkConnectionState::INIT && netConnectionState != NetworkConnectionState::CONNECTING) @@ -148,13 +154,15 @@ void LoRaConnectionHandler::disconnect() PRIVATE MEMBER FUNCTIONS ******************************************************************************/ -NetworkConnectionState LoRaConnectionHandler::update_handleInit() { +NetworkConnectionState LoRaConnectionHandler::update_handleInit() +{ Debug.print(DBG_VERBOSE, "::INIT"); - if (!_modem.begin(_band)) { + if (!_modem.begin(_band)) + { Debug.print(DBG_VERBOSE, "Failed to start module"); execCallback(NetworkConnectionEvent::ERROR, 0); Debug.print(DBG_ERROR, "Something went wrong; are you indoor? Move near a window, then reset and retry."); - }; + } //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 delay(100); _modem.configureClass(_device_class); @@ -163,10 +171,12 @@ NetworkConnectionState LoRaConnectionHandler::update_handleInit() { return NetworkConnectionState::CONNECTING; } -NetworkConnectionState LoRaConnectionHandler::update_handleConnecting() { +NetworkConnectionState LoRaConnectionHandler::update_handleConnecting() +{ Debug.print(DBG_VERBOSE, "::CONNECTING"); bool const network_status = _modem.joinOTAA(_appeui, _appkey); - if (network_status != true) { + if (network_status != true) + { execCallback(NetworkConnectionEvent::ERROR, 0); Debug.print(DBG_ERROR, "Something went wrong; are you indoor? Move near a window, then reset and retry."); return NetworkConnectionState::ERROR; @@ -177,39 +187,45 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnecting() { return NetworkConnectionState::CONNECTED; } -NetworkConnectionState LoRaConnectionHandler::update_handleConnected() { - +NetworkConnectionState LoRaConnectionHandler::update_handleConnected() +{ bool const network_status = _modem.connected(); Debug.print(DBG_VERBOSE, "Connection state: %d", network_status); if (network_status != true) { execCallback(NetworkConnectionEvent::DISCONNECTED, 0); Debug.print(DBG_ERROR, "Connection to the network lost."); - if (_keep_alive) { + if (_keep_alive) + { Debug.print(DBG_ERROR, "Attempting reconnection"); } return NetworkConnectionState::DISCONNECTED; } Debug.print(DBG_VERBOSE, "Connected to the network"); - return NetworkConnectionState::CONNECTED; } -NetworkConnectionState LoRaConnectionHandler::update_handleDisconnecting() { +NetworkConnectionState LoRaConnectionHandler::update_handleDisconnecting() +{ execCallback(NetworkConnectionEvent::DISCONNECTED, 0); Debug.print(DBG_ERROR, "Connection to the network lost."); - if (_keep_alive) { + if (_keep_alive) + { Debug.print(DBG_ERROR, "Attempting reconnection"); } return NetworkConnectionState::DISCONNECTED; } -NetworkConnectionState LoRaConnectionHandler::update_handleDisconnected() { - if (_keep_alive) { +NetworkConnectionState LoRaConnectionHandler::update_handleDisconnected() +{ + if (_keep_alive) + { Debug.print(DBG_VERBOSE, "CHANGING STATE TO ::INIT"); return NetworkConnectionState::INIT; - } else { + } + else + { Debug.print(DBG_VERBOSE, "Connection to the network terminated"); return NetworkConnectionState::CLOSED; } diff --git a/src/Arduino_LoRaConnectionHandler.h b/src/Arduino_LoRaConnectionHandler.h index 1ec7653a..dd88f4c5 100644 --- a/src/Arduino_LoRaConnectionHandler.h +++ b/src/Arduino_LoRaConnectionHandler.h @@ -24,45 +24,26 @@ #include "Arduino_ConnectionHandler.h" -typedef enum { - LORA_ERROR_ACK_NOT_RECEIVED = -1, - LORA_ERROR_GENERIC = -2, - LORA_ERROR_WRONG_PARAM = -3, - LORA_ERROR_COMMUNICATION_BUSY = -4, - LORA_ERROR_MESSAGE_OVERFLOW = -5, - LORA_ERROR_NO_NETWORK_AVAILABLE = -6, - LORA_ERROR_RX_PACKET = -7, - LORA_ERROR_REASON_UNKNOWN = -8, - LORA_ERROR_MAX_PACKET_SIZE = -20 -} LoRaCommunicationError; - /****************************************************************************** CLASS DECLARATION ******************************************************************************/ -class LoRaConnectionHandler : public ConnectionHandler { +class LoRaConnectionHandler : public ConnectionHandler +{ public: + LoRaConnectionHandler(char const * appeui, char const * appkey, _lora_band const band = _lora_band::EU868, _lora_class const device_class = _lora_class::CLASS_A); - virtual NetworkConnectionState check(); + virtual NetworkConnectionState check(); virtual int write(const uint8_t *buf, size_t size); virtual int read(); virtual bool available(); - virtual void disconnect(); virtual void connect(); - private: - const int CHECK_INTERVAL_IDLE = 100; - const int CHECK_INTERVAL_INIT = 100; - const int CHECK_INTERVAL_CONNECTING = 500; - const int CHECK_INTERVAL_CONNECTED = 10000; - const int CHECK_INTERVAL_RETRYING = 30000; - const int CHECK_INTERVAL_DISCONNECTING = 500; - const int CHECK_INTERVAL_DISCONNECTED = 1000; - const int CHECK_INTERVAL_ERROR = 500; + private: char const * _appeui; char const * _appkey; @@ -75,11 +56,8 @@ class LoRaConnectionHandler : public ConnectionHandler { NetworkConnectionState update_handleInit(); NetworkConnectionState update_handleConnecting(); NetworkConnectionState update_handleConnected(); - NetworkConnectionState update_handleDisconnecting(); NetworkConnectionState update_handleDisconnected(); - - }; #endif /* ARDUINO_LORA_CONNECTION_HANDLER_H_ */ From 11f936fdcc17dfea64a7255ffc73c25e9de4bd26 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 09:14:42 +0100 Subject: [PATCH 29/54] Adding keyword override to allow compiler check if really a base class function is overwritten --- src/Arduino_LoRaConnectionHandler.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/Arduino_LoRaConnectionHandler.h b/src/Arduino_LoRaConnectionHandler.h index dd88f4c5..d641dce3 100644 --- a/src/Arduino_LoRaConnectionHandler.h +++ b/src/Arduino_LoRaConnectionHandler.h @@ -35,12 +35,12 @@ class LoRaConnectionHandler : public ConnectionHandler LoRaConnectionHandler(char const * appeui, char const * appkey, _lora_band const band = _lora_band::EU868, _lora_class const device_class = _lora_class::CLASS_A); - virtual NetworkConnectionState check(); - virtual int write(const uint8_t *buf, size_t size); - virtual int read(); - virtual bool available(); - virtual void disconnect(); - virtual void connect(); + virtual NetworkConnectionState check() override; + virtual int write(const uint8_t *buf, size_t size) override; + virtual int read() override; + virtual bool available() override; + virtual void disconnect() override; + virtual void connect() override; private: From ffaa0f1a7130ed08c0af908632e5753bc79a97fd Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 09:17:42 +0100 Subject: [PATCH 30/54] Deleting all debug statements with verbose debug output - development has been done so there is no need for them but they clutter code space and flash space --- src/Arduino_GSMConnectionHandler.cpp | 4 ---- src/Arduino_LoRaConnectionHandler.cpp | 7 ------- src/Arduino_WiFiConnectionHandler.cpp | 9 --------- 3 files changed, 20 deletions(-) diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index 96f0965c..778a7ccc 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -101,7 +101,6 @@ NetworkConnectionState GSMConnectionHandler::check() void GSMConnectionHandler::disconnect() { - Debug.print(DBG_VERBOSE, "Disconnecting from Cellular Network"); _gsm.shutdown(); _keep_alive = false; netConnectionState = NetworkConnectionState::DISCONNECTING; @@ -167,13 +166,11 @@ NetworkConnectionState GSMConnectionHandler::update_handleConnecting() NetworkConnectionState GSMConnectionHandler::update_handleConnected() { int const is_gsm_access_alive = _gsm.isAccessAlive(); - Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", is_gsm_access_alive); if (is_gsm_access_alive != 1) { execCallback(NetworkConnectionEvent::DISCONNECTED, 0); return NetworkConnectionState::DISCONNECTED; } - Debug.print(DBG_VERBOSE, "Connected to Cellular Network"); return NetworkConnectionState::CONNECTED; } @@ -187,7 +184,6 @@ NetworkConnectionState GSMConnectionHandler::update_handleDisconnected() { if (_keep_alive) { - Debug.print(DBG_VERBOSE, "keep alive > INIT"); return NetworkConnectionState::INIT; } else diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp index c3145031..f3ddec27 100644 --- a/src/Arduino_LoRaConnectionHandler.cpp +++ b/src/Arduino_LoRaConnectionHandler.cpp @@ -156,10 +156,8 @@ void LoRaConnectionHandler::disconnect() NetworkConnectionState LoRaConnectionHandler::update_handleInit() { - Debug.print(DBG_VERBOSE, "::INIT"); if (!_modem.begin(_band)) { - Debug.print(DBG_VERBOSE, "Failed to start module"); execCallback(NetworkConnectionEvent::ERROR, 0); Debug.print(DBG_ERROR, "Something went wrong; are you indoor? Move near a window, then reset and retry."); } @@ -173,7 +171,6 @@ NetworkConnectionState LoRaConnectionHandler::update_handleInit() NetworkConnectionState LoRaConnectionHandler::update_handleConnecting() { - Debug.print(DBG_VERBOSE, "::CONNECTING"); bool const network_status = _modem.joinOTAA(_appeui, _appkey); if (network_status != true) { @@ -190,7 +187,6 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnecting() NetworkConnectionState LoRaConnectionHandler::update_handleConnected() { bool const network_status = _modem.connected(); - Debug.print(DBG_VERBOSE, "Connection state: %d", network_status); if (network_status != true) { execCallback(NetworkConnectionEvent::DISCONNECTED, 0); @@ -201,7 +197,6 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnected() } return NetworkConnectionState::DISCONNECTED; } - Debug.print(DBG_VERBOSE, "Connected to the network"); return NetworkConnectionState::CONNECTED; } @@ -221,12 +216,10 @@ NetworkConnectionState LoRaConnectionHandler::update_handleDisconnected() { if (_keep_alive) { - Debug.print(DBG_VERBOSE, "CHANGING STATE TO ::INIT"); return NetworkConnectionState::INIT; } else { - Debug.print(DBG_VERBOSE, "Connection to the network terminated"); return NetworkConnectionState::CLOSED; } } diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp index dff4d343..1f07c67a 100644 --- a/src/Arduino_WiFiConnectionHandler.cpp +++ b/src/Arduino_WiFiConnectionHandler.cpp @@ -111,8 +111,6 @@ void WiFiConnectionHandler::disconnect() NetworkConnectionState WiFiConnectionHandler::update_handleInit() { - Debug.print(DBG_VERBOSE, "::INIT"); - #ifndef BOARD_ESP8266 Debug.print(DBG_INFO, "WiFi.status(): %d", WiFi.status()); if (WiFi.status() == NETWORK_HARDWARE_ERROR) @@ -144,8 +142,6 @@ NetworkConnectionState WiFiConnectionHandler::update_handleInit() NetworkConnectionState WiFiConnectionHandler::update_handleConnecting() { - Debug.print(DBG_VERBOSE, "::CONNECTING"); - #ifndef BOARD_ESP8266 if (WiFi.status() != WL_CONNECTED) { @@ -153,7 +149,6 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnecting() } #endif /* ifndef BOARD_ESP8266 */ - Debug.print(DBG_VERBOSE, "WiFi.status(): %d", WiFi.status()); if (WiFi.status() != NETWORK_CONNECTED) { Debug.print(DBG_ERROR, "Connection to \"%s\" failed", _ssid); @@ -170,7 +165,6 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnecting() NetworkConnectionState WiFiConnectionHandler::update_handleConnected() { - Debug.print(DBG_VERBOSE, "WiFi.status(): %d", WiFi.status()); if (WiFi.status() != WL_CONNECTED) { execCallback(NetworkConnectionEvent::DISCONNECTED, 0); @@ -190,7 +184,6 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnected() NetworkConnectionState WiFiConnectionHandler::update_handleGetTime() { - Debug.print(DBG_VERBOSE, "NetworkConnectionState::GETTIME"); #ifdef BOARD_ESP8266 configTime(0, 0, "time.arduino.cc", "pool.ntp.org", "time.nist.gov"); #endif @@ -199,7 +192,6 @@ NetworkConnectionState WiFiConnectionHandler::update_handleGetTime() NetworkConnectionState WiFiConnectionHandler::update_handleDisconnecting() { - Debug.print(DBG_VERBOSE, "Disconnecting from \"%s\"", _ssid); WiFi.disconnect(); return NetworkConnectionState::DISCONNECTED; } @@ -215,7 +207,6 @@ NetworkConnectionState WiFiConnectionHandler::update_handleDisconnected() } else { - Debug.print(DBG_VERBOSE, "Connection to \"%s\" closed", _ssid); return NetworkConnectionState::CLOSED; } } From a39cd7765aedc0378ef5ec442a5395ddda5a7d5d Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 09:20:38 +0100 Subject: [PATCH 31/54] Prefixing member variable netConnectionState with '_' to mark it as a member variable --- src/Arduino_ConnectionHandler.h | 4 ++-- src/Arduino_GSMConnectionHandler.cpp | 22 +++++++++++----------- src/Arduino_LoRaConnectionHandler.cpp | 20 ++++++++++---------- src/Arduino_NBConnectionHandler.cpp | 18 +++++++++--------- src/Arduino_WiFiConnectionHandler.cpp | 24 ++++++++++++------------ 5 files changed, 44 insertions(+), 44 deletions(-) diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h index 2b9ba705..52586003 100644 --- a/src/Arduino_ConnectionHandler.h +++ b/src/Arduino_ConnectionHandler.h @@ -151,7 +151,7 @@ class ConnectionHandler { #endif virtual NetworkConnectionState getStatus() __attribute__((deprecated)) { - return netConnectionState; + return _netConnectionState; } virtual void connect() = 0; virtual void disconnect() = 0; @@ -162,7 +162,7 @@ class ConnectionHandler { protected: - NetworkConnectionState netConnectionState = NetworkConnectionState::INIT; + NetworkConnectionState _netConnectionState = NetworkConnectionState::INIT; void execCallback(NetworkConnectionEvent const event, void * callback_arg); diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index 778a7ccc..6a0b3037 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -77,41 +77,41 @@ unsigned long GSMConnectionHandler::getTime() NetworkConnectionState GSMConnectionHandler::check() { unsigned long const now = millis(); - unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(netConnectionState)]; + unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(_netConnectionState)]; if((now - _lastConnectionTickTime) > connectionTickTimeInterval) { _lastConnectionTickTime = now; - switch (netConnectionState) + switch (_netConnectionState) { - case NetworkConnectionState::INIT: netConnectionState = update_handleInit(); break; - case NetworkConnectionState::CONNECTING: netConnectionState = update_handleConnecting(); break; - case NetworkConnectionState::CONNECTED: netConnectionState = update_handleConnected(); break; + case NetworkConnectionState::INIT: _netConnectionState = update_handleInit(); break; + case NetworkConnectionState::CONNECTING: _netConnectionState = update_handleConnecting(); break; + case NetworkConnectionState::CONNECTED: _netConnectionState = update_handleConnected(); break; case NetworkConnectionState::GETTIME: /* Unused */ break; - case NetworkConnectionState::DISCONNECTING: netConnectionState = update_handleDisconnecting(); break; - case NetworkConnectionState::DISCONNECTED: netConnectionState = update_handleDisconnected(); break; + case NetworkConnectionState::DISCONNECTING: _netConnectionState = update_handleDisconnecting(); break; + case NetworkConnectionState::DISCONNECTED: _netConnectionState = update_handleDisconnected(); break; case NetworkConnectionState::ERROR: break; case NetworkConnectionState::CLOSED: break; } } - return netConnectionState; + return _netConnectionState; } void GSMConnectionHandler::disconnect() { _gsm.shutdown(); _keep_alive = false; - netConnectionState = NetworkConnectionState::DISCONNECTING; + _netConnectionState = NetworkConnectionState::DISCONNECTING; } void GSMConnectionHandler::connect() { - if (netConnectionState != NetworkConnectionState::INIT && netConnectionState != NetworkConnectionState::CONNECTING) + if (_netConnectionState != NetworkConnectionState::INIT && _netConnectionState != NetworkConnectionState::CONNECTING) { _keep_alive = true; - netConnectionState = NetworkConnectionState::INIT; + _netConnectionState = NetworkConnectionState::INIT; } } diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp index f3ddec27..05b9b9ab 100644 --- a/src/Arduino_LoRaConnectionHandler.cpp +++ b/src/Arduino_LoRaConnectionHandler.cpp @@ -78,25 +78,25 @@ LoRaConnectionHandler::LoRaConnectionHandler(char const * appeui, char const * a NetworkConnectionState LoRaConnectionHandler::check() { unsigned long const now = millis(); - unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(netConnectionState)]; + unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(_netConnectionState)]; if((now - _lastConnectionTickTime) > connectionTickTimeInterval) { _lastConnectionTickTime = now; - switch (netConnectionState) + switch (_netConnectionState) { - case NetworkConnectionState::INIT: netConnectionState = update_handleInit(); break; - case NetworkConnectionState::CONNECTING: netConnectionState = update_handleConnecting(); break; - case NetworkConnectionState::CONNECTED: netConnectionState = update_handleConnected(); break; - case NetworkConnectionState::DISCONNECTING: netConnectionState = update_handleDisconnecting(); break; - case NetworkConnectionState::DISCONNECTED: netConnectionState = update_handleDisconnected(); break; + case NetworkConnectionState::INIT: _netConnectionState = update_handleInit(); break; + case NetworkConnectionState::CONNECTING: _netConnectionState = update_handleConnecting(); break; + case NetworkConnectionState::CONNECTED: _netConnectionState = update_handleConnected(); break; + case NetworkConnectionState::DISCONNECTING: _netConnectionState = update_handleDisconnecting(); break; + case NetworkConnectionState::DISCONNECTED: _netConnectionState = update_handleDisconnected(); break; case NetworkConnectionState::ERROR: break; case NetworkConnectionState::CLOSED: break; } } - return netConnectionState; + return _netConnectionState; } int LoRaConnectionHandler::write(const uint8_t * buf, size_t size) @@ -139,10 +139,10 @@ bool LoRaConnectionHandler::available() void LoRaConnectionHandler::connect() { - if (netConnectionState != NetworkConnectionState::INIT && netConnectionState != NetworkConnectionState::CONNECTING) + if (_netConnectionState != NetworkConnectionState::INIT && _netConnectionState != NetworkConnectionState::CONNECTING) { _keep_alive = true; - netConnectionState = NetworkConnectionState::INIT; + _netConnectionState = NetworkConnectionState::INIT; } } void LoRaConnectionHandler::disconnect() diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp index 50500a3c..aa63ce1b 100644 --- a/src/Arduino_NBConnectionHandler.cpp +++ b/src/Arduino_NBConnectionHandler.cpp @@ -82,7 +82,7 @@ NetworkConnectionState NBConnectionHandler::check() { unsigned long const now = millis(); int nbAccessAlive; if (now - lastConnectionTickTime > connectionTickTimeInterval) { - switch (netConnectionState) { + switch (_netConnectionState) { case NetworkConnectionState::INIT: { init(); } @@ -96,7 +96,7 @@ NetworkConnectionState NBConnectionHandler::check() { if (networkStatus == NB_NetworkStatus_t::ERROR) { // NO FURTHER ACTION WILL FOLLOW THIS changeConnectionState(NetworkConnectionState::ERROR); - return netConnectionState; + return _netConnectionState; } Debug.print(DBG_INFO, "Sending PING to outer space..."); int pingResult; @@ -106,11 +106,11 @@ NetworkConnectionState NBConnectionHandler::check() { if (pingResult < 0) { Debug.print(DBG_ERROR, "PING failed"); Debug.print(DBG_INFO, "Retrying in \"%d\" milliseconds", connectionTickTimeInterval); - return netConnectionState; + return _netConnectionState; } else { Debug.print(DBG_INFO, "Connected to GPRS Network"); changeConnectionState(NetworkConnectionState::CONNECTED); - return netConnectionState; + return _netConnectionState; } } break; @@ -119,7 +119,7 @@ NetworkConnectionState NBConnectionHandler::check() { Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", nbAccessAlive); if (nbAccessAlive != 1) { changeConnectionState(NetworkConnectionState::DISCONNECTED); - return netConnectionState; + return _netConnectionState; } Debug.print(DBG_VERBOSE, "Connected to Cellular Network"); } @@ -139,7 +139,7 @@ NetworkConnectionState NBConnectionHandler::check() { lastConnectionTickTime = now; } - return netConnectionState; + return _netConnectionState; } /****************************************************************************** @@ -171,7 +171,7 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState nbAccess.shutdown(); } case NetworkConnectionState::DISCONNECTED: { - if (netConnectionState == NetworkConnectionState::CONNECTED) { + if (_netConnectionState == NetworkConnectionState::CONNECTED) { execCallback(NetworkConnectionEvent::DISCONNECTED, 0); Debug.print(DBG_ERROR, "Disconnected from Cellular Network"); Debug.print(DBG_ERROR, "Attempting reconnection"); @@ -190,12 +190,12 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState } connectionTickTimeInterval = newInterval; lastConnectionTickTime = millis(); - netConnectionState = _newState; + _netConnectionState = _newState; } void NBConnectionHandler::connect() { - if (netConnectionState == NetworkConnectionState::INIT || netConnectionState == NetworkConnectionState::CONNECTING) { + if (_netConnectionState == NetworkConnectionState::INIT || _netConnectionState == NetworkConnectionState::CONNECTING) { return; } keepAlive = true; diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp index 1f07c67a..3966fedf 100644 --- a/src/Arduino_WiFiConnectionHandler.cpp +++ b/src/Arduino_WiFiConnectionHandler.cpp @@ -68,26 +68,26 @@ unsigned long WiFiConnectionHandler::getTime() NetworkConnectionState WiFiConnectionHandler::check() { unsigned long const now = millis(); - unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(netConnectionState)]; + unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(_netConnectionState)]; if((now - _lastConnectionTickTime) > connectionTickTimeInterval) { _lastConnectionTickTime = now; - switch (netConnectionState) + switch (_netConnectionState) { - case NetworkConnectionState::INIT: netConnectionState = update_handleInit (); break; - case NetworkConnectionState::CONNECTING: netConnectionState = update_handleConnecting (); break; - case NetworkConnectionState::CONNECTED: netConnectionState = update_handleConnected (); break; - case NetworkConnectionState::GETTIME: netConnectionState = update_handleGetTime (); break; - case NetworkConnectionState::DISCONNECTING: netConnectionState = update_handleDisconnecting(); break; - case NetworkConnectionState::DISCONNECTED: netConnectionState = update_handleDisconnected (); break; + case NetworkConnectionState::INIT: _netConnectionState = update_handleInit (); break; + case NetworkConnectionState::CONNECTING: _netConnectionState = update_handleConnecting (); break; + case NetworkConnectionState::CONNECTED: _netConnectionState = update_handleConnected (); break; + case NetworkConnectionState::GETTIME: _netConnectionState = update_handleGetTime (); break; + case NetworkConnectionState::DISCONNECTING: _netConnectionState = update_handleDisconnecting(); break; + case NetworkConnectionState::DISCONNECTED: _netConnectionState = update_handleDisconnected (); break; case NetworkConnectionState::ERROR: break; case NetworkConnectionState::CLOSED: break; } } - return netConnectionState; + return _netConnectionState; } /****************************************************************************** @@ -96,17 +96,17 @@ NetworkConnectionState WiFiConnectionHandler::check() void WiFiConnectionHandler::connect() { - if (netConnectionState != NetworkConnectionState::INIT && netConnectionState != NetworkConnectionState::CONNECTING) + if (_netConnectionState != NetworkConnectionState::INIT && _netConnectionState != NetworkConnectionState::CONNECTING) { _keep_alive = true; - netConnectionState = NetworkConnectionState::INIT; + _netConnectionState = NetworkConnectionState::INIT; } } void WiFiConnectionHandler::disconnect() { _keep_alive = false; - netConnectionState = NetworkConnectionState::DISCONNECTING; + _netConnectionState = NetworkConnectionState::DISCONNECTING; } NetworkConnectionState WiFiConnectionHandler::update_handleInit() From 7b7f0fbe18854dbdfbbea736bd11f606798e4b9a Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 09:21:19 +0100 Subject: [PATCH 32/54] Fixing formatting --- src/Arduino_GSMConnectionHandler.cpp | 6 +++--- src/Arduino_WiFiConnectionHandler.cpp | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index 6a0b3037..474eea33 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -88,11 +88,11 @@ NetworkConnectionState GSMConnectionHandler::check() case NetworkConnectionState::INIT: _netConnectionState = update_handleInit(); break; case NetworkConnectionState::CONNECTING: _netConnectionState = update_handleConnecting(); break; case NetworkConnectionState::CONNECTED: _netConnectionState = update_handleConnected(); break; - case NetworkConnectionState::GETTIME: /* Unused */ break; + case NetworkConnectionState::GETTIME: /* Unused */ break; case NetworkConnectionState::DISCONNECTING: _netConnectionState = update_handleDisconnecting(); break; case NetworkConnectionState::DISCONNECTED: _netConnectionState = update_handleDisconnected(); break; - case NetworkConnectionState::ERROR: break; - case NetworkConnectionState::CLOSED: break; + case NetworkConnectionState::ERROR: break; + case NetworkConnectionState::CLOSED: break; } } diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp index 3966fedf..eab65210 100644 --- a/src/Arduino_WiFiConnectionHandler.cpp +++ b/src/Arduino_WiFiConnectionHandler.cpp @@ -82,8 +82,8 @@ NetworkConnectionState WiFiConnectionHandler::check() case NetworkConnectionState::GETTIME: _netConnectionState = update_handleGetTime (); break; case NetworkConnectionState::DISCONNECTING: _netConnectionState = update_handleDisconnecting(); break; case NetworkConnectionState::DISCONNECTED: _netConnectionState = update_handleDisconnected (); break; - case NetworkConnectionState::ERROR: break; - case NetworkConnectionState::CLOSED: break; + case NetworkConnectionState::ERROR: break; + case NetworkConnectionState::CLOSED: break; } } From fb87b3b0f77ffdce47f79d45615a55fd0bf142b1 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 09:25:22 +0100 Subject: [PATCH 33/54] Removing callback arg since it is anyway always 0 and was never used --- .../ConnectionHandlerDemo.ino | 10 ++++------ src/Arduino_ConnectionHandler.cpp | 16 ++++++++-------- src/Arduino_ConnectionHandler.h | 4 ++-- src/Arduino_GSMConnectionHandler.cpp | 10 +++++----- src/Arduino_LoRaConnectionHandler.cpp | 10 +++++----- src/Arduino_NBConnectionHandler.cpp | 6 +++--- src/Arduino_WiFiConnectionHandler.cpp | 6 +++--- 7 files changed, 30 insertions(+), 32 deletions(-) diff --git a/examples/ConnectionHandlerDemo/ConnectionHandlerDemo.ino b/examples/ConnectionHandlerDemo/ConnectionHandlerDemo.ino index a2522834..3cf16200 100644 --- a/examples/ConnectionHandlerDemo/ConnectionHandlerDemo.ino +++ b/examples/ConnectionHandlerDemo/ConnectionHandlerDemo.ino @@ -35,10 +35,8 @@ void setup() { setDebugMessageLevel(DBG_INFO); - /* Register a function to be called upon connection to a network */ - conMan.addConnectCallback(onNetworkConnect); - /* Register a function to be called upon disconnection from a network */ - conMan.addDisconnectCallback(onNetworkDisconnect); + conMan.addCallback(NetworkConnectionEvent::CONNECTED, onNetworkConnect); + conMan.addCallback(NetworkConnectionEvent::DISCONNECTED, onNetworkDisconnect); } void loop() { @@ -54,10 +52,10 @@ void loop() { conMan.check(); } -void onNetworkConnect(void *_arg) { +void onNetworkConnect() { Serial.println(">>>> CONNECTED to network"); } -void onNetworkDisconnect(void *_arg) { +void onNetworkDisconnect() { Serial.println(">>>> DISCONNECTED from network"); } diff --git a/src/Arduino_ConnectionHandler.cpp b/src/Arduino_ConnectionHandler.cpp index 46157975..b9bc110c 100644 --- a/src/Arduino_ConnectionHandler.cpp +++ b/src/Arduino_ConnectionHandler.cpp @@ -51,14 +51,14 @@ void ConnectionHandler::addErrorCallback(OnNetworkEventCallback callback) { PRIVATE MEMBER FUNCTIONS ******************************************************************************/ -void ConnectionHandler::execCallback(NetworkConnectionEvent const event, void * callback_arg) { +void ConnectionHandler::execCallback(NetworkConnectionEvent const event) { switch (event) { - case NetworkConnectionEvent::CONNECTED: if(_on_connect_event_callback) _on_connect_event_callback (callback_arg); break; - case NetworkConnectionEvent::DISCONNECTED: if(_on_disconnect_event_callback) _on_disconnect_event_callback(callback_arg); break; - case NetworkConnectionEvent::ERROR: if(_on_error_event_callback) _on_error_event_callback (callback_arg); break; - case NetworkConnectionEvent::INIT: break; - case NetworkConnectionEvent::CONNECTING: break; - case NetworkConnectionEvent::DISCONNECTING: break; - case NetworkConnectionEvent::CLOSED: break; + case NetworkConnectionEvent::CONNECTED: if(_on_connect_event_callback) _on_connect_event_callback (); break; + case NetworkConnectionEvent::DISCONNECTED: if(_on_disconnect_event_callback) _on_disconnect_event_callback(); break; + case NetworkConnectionEvent::ERROR: if(_on_error_event_callback) _on_error_event_callback (); break; + case NetworkConnectionEvent::INIT: break; + case NetworkConnectionEvent::CONNECTING: break; + case NetworkConnectionEvent::DISCONNECTING: break; + case NetworkConnectionEvent::CLOSED: break; } } diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h index 52586003..c297281b 100644 --- a/src/Arduino_ConnectionHandler.h +++ b/src/Arduino_ConnectionHandler.h @@ -128,7 +128,7 @@ enum class NetworkConnectionEvent { INIT, CONNECTING, CONNECTED, DISCONNECTING, DISCONNECTED, CLOSED, ERROR }; -typedef void (*OnNetworkEventCallback)(void * /* arg */); +typedef void (*OnNetworkEventCallback)(); /****************************************************************************** CLASS DECLARATION @@ -164,7 +164,7 @@ class ConnectionHandler { NetworkConnectionState _netConnectionState = NetworkConnectionState::INIT; - void execCallback(NetworkConnectionEvent const event, void * callback_arg); + void execCallback(NetworkConnectionEvent const event); private: diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index 474eea33..05709132 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -130,7 +130,7 @@ NetworkConnectionState GSMConnectionHandler::update_handleInit() else { Debug.print(DBG_ERROR, "SIM not present or wrong PIN"); - execCallback(NetworkConnectionEvent::ERROR, 0); + execCallback(NetworkConnectionEvent::ERROR); return NetworkConnectionState::ERROR; } } @@ -143,7 +143,7 @@ NetworkConnectionState GSMConnectionHandler::update_handleConnecting() { Debug.print(DBG_ERROR, "GPRS attach failed"); Debug.print(DBG_ERROR, "Make sure the antenna is connected and reset your board."); - execCallback(NetworkConnectionEvent::ERROR, 0); + execCallback(NetworkConnectionEvent::ERROR); return NetworkConnectionState::ERROR; } Debug.print(DBG_INFO, "Sending PING to outer space..."); @@ -158,7 +158,7 @@ NetworkConnectionState GSMConnectionHandler::update_handleConnecting() else { Debug.print(DBG_INFO, "Connected to GPRS Network"); - execCallback(NetworkConnectionEvent::CONNECTED, 0); + execCallback(NetworkConnectionEvent::CONNECTED); return NetworkConnectionState::CONNECTED; } } @@ -168,7 +168,7 @@ NetworkConnectionState GSMConnectionHandler::update_handleConnected() int const is_gsm_access_alive = _gsm.isAccessAlive(); if (is_gsm_access_alive != 1) { - execCallback(NetworkConnectionEvent::DISCONNECTED, 0); + execCallback(NetworkConnectionEvent::DISCONNECTED); return NetworkConnectionState::DISCONNECTED; } return NetworkConnectionState::CONNECTED; @@ -176,7 +176,7 @@ NetworkConnectionState GSMConnectionHandler::update_handleConnected() NetworkConnectionState GSMConnectionHandler::update_handleDisconnecting() { - execCallback(NetworkConnectionEvent::DISCONNECTED, 0); + execCallback(NetworkConnectionEvent::DISCONNECTED); return NetworkConnectionState::DISCONNECTED; } diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp index 05b9b9ab..68ec06d7 100644 --- a/src/Arduino_LoRaConnectionHandler.cpp +++ b/src/Arduino_LoRaConnectionHandler.cpp @@ -158,7 +158,7 @@ NetworkConnectionState LoRaConnectionHandler::update_handleInit() { if (!_modem.begin(_band)) { - execCallback(NetworkConnectionEvent::ERROR, 0); + execCallback(NetworkConnectionEvent::ERROR); Debug.print(DBG_ERROR, "Something went wrong; are you indoor? Move near a window, then reset and retry."); } //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 @@ -174,13 +174,13 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnecting() bool const network_status = _modem.joinOTAA(_appeui, _appkey); if (network_status != true) { - execCallback(NetworkConnectionEvent::ERROR, 0); + execCallback(NetworkConnectionEvent::ERROR); Debug.print(DBG_ERROR, "Something went wrong; are you indoor? Move near a window, then reset and retry."); return NetworkConnectionState::ERROR; } Debug.print(DBG_INFO, "Connected to the network"); - execCallback(NetworkConnectionEvent::CONNECTED, 0); + execCallback(NetworkConnectionEvent::CONNECTED); return NetworkConnectionState::CONNECTED; } @@ -188,7 +188,7 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnected() { bool const network_status = _modem.connected(); if (network_status != true) { - execCallback(NetworkConnectionEvent::DISCONNECTED, 0); + execCallback(NetworkConnectionEvent::DISCONNECTED); Debug.print(DBG_ERROR, "Connection to the network lost."); if (_keep_alive) @@ -202,7 +202,7 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnected() NetworkConnectionState LoRaConnectionHandler::update_handleDisconnecting() { - execCallback(NetworkConnectionEvent::DISCONNECTED, 0); + execCallback(NetworkConnectionEvent::DISCONNECTED); Debug.print(DBG_ERROR, "Connection to the network lost."); if (_keep_alive) diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp index aa63ce1b..cf40062c 100644 --- a/src/Arduino_NBConnectionHandler.cpp +++ b/src/Arduino_NBConnectionHandler.cpp @@ -159,7 +159,7 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState } break; case NetworkConnectionState::CONNECTED: { - execCallback(NetworkConnectionEvent::CONNECTED, 0); + execCallback(NetworkConnectionEvent::CONNECTED); newInterval = CHECK_INTERVAL_CONNECTED; } break; @@ -172,7 +172,7 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState } case NetworkConnectionState::DISCONNECTED: { if (_netConnectionState == NetworkConnectionState::CONNECTED) { - execCallback(NetworkConnectionEvent::DISCONNECTED, 0); + execCallback(NetworkConnectionEvent::DISCONNECTED); Debug.print(DBG_ERROR, "Disconnected from Cellular Network"); Debug.print(DBG_ERROR, "Attempting reconnection"); if (keepAlive) { @@ -183,7 +183,7 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState } break; case NetworkConnectionState::ERROR: { - execCallback(NetworkConnectionEvent::ERROR, 0); + execCallback(NetworkConnectionEvent::ERROR); Debug.print(DBG_ERROR, "GPRS attach failed\n\rMake sure the antenna is connected and reset your board."); } break; diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp index eab65210..a6745225 100644 --- a/src/Arduino_WiFiConnectionHandler.cpp +++ b/src/Arduino_WiFiConnectionHandler.cpp @@ -115,7 +115,7 @@ NetworkConnectionState WiFiConnectionHandler::update_handleInit() Debug.print(DBG_INFO, "WiFi.status(): %d", WiFi.status()); if (WiFi.status() == NETWORK_HARDWARE_ERROR) { - execCallback(NetworkConnectionEvent::ERROR, 0); + execCallback(NetworkConnectionEvent::ERROR); Debug.print(DBG_ERROR, "WiFi Hardware failure.\nMake sure you are using a WiFi enabled board/shield."); Debug.print(DBG_ERROR, "Then reset and retry."); return NetworkConnectionState::ERROR; @@ -158,7 +158,7 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnecting() else { Debug.print(DBG_INFO, "Connected to \"%s\"", _ssid); - execCallback(NetworkConnectionEvent::CONNECTED, 0); + execCallback(NetworkConnectionEvent::CONNECTED); return NetworkConnectionState::GETTIME; } } @@ -167,7 +167,7 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnected() { if (WiFi.status() != WL_CONNECTED) { - execCallback(NetworkConnectionEvent::DISCONNECTED, 0); + execCallback(NetworkConnectionEvent::DISCONNECTED); Debug.print(DBG_VERBOSE, "WiFi.status(): %d", WiFi.status()); Debug.print(DBG_ERROR, "Connection to \"%s\" lost.", _ssid); From 7bb1b5543f6220773ea208cb0e4d2b46e4a5c238 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 10:29:16 +0100 Subject: [PATCH 34/54] Restructuring member variables --- src/Arduino_NBConnectionHandler.cpp | 60 ++++++++++++++++------------- src/Arduino_NBConnectionHandler.h | 33 +++++++--------- 2 files changed, 47 insertions(+), 46 deletions(-) diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp index cf40062c..eeec35df 100644 --- a/src/Arduino_NBConnectionHandler.cpp +++ b/src/Arduino_NBConnectionHandler.cpp @@ -41,22 +41,28 @@ static const unsigned long NETWORK_CONNECTION_INTERVAL = 30000; /****************************************************************************** CTOR/DTOR ******************************************************************************/ -NBConnectionHandler::NBConnectionHandler(const char *pin, bool _keepAlive) : - NBConnectionHandler(pin, "", _keepAlive) { +NBConnectionHandler::NBConnectionHandler(char const * pin, bool const keep_alive) +: NBConnectionHandler(pin, "", keep_alive) +{ + } -NBConnectionHandler::NBConnectionHandler(const char *pin, const char *apn, bool _keepAlive) : - NBConnectionHandler(pin, apn, "", "", _keepAlive) { +NBConnectionHandler::NBConnectionHandler(char const * pin, char const * apn, bool const keep_alive) +: NBConnectionHandler(pin, apn, "", "", keep_alive) +{ + } -NBConnectionHandler::NBConnectionHandler(const char *pin, const char *apn, const char *login, const char *pass, bool _keepAlive) : - pin(pin), - apn(apn), - login(login), - pass(pass), - lastConnectionTickTime(millis()), - connectionTickTimeInterval(CHECK_INTERVAL_IDLE), - keepAlive(_keepAlive) { +NBConnectionHandler::NBConnectionHandler(char const * pin, char const * apn, char const * login, char const * pass, bool const keep_alive) +: _pin(pin) +, _apn(apn) +, _login(login) +, _pass(pass) +, lastConnectionTickTime(millis()) +, connectionTickTimeInterval(CHECK_INTERVAL_IDLE) +, _keep_alive(keep_alive) +{ + } /****************************************************************************** @@ -65,9 +71,9 @@ NBConnectionHandler::NBConnectionHandler(const char *pin, const char *apn, const void NBConnectionHandler::init() { char msgBuffer[120]; - if (nbAccess.begin(pin, apn, login, pass) == NB_READY) { + if (_nb.begin(_pin, _apn, _login, _pass) == NB_READY) { Debug.print(DBG_INFO, "SIM card ok"); - nbAccess.setTimeout(CHECK_INTERVAL_RETRYING); + _nb.setTimeout(CHECK_INTERVAL_RETRYING); changeConnectionState(NetworkConnectionState::CONNECTING); } else { Debug.print(DBG_ERROR, "SIM not present or wrong PIN"); @@ -75,12 +81,12 @@ void NBConnectionHandler::init() { } unsigned long NBConnectionHandler::getTime() { - return nbAccess.getTime(); + return _nb.getTime(); } NetworkConnectionState NBConnectionHandler::check() { unsigned long const now = millis(); - int nbAccessAlive; + int _nbAlive; if (now - lastConnectionTickTime > connectionTickTimeInterval) { switch (_netConnectionState) { case NetworkConnectionState::INIT: { @@ -91,7 +97,7 @@ NetworkConnectionState NBConnectionHandler::check() { case NetworkConnectionState::CONNECTING: { // NOTE: Blocking Call when 4th parameter == true NB_NetworkStatus_t networkStatus; - networkStatus = _gprs.attachGPRS(true); + networkStatus = _nb_gprs.attachGPRS(true); Debug.print(DBG_DEBUG, "GPRS.attachGPRS(): %d", networkStatus); if (networkStatus == NB_NetworkStatus_t::ERROR) { // NO FURTHER ACTION WILL FOLLOW THIS @@ -100,7 +106,7 @@ NetworkConnectionState NBConnectionHandler::check() { } Debug.print(DBG_INFO, "Sending PING to outer space..."); int pingResult; - // pingResult = _gprs.ping("time.arduino.cc"); + // pingResult = _nb_gprs.ping("time.arduino.cc"); // Debug.print(DBG_INFO, "NB.ping(): %d", pingResult); // if (pingResult < 0) { if (pingResult < 0) { @@ -115,9 +121,9 @@ NetworkConnectionState NBConnectionHandler::check() { } break; case NetworkConnectionState::CONNECTED: { - nbAccessAlive = nbAccess.isAccessAlive(); - Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", nbAccessAlive); - if (nbAccessAlive != 1) { + _nbAlive = _nb.isAccessAlive(); + Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", _nbAlive); + if (_nbAlive != 1) { changeConnectionState(NetworkConnectionState::DISCONNECTED); return _netConnectionState; } @@ -125,8 +131,8 @@ NetworkConnectionState NBConnectionHandler::check() { } break; case NetworkConnectionState::DISCONNECTED: { - //_gprs.detachGPRS(); - if (keepAlive) { + //_nb_gprs.detachGPRS(); + if (_keep_alive) { Debug.print(DBG_VERBOSE, "keep alive > INIT"); changeConnectionState(NetworkConnectionState::INIT); } else { @@ -168,14 +174,14 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState break; case NetworkConnectionState::DISCONNECTING: { Debug.print(DBG_VERBOSE, "Disconnecting from Cellular Network"); - nbAccess.shutdown(); + _nb.shutdown(); } case NetworkConnectionState::DISCONNECTED: { if (_netConnectionState == NetworkConnectionState::CONNECTED) { execCallback(NetworkConnectionEvent::DISCONNECTED); Debug.print(DBG_ERROR, "Disconnected from Cellular Network"); Debug.print(DBG_ERROR, "Attempting reconnection"); - if (keepAlive) { + if (_keep_alive) { Debug.print(DBG_ERROR, "Attempting reconnection"); } } @@ -198,7 +204,7 @@ void NBConnectionHandler::connect() { if (_netConnectionState == NetworkConnectionState::INIT || _netConnectionState == NetworkConnectionState::CONNECTING) { return; } - keepAlive = true; + _keep_alive = true; changeConnectionState(NetworkConnectionState::INIT); } @@ -206,7 +212,7 @@ void NBConnectionHandler::disconnect() { //WiFi.end(); changeConnectionState(NetworkConnectionState::DISCONNECTING); - keepAlive = false; + _keep_alive = false; } #endif /* #ifdef BOARD_HAS_NB */ \ No newline at end of file diff --git a/src/Arduino_NBConnectionHandler.h b/src/Arduino_NBConnectionHandler.h index 8c89951d..c124c04c 100644 --- a/src/Arduino_NBConnectionHandler.h +++ b/src/Arduino_NBConnectionHandler.h @@ -32,25 +32,15 @@ class NBConnectionHandler : public ConnectionHandler { public: - NBConnectionHandler(const char *pin, const bool keepAlive = true); - NBConnectionHandler(const char *pin, const char *apn, const bool keepAlive = true); - NBConnectionHandler(const char *pin, const char *apn, const char *login, const char *pass, const bool keepAlive = true); + NBConnectionHandler(char const * pin, bool const keep_alive = true); + NBConnectionHandler(char const * pin, char const * apn, bool const keep_alive = true); + NBConnectionHandler(char const * pin, char const * apn, char const * login, char const * pass, bool const keep_alive = true); virtual void init(); virtual unsigned long getTime(); virtual NetworkConnectionState check(); - virtual Client &getClient() { - return _gsm_client; - }; - virtual UDP &getUDP() { - return udp; - }; - - NBClient _gsm_client; - NB nbAccess; - GPRS _gprs; - NBUDP udp; - + virtual Client & getClient() { return _nb_client; }; + virtual UDP & getUDP() { return _nb_udp; }; virtual void disconnect(); virtual void connect(); @@ -66,13 +56,18 @@ class NBConnectionHandler : public ConnectionHandler { const int CHECK_INTERVAL_DISCONNECTED = 1000; const int CHECK_INTERVAL_ERROR = 500; - const char *pin, *apn, *login, *pass; + char const * _pin; + char const * _apn; + char const * _login; + char const * _pass; unsigned long lastConnectionTickTime; int connectionTickTimeInterval; + bool _keep_alive; - - bool keepAlive; - + NB _nb; + GPRS _nb_gprs; + NBUDP _nb_udp; + NBClient _nb_client; }; #endif /* #ifdef BOARD_HAS_NB */ From ff9957230b148f2fc187419d60544341a4b06300 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 10:34:24 +0100 Subject: [PATCH 35/54] Adding keyword override to allow compiler check if really a base class function is overwritten --- src/Arduino_NBConnectionHandler.cpp | 21 ++++++++------------- src/Arduino_NBConnectionHandler.h | 13 ++++++------- 2 files changed, 14 insertions(+), 20 deletions(-) diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp index eeec35df..82048612 100644 --- a/src/Arduino_NBConnectionHandler.cpp +++ b/src/Arduino_NBConnectionHandler.cpp @@ -69,17 +69,6 @@ NBConnectionHandler::NBConnectionHandler(char const * pin, char const * apn, cha PUBLIC MEMBER FUNCTIONS ******************************************************************************/ -void NBConnectionHandler::init() { - char msgBuffer[120]; - if (_nb.begin(_pin, _apn, _login, _pass) == NB_READY) { - Debug.print(DBG_INFO, "SIM card ok"); - _nb.setTimeout(CHECK_INTERVAL_RETRYING); - changeConnectionState(NetworkConnectionState::CONNECTING); - } else { - Debug.print(DBG_ERROR, "SIM not present or wrong PIN"); - } -} - unsigned long NBConnectionHandler::getTime() { return _nb.getTime(); } @@ -90,9 +79,15 @@ NetworkConnectionState NBConnectionHandler::check() { if (now - lastConnectionTickTime > connectionTickTimeInterval) { switch (_netConnectionState) { case NetworkConnectionState::INIT: { - init(); + if (_nb.begin(_pin, _apn, _login, _pass) == NB_READY) { + Debug.print(DBG_INFO, "SIM card ok"); + _nb.setTimeout(CHECK_INTERVAL_RETRYING); + changeConnectionState(NetworkConnectionState::CONNECTING); + } else { + Debug.print(DBG_ERROR, "SIM not present or wrong PIN"); } - break; + } + break; case NetworkConnectionState::CONNECTING: { // NOTE: Blocking Call when 4th parameter == true diff --git a/src/Arduino_NBConnectionHandler.h b/src/Arduino_NBConnectionHandler.h index c124c04c..1a68adf9 100644 --- a/src/Arduino_NBConnectionHandler.h +++ b/src/Arduino_NBConnectionHandler.h @@ -36,13 +36,12 @@ class NBConnectionHandler : public ConnectionHandler { NBConnectionHandler(char const * pin, char const * apn, bool const keep_alive = true); NBConnectionHandler(char const * pin, char const * apn, char const * login, char const * pass, bool const keep_alive = true); - virtual void init(); - virtual unsigned long getTime(); - virtual NetworkConnectionState check(); - virtual Client & getClient() { return _nb_client; }; - virtual UDP & getUDP() { return _nb_udp; }; - virtual void disconnect(); - virtual void connect(); + virtual unsigned long getTime() override; + virtual NetworkConnectionState check() override; + virtual Client & getClient() override { return _nb_client; }; + virtual UDP & getUDP() override { return _nb_udp; }; + virtual void disconnect() override; + virtual void connect() override; private: From 7e7121dd9af9ad910152de275fa9ceb1ad00508f Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 10:36:01 +0100 Subject: [PATCH 36/54] Restructuring connect/disconnect --- src/Arduino_NBConnectionHandler.cpp | 34 ++++++++++++++--------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp index 82048612..dbf9ac7a 100644 --- a/src/Arduino_NBConnectionHandler.cpp +++ b/src/Arduino_NBConnectionHandler.cpp @@ -143,6 +143,22 @@ NetworkConnectionState NBConnectionHandler::check() { return _netConnectionState; } +void NBConnectionHandler::connect() +{ + if (_netConnectionState != NetworkConnectionState::INIT && _netConnectionState != NetworkConnectionState::CONNECTING) + { + _keep_alive = true; + changeConnectionState(NetworkConnectionState::INIT); + } +} + +void NBConnectionHandler::disconnect() +{ + changeConnectionState(NetworkConnectionState::DISCONNECTING); + _keep_alive = false; +} + + /****************************************************************************** PRIVATE MEMBER FUNCTIONS ******************************************************************************/ @@ -194,20 +210,4 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState _netConnectionState = _newState; } - -void NBConnectionHandler::connect() { - if (_netConnectionState == NetworkConnectionState::INIT || _netConnectionState == NetworkConnectionState::CONNECTING) { - return; - } - _keep_alive = true; - changeConnectionState(NetworkConnectionState::INIT); - -} -void NBConnectionHandler::disconnect() { - //WiFi.end(); - - changeConnectionState(NetworkConnectionState::DISCONNECTING); - _keep_alive = false; -} - -#endif /* #ifdef BOARD_HAS_NB */ \ No newline at end of file +#endif /* #ifdef BOARD_HAS_NB */ From 7b4b50a6d6acc8e78c4ca86ca31744a464974ddb Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 11:02:31 +0100 Subject: [PATCH 37/54] Using table for check interval times instead of member variable --- src/Arduino_NBConnectionHandler.cpp | 51 +++++++++++++++-------------- src/Arduino_NBConnectionHandler.h | 11 +------ 2 files changed, 28 insertions(+), 34 deletions(-) diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp index dbf9ac7a..bdd53295 100644 --- a/src/Arduino_NBConnectionHandler.cpp +++ b/src/Arduino_NBConnectionHandler.cpp @@ -36,7 +36,19 @@ CONSTANTS ******************************************************************************/ -static const unsigned long NETWORK_CONNECTION_INTERVAL = 30000; +static int const NB_TIMEOUT = 30000; + +static unsigned int const CHECK_INTERVAL_TABLE[] = +{ + /* INIT */ 100, + /* CONNECTING */ 500, + /* CONNECTED */ 10000, + /* GETTIME */ 100, + /* DISCONNECTING */ 100, + /* DISCONNECTED */ 1000, + /* CLOSED */ 1000, + /* ERROR */ 1000 +}; /****************************************************************************** CTOR/DTOR @@ -58,8 +70,7 @@ NBConnectionHandler::NBConnectionHandler(char const * pin, char const * apn, cha , _apn(apn) , _login(login) , _pass(pass) -, lastConnectionTickTime(millis()) -, connectionTickTimeInterval(CHECK_INTERVAL_IDLE) +, _lastConnectionTickTime(millis()) , _keep_alive(keep_alive) { @@ -73,15 +84,21 @@ unsigned long NBConnectionHandler::getTime() { return _nb.getTime(); } -NetworkConnectionState NBConnectionHandler::check() { +NetworkConnectionState NBConnectionHandler::check() +{ + unsigned long const now = millis(); - int _nbAlive; - if (now - lastConnectionTickTime > connectionTickTimeInterval) { + unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(_netConnectionState)]; + + if((now - _lastConnectionTickTime) > connectionTickTimeInterval) + { + _lastConnectionTickTime = now; + switch (_netConnectionState) { case NetworkConnectionState::INIT: { if (_nb.begin(_pin, _apn, _login, _pass) == NB_READY) { Debug.print(DBG_INFO, "SIM card ok"); - _nb.setTimeout(CHECK_INTERVAL_RETRYING); + _nb.setTimeout(NB_TIMEOUT); changeConnectionState(NetworkConnectionState::CONNECTING); } else { Debug.print(DBG_ERROR, "SIM not present or wrong PIN"); @@ -116,9 +133,9 @@ NetworkConnectionState NBConnectionHandler::check() { } break; case NetworkConnectionState::CONNECTED: { - _nbAlive = _nb.isAccessAlive(); - Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", _nbAlive); - if (_nbAlive != 1) { + int const nb_is_access_alive = _nb.isAccessAlive(); + Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", nb_is_access_alive); + if (nb_is_access_alive != 1) { changeConnectionState(NetworkConnectionState::DISCONNECTED); return _netConnectionState; } @@ -137,7 +154,6 @@ NetworkConnectionState NBConnectionHandler::check() { } break; } - lastConnectionTickTime = now; } return _netConnectionState; @@ -164,23 +180,13 @@ void NBConnectionHandler::disconnect() ******************************************************************************/ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState) { - int newInterval = CHECK_INTERVAL_IDLE; switch (_newState) { - case NetworkConnectionState::INIT: { - newInterval = CHECK_INTERVAL_INIT; - } - break; case NetworkConnectionState::CONNECTING: { Debug.print(DBG_INFO, "Connecting to Cellular Network"); - newInterval = CHECK_INTERVAL_CONNECTING; } break; case NetworkConnectionState::CONNECTED: { execCallback(NetworkConnectionEvent::CONNECTED); - newInterval = CHECK_INTERVAL_CONNECTED; - } - break; - case NetworkConnectionState::GETTIME: { } break; case NetworkConnectionState::DISCONNECTING: { @@ -196,7 +202,6 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState Debug.print(DBG_ERROR, "Attempting reconnection"); } } - newInterval = CHECK_INTERVAL_DISCONNECTED; } break; case NetworkConnectionState::ERROR: { @@ -205,8 +210,6 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState } break; } - connectionTickTimeInterval = newInterval; - lastConnectionTickTime = millis(); _netConnectionState = _newState; } diff --git a/src/Arduino_NBConnectionHandler.h b/src/Arduino_NBConnectionHandler.h index 1a68adf9..f69844d7 100644 --- a/src/Arduino_NBConnectionHandler.h +++ b/src/Arduino_NBConnectionHandler.h @@ -47,20 +47,11 @@ class NBConnectionHandler : public ConnectionHandler { void changeConnectionState(NetworkConnectionState _newState); - const int CHECK_INTERVAL_IDLE = 100; - const int CHECK_INTERVAL_INIT = 100; - const int CHECK_INTERVAL_CONNECTING = 500; - const int CHECK_INTERVAL_CONNECTED = 10000; - const int CHECK_INTERVAL_RETRYING = 30000; - const int CHECK_INTERVAL_DISCONNECTED = 1000; - const int CHECK_INTERVAL_ERROR = 500; - char const * _pin; char const * _apn; char const * _login; char const * _pass; - unsigned long lastConnectionTickTime; - int connectionTickTimeInterval; + unsigned long _lastConnectionTickTime; bool _keep_alive; NB _nb; From da5e079d30756b25abd6a6be9d1ad88a8b503ffd Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Tue, 10 Mar 2020 11:18:00 +0100 Subject: [PATCH 38/54] Fixing braces for easier reading --- src/Arduino_NBConnectionHandler.cpp | 46 ++++++++++++++++++----------- src/Arduino_NBConnectionHandler.h | 6 +++- 2 files changed, 33 insertions(+), 19 deletions(-) diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp index bdd53295..dec6122f 100644 --- a/src/Arduino_NBConnectionHandler.cpp +++ b/src/Arduino_NBConnectionHandler.cpp @@ -80,13 +80,13 @@ NBConnectionHandler::NBConnectionHandler(char const * pin, char const * apn, cha PUBLIC MEMBER FUNCTIONS ******************************************************************************/ -unsigned long NBConnectionHandler::getTime() { +unsigned long NBConnectionHandler::getTime() +{ return _nb.getTime(); } NetworkConnectionState NBConnectionHandler::check() { - unsigned long const now = millis(); unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(_netConnectionState)]; @@ -94,25 +94,30 @@ NetworkConnectionState NBConnectionHandler::check() { _lastConnectionTickTime = now; - switch (_netConnectionState) { - case NetworkConnectionState::INIT: { - if (_nb.begin(_pin, _apn, _login, _pass) == NB_READY) { + switch (_netConnectionState) + { + case NetworkConnectionState::INIT: + { + if (_nb.begin(_pin, _apn, _login, _pass) == NB_READY) + { Debug.print(DBG_INFO, "SIM card ok"); _nb.setTimeout(NB_TIMEOUT); changeConnectionState(NetworkConnectionState::CONNECTING); - } else { + } + else + { Debug.print(DBG_ERROR, "SIM not present or wrong PIN"); } } break; - case NetworkConnectionState::CONNECTING: { - // NOTE: Blocking Call when 4th parameter == true + case NetworkConnectionState::CONNECTING: + { NB_NetworkStatus_t networkStatus; networkStatus = _nb_gprs.attachGPRS(true); Debug.print(DBG_DEBUG, "GPRS.attachGPRS(): %d", networkStatus); - if (networkStatus == NB_NetworkStatus_t::ERROR) { - // NO FURTHER ACTION WILL FOLLOW THIS + if (networkStatus == NB_NetworkStatus_t::ERROR) + { changeConnectionState(NetworkConnectionState::ERROR); return _netConnectionState; } @@ -121,36 +126,41 @@ NetworkConnectionState NBConnectionHandler::check() // pingResult = _nb_gprs.ping("time.arduino.cc"); // Debug.print(DBG_INFO, "NB.ping(): %d", pingResult); // if (pingResult < 0) { - if (pingResult < 0) { + if (pingResult < 0) + { Debug.print(DBG_ERROR, "PING failed"); Debug.print(DBG_INFO, "Retrying in \"%d\" milliseconds", connectionTickTimeInterval); return _netConnectionState; - } else { + } + else + { Debug.print(DBG_INFO, "Connected to GPRS Network"); changeConnectionState(NetworkConnectionState::CONNECTED); return _netConnectionState; } } break; - case NetworkConnectionState::CONNECTED: { + case NetworkConnectionState::CONNECTED: + { int const nb_is_access_alive = _nb.isAccessAlive(); Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", nb_is_access_alive); - if (nb_is_access_alive != 1) { + if (nb_is_access_alive != 1) + { changeConnectionState(NetworkConnectionState::DISCONNECTED); return _netConnectionState; } Debug.print(DBG_VERBOSE, "Connected to Cellular Network"); } break; - case NetworkConnectionState::DISCONNECTED: { - //_nb_gprs.detachGPRS(); - if (_keep_alive) { + case NetworkConnectionState::DISCONNECTED: + { + if (_keep_alive) + { Debug.print(DBG_VERBOSE, "keep alive > INIT"); changeConnectionState(NetworkConnectionState::INIT); } else { changeConnectionState(NetworkConnectionState::CLOSED); } - //changeConnectionState(NetworkConnectionState::CONNECTING); } break; } diff --git a/src/Arduino_NBConnectionHandler.h b/src/Arduino_NBConnectionHandler.h index f69844d7..9d2d9a0e 100644 --- a/src/Arduino_NBConnectionHandler.h +++ b/src/Arduino_NBConnectionHandler.h @@ -30,12 +30,15 @@ CLASS DECLARATION ******************************************************************************/ -class NBConnectionHandler : public ConnectionHandler { +class NBConnectionHandler : public ConnectionHandler +{ public: + NBConnectionHandler(char const * pin, bool const keep_alive = true); NBConnectionHandler(char const * pin, char const * apn, bool const keep_alive = true); NBConnectionHandler(char const * pin, char const * apn, char const * login, char const * pass, bool const keep_alive = true); + virtual unsigned long getTime() override; virtual NetworkConnectionState check() override; virtual Client & getClient() override { return _nb_client; }; @@ -43,6 +46,7 @@ class NBConnectionHandler : public ConnectionHandler { virtual void disconnect() override; virtual void connect() override; + private: void changeConnectionState(NetworkConnectionState _newState); From 45635e54058bae3cfb5c1f8bef7b7e1972988cbe Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Thu, 12 Mar 2020 08:57:58 +0100 Subject: [PATCH 39/54] Deleting code which is problematic because the execution of the if trace depends on an uninitialized variable --- src/Arduino_NBConnectionHandler.cpp | 20 +++----------------- 1 file changed, 3 insertions(+), 17 deletions(-) diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp index dec6122f..5dff7342 100644 --- a/src/Arduino_NBConnectionHandler.cpp +++ b/src/Arduino_NBConnectionHandler.cpp @@ -121,23 +121,9 @@ NetworkConnectionState NBConnectionHandler::check() changeConnectionState(NetworkConnectionState::ERROR); return _netConnectionState; } - Debug.print(DBG_INFO, "Sending PING to outer space..."); - int pingResult; - // pingResult = _nb_gprs.ping("time.arduino.cc"); - // Debug.print(DBG_INFO, "NB.ping(): %d", pingResult); - // if (pingResult < 0) { - if (pingResult < 0) - { - Debug.print(DBG_ERROR, "PING failed"); - Debug.print(DBG_INFO, "Retrying in \"%d\" milliseconds", connectionTickTimeInterval); - return _netConnectionState; - } - else - { - Debug.print(DBG_INFO, "Connected to GPRS Network"); - changeConnectionState(NetworkConnectionState::CONNECTED); - return _netConnectionState; - } + Debug.print(DBG_INFO, "Connected to GPRS Network"); + changeConnectionState(NetworkConnectionState::CONNECTED); + return _netConnectionState; } break; case NetworkConnectionState::CONNECTED: From 76e9c34bde3297110cca86f458736b6a8c6ddb1e Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Thu, 12 Mar 2020 10:51:57 +0100 Subject: [PATCH 40/54] Extract direct implementation of switch/case into small functions --- src/Arduino_NBConnectionHandler.cpp | 160 +++++++++++++--------------- src/Arduino_NBConnectionHandler.h | 6 ++ 2 files changed, 79 insertions(+), 87 deletions(-) diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp index 5dff7342..fe1a9ad0 100644 --- a/src/Arduino_NBConnectionHandler.cpp +++ b/src/Arduino_NBConnectionHandler.cpp @@ -96,59 +96,14 @@ NetworkConnectionState NBConnectionHandler::check() switch (_netConnectionState) { - case NetworkConnectionState::INIT: - { - if (_nb.begin(_pin, _apn, _login, _pass) == NB_READY) - { - Debug.print(DBG_INFO, "SIM card ok"); - _nb.setTimeout(NB_TIMEOUT); - changeConnectionState(NetworkConnectionState::CONNECTING); - } - else - { - Debug.print(DBG_ERROR, "SIM not present or wrong PIN"); - } - } - break; - - case NetworkConnectionState::CONNECTING: - { - NB_NetworkStatus_t networkStatus; - networkStatus = _nb_gprs.attachGPRS(true); - Debug.print(DBG_DEBUG, "GPRS.attachGPRS(): %d", networkStatus); - if (networkStatus == NB_NetworkStatus_t::ERROR) - { - changeConnectionState(NetworkConnectionState::ERROR); - return _netConnectionState; - } - Debug.print(DBG_INFO, "Connected to GPRS Network"); - changeConnectionState(NetworkConnectionState::CONNECTED); - return _netConnectionState; - } - break; - case NetworkConnectionState::CONNECTED: - { - int const nb_is_access_alive = _nb.isAccessAlive(); - Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", nb_is_access_alive); - if (nb_is_access_alive != 1) - { - changeConnectionState(NetworkConnectionState::DISCONNECTED); - return _netConnectionState; - } - Debug.print(DBG_VERBOSE, "Connected to Cellular Network"); - } - break; - case NetworkConnectionState::DISCONNECTED: - { - if (_keep_alive) - { - Debug.print(DBG_VERBOSE, "keep alive > INIT"); - changeConnectionState(NetworkConnectionState::INIT); - } else { - changeConnectionState(NetworkConnectionState::CLOSED); - } - } - break; + case NetworkConnectionState::INIT: _netConnectionState = update_handleInit (); break; + case NetworkConnectionState::CONNECTING: _netConnectionState = update_handleConnecting (); break; + case NetworkConnectionState::CONNECTED: _netConnectionState = update_handleConnected (); break; + case NetworkConnectionState::GETTIME: /* Unused */ break; + case NetworkConnectionState::DISCONNECTING: _netConnectionState = update_handleDisconnecting(); break; + case NetworkConnectionState::DISCONNECTED: _netConnectionState = update_handleDisconnected (); break; + case NetworkConnectionState::ERROR: break; + case NetworkConnectionState::CLOSED: break; } } @@ -160,53 +115,84 @@ void NBConnectionHandler::connect() if (_netConnectionState != NetworkConnectionState::INIT && _netConnectionState != NetworkConnectionState::CONNECTING) { _keep_alive = true; - changeConnectionState(NetworkConnectionState::INIT); + _netConnectionState = NetworkConnectionState::INIT; } } void NBConnectionHandler::disconnect() { - changeConnectionState(NetworkConnectionState::DISCONNECTING); _keep_alive = false; + _netConnectionState = NetworkConnectionState::DISCONNECTING; } - /****************************************************************************** PRIVATE MEMBER FUNCTIONS ******************************************************************************/ -void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState) { - switch (_newState) { - case NetworkConnectionState::CONNECTING: { - Debug.print(DBG_INFO, "Connecting to Cellular Network"); - } - break; - case NetworkConnectionState::CONNECTED: { - execCallback(NetworkConnectionEvent::CONNECTED); - } - break; - case NetworkConnectionState::DISCONNECTING: { - Debug.print(DBG_VERBOSE, "Disconnecting from Cellular Network"); - _nb.shutdown(); - } - case NetworkConnectionState::DISCONNECTED: { - if (_netConnectionState == NetworkConnectionState::CONNECTED) { - execCallback(NetworkConnectionEvent::DISCONNECTED); - Debug.print(DBG_ERROR, "Disconnected from Cellular Network"); - Debug.print(DBG_ERROR, "Attempting reconnection"); - if (_keep_alive) { - Debug.print(DBG_ERROR, "Attempting reconnection"); - } - } - } - break; - case NetworkConnectionState::ERROR: { - execCallback(NetworkConnectionEvent::ERROR); - Debug.print(DBG_ERROR, "GPRS attach failed\n\rMake sure the antenna is connected and reset your board."); - } - break; +NetworkConnectionState NBConnectionHandler::update_handleInit() +{ + if (_nb.begin(_pin, _apn, _login, _pass) == NB_READY) + { + Debug.print(DBG_INFO, "SIM card ok"); + _nb.setTimeout(NB_TIMEOUT); + return NetworkConnectionState::CONNECTING; + } + else + { + Debug.print(DBG_ERROR, "SIM not present or wrong PIN"); + return NetworkConnectionState::ERROR; + } +} + +NetworkConnectionState NBConnectionHandler::update_handleConnecting() +{ + NB_NetworkStatus_t const network_status = _nb_gprs.attachGPRS(true); + Debug.print(DBG_DEBUG, "GPRS.attachGPRS(): %d", network_status); + if (network_status == NB_NetworkStatus_t::ERROR) + { + Debug.print(DBG_ERROR, "GPRS.attachGPRS() failed"); + return NetworkConnectionState::ERROR; + } + else + { + Debug.print(DBG_INFO, "Connected to GPRS Network"); + return NetworkConnectionState::CONNECTED; + } +} + +NetworkConnectionState NBConnectionHandler::update_handleConnected() +{ + int const nb_is_access_alive = _nb.isAccessAlive(); + Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", nb_is_access_alive); + if (nb_is_access_alive != 1) + { + Debug.print(DBG_INFO, "Disconnected from cellular network"); + return NetworkConnectionState::DISCONNECTED; + } + else + { + Debug.print(DBG_VERBOSE, "Connected to Cellular Network"); + return NetworkConnectionState::CONNECTED; + } +} + +NetworkConnectionState NBConnectionHandler::update_handleDisconnecting() +{ + Debug.print(DBG_VERBOSE, "Disconnecting from Cellular Network"); + _nb.shutdown(); + return NetworkConnectionState::DISCONNECTED; +} + +NetworkConnectionState NBConnectionHandler::update_handleDisconnected() +{ + if (_keep_alive) + { + return NetworkConnectionState::INIT; + } + else + { + return NetworkConnectionState::CLOSED; } - _netConnectionState = _newState; } #endif /* #ifdef BOARD_HAS_NB */ diff --git a/src/Arduino_NBConnectionHandler.h b/src/Arduino_NBConnectionHandler.h index 9d2d9a0e..5d032df9 100644 --- a/src/Arduino_NBConnectionHandler.h +++ b/src/Arduino_NBConnectionHandler.h @@ -62,6 +62,12 @@ class NBConnectionHandler : public ConnectionHandler GPRS _nb_gprs; NBUDP _nb_udp; NBClient _nb_client; + + NetworkConnectionState update_handleInit (); + NetworkConnectionState update_handleConnecting (); + NetworkConnectionState update_handleConnected (); + NetworkConnectionState update_handleDisconnecting(); + NetworkConnectionState update_handleDisconnected (); }; #endif /* #ifdef BOARD_HAS_NB */ From af6300230a4d3fdcbaecb182cef1d64f75b17a78 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Thu, 12 Mar 2020 10:54:04 +0100 Subject: [PATCH 41/54] Moving _gsm.shutdown() call out of disconnect function which will allow to share the code for the function across all connection handlers --- src/Arduino_GSMConnectionHandler.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index 05709132..765d8de4 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -101,7 +101,6 @@ NetworkConnectionState GSMConnectionHandler::check() void GSMConnectionHandler::disconnect() { - _gsm.shutdown(); _keep_alive = false; _netConnectionState = NetworkConnectionState::DISCONNECTING; } @@ -176,6 +175,7 @@ NetworkConnectionState GSMConnectionHandler::update_handleConnected() NetworkConnectionState GSMConnectionHandler::update_handleDisconnecting() { + _gsm.shutdown(); execCallback(NetworkConnectionEvent::DISCONNECTED); return NetworkConnectionState::DISCONNECTED; } From 920cc4aed6e8dba08bc3b9da9c3ffd99b85d2a77 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Thu, 12 Mar 2020 11:08:56 +0100 Subject: [PATCH 42/54] Moving implementation of connect/disconnect into base class Arduino_ConnectionHandler --- src/Arduino_ConnectionHandler.cpp | 26 ++++++++++++++++++++++++++ src/Arduino_ConnectionHandler.h | 13 ++++++++++--- src/Arduino_GSMConnectionHandler.cpp | 19 ++----------------- src/Arduino_GSMConnectionHandler.h | 3 --- src/Arduino_LoRaConnectionHandler.cpp | 17 ++--------------- src/Arduino_LoRaConnectionHandler.h | 3 --- src/Arduino_NBConnectionHandler.cpp | 19 ++----------------- src/Arduino_NBConnectionHandler.h | 3 --- src/Arduino_WiFiConnectionHandler.cpp | 19 ++----------------- src/Arduino_WiFiConnectionHandler.h | 3 --- 10 files changed, 44 insertions(+), 81 deletions(-) diff --git a/src/Arduino_ConnectionHandler.cpp b/src/Arduino_ConnectionHandler.cpp index b9bc110c..86d43e12 100644 --- a/src/Arduino_ConnectionHandler.cpp +++ b/src/Arduino_ConnectionHandler.cpp @@ -21,10 +21,36 @@ #include "Arduino_ConnectionHandler.h" +/****************************************************************************** + CONSTRUCTOR/DESTRUCTOR + ******************************************************************************/ + +ConnectionHandler::ConnectionHandler(bool const keep_alive) +: _keep_alive{keep_alive} +, _netConnectionState{NetworkConnectionState::INIT} +{ + +} + /****************************************************************************** PUBLIC MEMBER FUNCTIONS ******************************************************************************/ +void ConnectionHandler::connect() +{ + if (_netConnectionState != NetworkConnectionState::INIT && _netConnectionState != NetworkConnectionState::CONNECTING) + { + _keep_alive = true; + _netConnectionState = NetworkConnectionState::INIT; + } +} + +void ConnectionHandler::disconnect() +{ + _keep_alive = false; + _netConnectionState = NetworkConnectionState::DISCONNECTING; +} + void ConnectionHandler::addCallback(NetworkConnectionEvent const event, OnNetworkEventCallback callback) { switch (event) { case NetworkConnectionEvent::CONNECTED: _on_connect_event_callback = callback; break; diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h index c297281b..c4fe4044 100644 --- a/src/Arduino_ConnectionHandler.h +++ b/src/Arduino_ConnectionHandler.h @@ -136,6 +136,10 @@ typedef void (*OnNetworkEventCallback)(); class ConnectionHandler { public: + + ConnectionHandler(bool const keep_alive); + + virtual NetworkConnectionState check() = 0; #if defined(BOARD_HAS_WIFI) || defined(BOARD_HAS_GSM) || defined(BOARD_HAS_NB) @@ -153,8 +157,10 @@ class ConnectionHandler { virtual NetworkConnectionState getStatus() __attribute__((deprecated)) { return _netConnectionState; } - virtual void connect() = 0; - virtual void disconnect() = 0; + + void connect(); + void disconnect(); + void addCallback(NetworkConnectionEvent const event, OnNetworkEventCallback callback); void addConnectCallback(OnNetworkEventCallback callback) __attribute__((deprecated)); void addDisconnectCallback(OnNetworkEventCallback callback) __attribute__((deprecated)); @@ -162,7 +168,8 @@ class ConnectionHandler { protected: - NetworkConnectionState _netConnectionState = NetworkConnectionState::INIT; + bool _keep_alive; + NetworkConnectionState _netConnectionState; void execCallback(NetworkConnectionEvent const event); diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index 765d8de4..c65e516d 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -55,11 +55,11 @@ static unsigned int const CHECK_INTERVAL_TABLE[] = ******************************************************************************/ GSMConnectionHandler::GSMConnectionHandler(const char * pin, const char * apn, const char * login, const char * pass, bool const keep_alive) -: _pin(pin) +: ConnectionHandler{keep_alive} +, _pin(pin) , _apn(apn) , _login(login) , _pass(pass) -, _keep_alive(keep_alive) , _lastConnectionTickTime(millis()) { @@ -99,21 +99,6 @@ NetworkConnectionState GSMConnectionHandler::check() return _netConnectionState; } -void GSMConnectionHandler::disconnect() -{ - _keep_alive = false; - _netConnectionState = NetworkConnectionState::DISCONNECTING; -} - -void GSMConnectionHandler::connect() -{ - if (_netConnectionState != NetworkConnectionState::INIT && _netConnectionState != NetworkConnectionState::CONNECTING) - { - _keep_alive = true; - _netConnectionState = NetworkConnectionState::INIT; - } -} - /****************************************************************************** PRIVATE MEMBER FUNCTIONS ******************************************************************************/ diff --git a/src/Arduino_GSMConnectionHandler.h b/src/Arduino_GSMConnectionHandler.h index 3aad1f36..06c572d1 100644 --- a/src/Arduino_GSMConnectionHandler.h +++ b/src/Arduino_GSMConnectionHandler.h @@ -42,8 +42,6 @@ class GSMConnectionHandler : public ConnectionHandler virtual NetworkConnectionState check() override; virtual Client & getClient() override { return _gsm_client; }; virtual UDP & getUDP() override { return _gsm_udp; }; - virtual void disconnect() override; - virtual void connect() override; private: @@ -52,7 +50,6 @@ class GSMConnectionHandler : public ConnectionHandler const char * _apn; const char * _login; const char * _pass; - bool _keep_alive; unsigned long _lastConnectionTickTime; GSM _gsm; diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp index 68ec06d7..a4137316 100644 --- a/src/Arduino_LoRaConnectionHandler.cpp +++ b/src/Arduino_LoRaConnectionHandler.cpp @@ -61,12 +61,12 @@ static unsigned int const CHECK_INTERVAL_TABLE[] = ******************************************************************************/ LoRaConnectionHandler::LoRaConnectionHandler(char const * appeui, char const * appkey, _lora_band const band, _lora_class const device_class) -: _appeui(appeui) +: ConnectionHandler{false} +, _appeui(appeui) , _appkey(appkey) , _band(band) , _device_class(device_class) , _lastConnectionTickTime(millis()) -, _keep_alive(false) { } @@ -137,19 +137,6 @@ bool LoRaConnectionHandler::available() return _modem.available(); } -void LoRaConnectionHandler::connect() -{ - if (_netConnectionState != NetworkConnectionState::INIT && _netConnectionState != NetworkConnectionState::CONNECTING) - { - _keep_alive = true; - _netConnectionState = NetworkConnectionState::INIT; - } -} -void LoRaConnectionHandler::disconnect() -{ - /* Do nothing */ -} - /****************************************************************************** PRIVATE MEMBER FUNCTIONS ******************************************************************************/ diff --git a/src/Arduino_LoRaConnectionHandler.h b/src/Arduino_LoRaConnectionHandler.h index d641dce3..b90c705d 100644 --- a/src/Arduino_LoRaConnectionHandler.h +++ b/src/Arduino_LoRaConnectionHandler.h @@ -39,8 +39,6 @@ class LoRaConnectionHandler : public ConnectionHandler virtual int write(const uint8_t *buf, size_t size) override; virtual int read() override; virtual bool available() override; - virtual void disconnect() override; - virtual void connect() override; private: @@ -50,7 +48,6 @@ class LoRaConnectionHandler : public ConnectionHandler _lora_band _band; _lora_class _device_class; unsigned long _lastConnectionTickTime; - bool _keep_alive; LoRaModem _modem; NetworkConnectionState update_handleInit(); diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp index fe1a9ad0..fa594bd4 100644 --- a/src/Arduino_NBConnectionHandler.cpp +++ b/src/Arduino_NBConnectionHandler.cpp @@ -66,12 +66,12 @@ NBConnectionHandler::NBConnectionHandler(char const * pin, char const * apn, boo } NBConnectionHandler::NBConnectionHandler(char const * pin, char const * apn, char const * login, char const * pass, bool const keep_alive) -: _pin(pin) +: ConnectionHandler{keep_alive} +, _pin(pin) , _apn(apn) , _login(login) , _pass(pass) , _lastConnectionTickTime(millis()) -, _keep_alive(keep_alive) { } @@ -110,21 +110,6 @@ NetworkConnectionState NBConnectionHandler::check() return _netConnectionState; } -void NBConnectionHandler::connect() -{ - if (_netConnectionState != NetworkConnectionState::INIT && _netConnectionState != NetworkConnectionState::CONNECTING) - { - _keep_alive = true; - _netConnectionState = NetworkConnectionState::INIT; - } -} - -void NBConnectionHandler::disconnect() -{ - _keep_alive = false; - _netConnectionState = NetworkConnectionState::DISCONNECTING; -} - /****************************************************************************** PRIVATE MEMBER FUNCTIONS ******************************************************************************/ diff --git a/src/Arduino_NBConnectionHandler.h b/src/Arduino_NBConnectionHandler.h index 5d032df9..bbae4acf 100644 --- a/src/Arduino_NBConnectionHandler.h +++ b/src/Arduino_NBConnectionHandler.h @@ -43,8 +43,6 @@ class NBConnectionHandler : public ConnectionHandler virtual NetworkConnectionState check() override; virtual Client & getClient() override { return _nb_client; }; virtual UDP & getUDP() override { return _nb_udp; }; - virtual void disconnect() override; - virtual void connect() override; private: @@ -56,7 +54,6 @@ class NBConnectionHandler : public ConnectionHandler char const * _login; char const * _pass; unsigned long _lastConnectionTickTime; - bool _keep_alive; NB _nb; GPRS _nb_gprs; diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp index a6745225..c68f8e9b 100644 --- a/src/Arduino_WiFiConnectionHandler.cpp +++ b/src/Arduino_WiFiConnectionHandler.cpp @@ -44,10 +44,10 @@ static unsigned int const CHECK_INTERVAL_TABLE[] = ******************************************************************************/ WiFiConnectionHandler::WiFiConnectionHandler(char const * ssid, char const * pass, bool const keep_alive) -: _ssid{ssid} +: ConnectionHandler{keep_alive} +, _ssid{ssid} , _pass{pass} , _lastConnectionTickTime{millis()} -, _keep_alive{keep_alive} { } @@ -94,21 +94,6 @@ NetworkConnectionState WiFiConnectionHandler::check() PRIVATE MEMBER FUNCTIONS ******************************************************************************/ -void WiFiConnectionHandler::connect() -{ - if (_netConnectionState != NetworkConnectionState::INIT && _netConnectionState != NetworkConnectionState::CONNECTING) - { - _keep_alive = true; - _netConnectionState = NetworkConnectionState::INIT; - } -} - -void WiFiConnectionHandler::disconnect() -{ - _keep_alive = false; - _netConnectionState = NetworkConnectionState::DISCONNECTING; -} - NetworkConnectionState WiFiConnectionHandler::update_handleInit() { #ifndef BOARD_ESP8266 diff --git a/src/Arduino_WiFiConnectionHandler.h b/src/Arduino_WiFiConnectionHandler.h index b4f20eb6..99df80a0 100644 --- a/src/Arduino_WiFiConnectionHandler.h +++ b/src/Arduino_WiFiConnectionHandler.h @@ -41,15 +41,12 @@ class WiFiConnectionHandler : public ConnectionHandler virtual NetworkConnectionState check() override; virtual Client & getClient() override{ return _wifi_client; } virtual UDP & getUDP() override { return _wifi_udp; } - virtual void disconnect() override; - virtual void connect() override; private: char const * _ssid; char const * _pass; - bool _keep_alive; unsigned long _lastConnectionTickTime; WiFiUDP _wifi_udp; From e7ae47cd69532665cdf42cd700e47c24cb9fb737 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Thu, 12 Mar 2020 11:09:30 +0100 Subject: [PATCH 43/54] Removing no longer necessary keyword virtual --- src/Arduino_ConnectionHandler.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h index c4fe4044..76ee63b2 100644 --- a/src/Arduino_ConnectionHandler.h +++ b/src/Arduino_ConnectionHandler.h @@ -154,7 +154,7 @@ class ConnectionHandler { virtual bool available() = 0; #endif - virtual NetworkConnectionState getStatus() __attribute__((deprecated)) { + NetworkConnectionState getStatus() __attribute__((deprecated)) { return _netConnectionState; } From 8172a1dc17272594e2728e2172da2b1fdc63a24c Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Thu, 12 Mar 2020 11:15:39 +0100 Subject: [PATCH 44/54] Move retrieval of time for ESP8266 out of update_handleGetTime since this is really the only type of board which needs this state --- src/Arduino_WiFiConnectionHandler.cpp | 15 +++++---------- src/Arduino_WiFiConnectionHandler.h | 1 - 2 files changed, 5 insertions(+), 11 deletions(-) diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp index c68f8e9b..dc36e8ab 100644 --- a/src/Arduino_WiFiConnectionHandler.cpp +++ b/src/Arduino_WiFiConnectionHandler.cpp @@ -79,7 +79,7 @@ NetworkConnectionState WiFiConnectionHandler::check() case NetworkConnectionState::INIT: _netConnectionState = update_handleInit (); break; case NetworkConnectionState::CONNECTING: _netConnectionState = update_handleConnecting (); break; case NetworkConnectionState::CONNECTED: _netConnectionState = update_handleConnected (); break; - case NetworkConnectionState::GETTIME: _netConnectionState = update_handleGetTime (); break; + case NetworkConnectionState::GETTIME: /* Unused */ break; case NetworkConnectionState::DISCONNECTING: _netConnectionState = update_handleDisconnecting(); break; case NetworkConnectionState::DISCONNECTED: _netConnectionState = update_handleDisconnected (); break; case NetworkConnectionState::ERROR: break; @@ -144,7 +144,10 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnecting() { Debug.print(DBG_INFO, "Connected to \"%s\"", _ssid); execCallback(NetworkConnectionEvent::CONNECTED); - return NetworkConnectionState::GETTIME; +#ifdef BOARD_ESP8266 + configTime(0, 0, "time.arduino.cc", "pool.ntp.org", "time.nist.gov"); +#endif + return NetworkConnectionState::CONNECTED; } } @@ -167,14 +170,6 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnected() return NetworkConnectionState::CONNECTED; } -NetworkConnectionState WiFiConnectionHandler::update_handleGetTime() -{ -#ifdef BOARD_ESP8266 - configTime(0, 0, "time.arduino.cc", "pool.ntp.org", "time.nist.gov"); -#endif - return NetworkConnectionState::CONNECTED; -} - NetworkConnectionState WiFiConnectionHandler::update_handleDisconnecting() { WiFi.disconnect(); diff --git a/src/Arduino_WiFiConnectionHandler.h b/src/Arduino_WiFiConnectionHandler.h index 99df80a0..22346e14 100644 --- a/src/Arduino_WiFiConnectionHandler.h +++ b/src/Arduino_WiFiConnectionHandler.h @@ -55,7 +55,6 @@ class WiFiConnectionHandler : public ConnectionHandler NetworkConnectionState update_handleInit (); NetworkConnectionState update_handleConnecting (); NetworkConnectionState update_handleConnected (); - NetworkConnectionState update_handleGetTime (); NetworkConnectionState update_handleDisconnecting(); NetworkConnectionState update_handleDisconnected (); }; From c1292ff1bab50c0dc22dccd90bc7e119de47c914 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Thu, 12 Mar 2020 11:19:54 +0100 Subject: [PATCH 45/54] Remove NetworkConnectionState::GETTIME and share check interval table between all connection handlers --- src/Arduino_ConnectionHandler.h | 24 +++++++++++++++++++----- src/Arduino_GSMConnectionHandler.cpp | 22 ---------------------- src/Arduino_LoRaConnectionHandler.cpp | 16 ---------------- src/Arduino_NBConnectionHandler.cpp | 13 ------------- src/Arduino_WiFiConnectionHandler.cpp | 17 ----------------- 5 files changed, 19 insertions(+), 73 deletions(-) diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h index 76ee63b2..cee07e27 100644 --- a/src/Arduino_ConnectionHandler.h +++ b/src/Arduino_ConnectionHandler.h @@ -117,11 +117,10 @@ enum class NetworkConnectionState : unsigned int { INIT = 0, CONNECTING = 1, CONNECTED = 2, - GETTIME = 3, - DISCONNECTING = 4, - DISCONNECTED = 5, - CLOSED = 6, - ERROR = 7 + DISCONNECTING = 3, + DISCONNECTED = 4, + CLOSED = 5, + ERROR = 6 }; enum class NetworkConnectionEvent { @@ -130,6 +129,21 @@ enum class NetworkConnectionEvent { typedef void (*OnNetworkEventCallback)(); +/****************************************************************************** + CONSTANTS + ******************************************************************************/ + +static unsigned int const CHECK_INTERVAL_TABLE[] = +{ + /* INIT */ 100, + /* CONNECTING */ 500, + /* CONNECTED */ 10000, + /* DISCONNECTING */ 100, + /* DISCONNECTED */ 1000, + /* CLOSED */ 1000, + /* ERROR */ 1000 +}; + /****************************************************************************** CLASS DECLARATION ******************************************************************************/ diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index c65e516d..b2ca9143 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -19,15 +19,6 @@ INCLUDE ******************************************************************************/ -/* - static int const DBG_NONE = -1; - static int const DBG_ERROR = 0; - static int const DBG_WARNING = 1; - static int const DBG_INFO = 2; - static int const DBG_DEBUG = 3; - static int const DBG_VERBOSE = 4; -*/ - #include "Arduino_GSMConnectionHandler.h" #ifdef BOARD_HAS_GSM /* Only compile if this is a board with GSM */ @@ -38,18 +29,6 @@ static int const GSM_TIMEOUT = 30000; -static unsigned int const CHECK_INTERVAL_TABLE[] = -{ - /* INIT */ 100, - /* CONNECTING */ 500, - /* CONNECTED */ 10000, - /* GETTIME */ 100, - /* DISCONNECTING */ 100, - /* DISCONNECTED */ 1000, - /* CLOSED */ 1000, - /* ERROR */ 1000 -}; - /****************************************************************************** CTOR/DTOR ******************************************************************************/ @@ -88,7 +67,6 @@ NetworkConnectionState GSMConnectionHandler::check() case NetworkConnectionState::INIT: _netConnectionState = update_handleInit(); break; case NetworkConnectionState::CONNECTING: _netConnectionState = update_handleConnecting(); break; case NetworkConnectionState::CONNECTED: _netConnectionState = update_handleConnected(); break; - case NetworkConnectionState::GETTIME: /* Unused */ break; case NetworkConnectionState::DISCONNECTING: _netConnectionState = update_handleDisconnecting(); break; case NetworkConnectionState::DISCONNECTED: _netConnectionState = update_handleDisconnected(); break; case NetworkConnectionState::ERROR: break; diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp index a4137316..faf3b5a1 100644 --- a/src/Arduino_LoRaConnectionHandler.cpp +++ b/src/Arduino_LoRaConnectionHandler.cpp @@ -40,22 +40,6 @@ typedef enum LORA_ERROR_MAX_PACKET_SIZE = -20 } LoRaCommunicationError; -/****************************************************************************** - CONSTANTS - ******************************************************************************/ - -static unsigned int const CHECK_INTERVAL_TABLE[] = -{ - /* INIT */ 100, - /* CONNECTING */ 500, - /* CONNECTED */ 10000, - /* GETTIME */ 100, - /* DISCONNECTING */ 100, - /* DISCONNECTED */ 1000, - /* CLOSED */ 1000, - /* ERROR */ 1000 -}; - /****************************************************************************** CTOR/DTOR ******************************************************************************/ diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp index fa594bd4..a8198290 100644 --- a/src/Arduino_NBConnectionHandler.cpp +++ b/src/Arduino_NBConnectionHandler.cpp @@ -38,18 +38,6 @@ static int const NB_TIMEOUT = 30000; -static unsigned int const CHECK_INTERVAL_TABLE[] = -{ - /* INIT */ 100, - /* CONNECTING */ 500, - /* CONNECTED */ 10000, - /* GETTIME */ 100, - /* DISCONNECTING */ 100, - /* DISCONNECTED */ 1000, - /* CLOSED */ 1000, - /* ERROR */ 1000 -}; - /****************************************************************************** CTOR/DTOR ******************************************************************************/ @@ -99,7 +87,6 @@ NetworkConnectionState NBConnectionHandler::check() case NetworkConnectionState::INIT: _netConnectionState = update_handleInit (); break; case NetworkConnectionState::CONNECTING: _netConnectionState = update_handleConnecting (); break; case NetworkConnectionState::CONNECTED: _netConnectionState = update_handleConnected (); break; - case NetworkConnectionState::GETTIME: /* Unused */ break; case NetworkConnectionState::DISCONNECTING: _netConnectionState = update_handleDisconnecting(); break; case NetworkConnectionState::DISCONNECTED: _netConnectionState = update_handleDisconnected (); break; case NetworkConnectionState::ERROR: break; diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp index dc36e8ab..a4db17bc 100644 --- a/src/Arduino_WiFiConnectionHandler.cpp +++ b/src/Arduino_WiFiConnectionHandler.cpp @@ -23,22 +23,6 @@ #ifdef BOARD_HAS_WIFI /* Only compile if the board has WiFi */ -/****************************************************************************** - CONSTANTS - ******************************************************************************/ - -static unsigned int const CHECK_INTERVAL_TABLE[] = -{ - /* INIT */ 100, - /* CONNECTING */ 500, - /* CONNECTED */ 10000, - /* GETTIME */ 100, - /* DISCONNECTING */ 100, - /* DISCONNECTED */ 1000, - /* CLOSED */ 1000, - /* ERROR */ 1000 -}; - /****************************************************************************** CTOR/DTOR ******************************************************************************/ @@ -79,7 +63,6 @@ NetworkConnectionState WiFiConnectionHandler::check() case NetworkConnectionState::INIT: _netConnectionState = update_handleInit (); break; case NetworkConnectionState::CONNECTING: _netConnectionState = update_handleConnecting (); break; case NetworkConnectionState::CONNECTED: _netConnectionState = update_handleConnected (); break; - case NetworkConnectionState::GETTIME: /* Unused */ break; case NetworkConnectionState::DISCONNECTING: _netConnectionState = update_handleDisconnecting(); break; case NetworkConnectionState::DISCONNECTED: _netConnectionState = update_handleDisconnected (); break; case NetworkConnectionState::ERROR: break; From bc378d5d83c0e7869ad3f94b3c8d3fe9b58fb07d Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Thu, 12 Mar 2020 11:30:34 +0100 Subject: [PATCH 46/54] Employing the template method pattern to only implement the state machine in the base class - all derived classes import their actual behaviour within their template methods --- src/Arduino_ConnectionHandler.cpp | 25 +++++++++++++++++++++++++ src/Arduino_ConnectionHandler.h | 10 +++++++++- src/Arduino_GSMConnectionHandler.cpp | 27 +-------------------------- src/Arduino_GSMConnectionHandler.h | 17 +++++++++-------- src/Arduino_LoRaConnectionHandler.cpp | 27 +-------------------------- src/Arduino_LoRaConnectionHandler.h | 17 +++++++++-------- src/Arduino_NBConnectionHandler.cpp | 25 ------------------------- src/Arduino_NBConnectionHandler.h | 17 +++++++++-------- src/Arduino_WiFiConnectionHandler.cpp | 27 +-------------------------- src/Arduino_WiFiConnectionHandler.h | 16 ++++++++-------- 10 files changed, 72 insertions(+), 136 deletions(-) diff --git a/src/Arduino_ConnectionHandler.cpp b/src/Arduino_ConnectionHandler.cpp index 86d43e12..2e7bddaa 100644 --- a/src/Arduino_ConnectionHandler.cpp +++ b/src/Arduino_ConnectionHandler.cpp @@ -28,6 +28,7 @@ ConnectionHandler::ConnectionHandler(bool const keep_alive) : _keep_alive{keep_alive} , _netConnectionState{NetworkConnectionState::INIT} +, _lastConnectionTickTime{millis()} { } @@ -36,6 +37,30 @@ ConnectionHandler::ConnectionHandler(bool const keep_alive) PUBLIC MEMBER FUNCTIONS ******************************************************************************/ +NetworkConnectionState ConnectionHandler::check() +{ + unsigned long const now = millis(); + unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(_netConnectionState)]; + + if((now - _lastConnectionTickTime) > connectionTickTimeInterval) + { + _lastConnectionTickTime = now; + + switch (_netConnectionState) + { + case NetworkConnectionState::INIT: _netConnectionState = update_handleInit (); break; + case NetworkConnectionState::CONNECTING: _netConnectionState = update_handleConnecting (); break; + case NetworkConnectionState::CONNECTED: _netConnectionState = update_handleConnected (); break; + case NetworkConnectionState::DISCONNECTING: _netConnectionState = update_handleDisconnecting(); break; + case NetworkConnectionState::DISCONNECTED: _netConnectionState = update_handleDisconnected (); break; + case NetworkConnectionState::ERROR: break; + case NetworkConnectionState::CLOSED: break; + } + } + + return _netConnectionState; +} + void ConnectionHandler::connect() { if (_netConnectionState != NetworkConnectionState::INIT && _netConnectionState != NetworkConnectionState::CONNECTING) diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h index cee07e27..a39fea0f 100644 --- a/src/Arduino_ConnectionHandler.h +++ b/src/Arduino_ConnectionHandler.h @@ -154,7 +154,7 @@ class ConnectionHandler { ConnectionHandler(bool const keep_alive); - virtual NetworkConnectionState check() = 0; + NetworkConnectionState check(); #if defined(BOARD_HAS_WIFI) || defined(BOARD_HAS_GSM) || defined(BOARD_HAS_NB) virtual unsigned long getTime() = 0; @@ -187,8 +187,16 @@ class ConnectionHandler { void execCallback(NetworkConnectionEvent const event); + virtual NetworkConnectionState update_handleInit () = 0; + virtual NetworkConnectionState update_handleConnecting () = 0; + virtual NetworkConnectionState update_handleConnected () = 0; + virtual NetworkConnectionState update_handleDisconnecting() = 0; + virtual NetworkConnectionState update_handleDisconnected () = 0; + + private: + unsigned long _lastConnectionTickTime; OnNetworkEventCallback _on_connect_event_callback = NULL, _on_disconnect_event_callback = NULL, _on_error_event_callback = NULL; diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index b2ca9143..97d56644 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -39,7 +39,6 @@ GSMConnectionHandler::GSMConnectionHandler(const char * pin, const char * apn, c , _apn(apn) , _login(login) , _pass(pass) -, _lastConnectionTickTime(millis()) { } @@ -53,32 +52,8 @@ unsigned long GSMConnectionHandler::getTime() return _gsm.getTime(); } -NetworkConnectionState GSMConnectionHandler::check() -{ - unsigned long const now = millis(); - unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(_netConnectionState)]; - - if((now - _lastConnectionTickTime) > connectionTickTimeInterval) - { - _lastConnectionTickTime = now; - - switch (_netConnectionState) - { - case NetworkConnectionState::INIT: _netConnectionState = update_handleInit(); break; - case NetworkConnectionState::CONNECTING: _netConnectionState = update_handleConnecting(); break; - case NetworkConnectionState::CONNECTED: _netConnectionState = update_handleConnected(); break; - case NetworkConnectionState::DISCONNECTING: _netConnectionState = update_handleDisconnecting(); break; - case NetworkConnectionState::DISCONNECTED: _netConnectionState = update_handleDisconnected(); break; - case NetworkConnectionState::ERROR: break; - case NetworkConnectionState::CLOSED: break; - } - } - - return _netConnectionState; -} - /****************************************************************************** - PRIVATE MEMBER FUNCTIONS + PROTECTED MEMBER FUNCTIONS ******************************************************************************/ NetworkConnectionState GSMConnectionHandler::update_handleInit() diff --git a/src/Arduino_GSMConnectionHandler.h b/src/Arduino_GSMConnectionHandler.h index 06c572d1..714ed8c5 100644 --- a/src/Arduino_GSMConnectionHandler.h +++ b/src/Arduino_GSMConnectionHandler.h @@ -39,29 +39,30 @@ class GSMConnectionHandler : public ConnectionHandler virtual unsigned long getTime() override; - virtual NetworkConnectionState check() override; virtual Client & getClient() override { return _gsm_client; }; virtual UDP & getUDP() override { return _gsm_udp; }; + protected: + + virtual NetworkConnectionState update_handleInit () override; + virtual NetworkConnectionState update_handleConnecting () override; + virtual NetworkConnectionState update_handleConnected () override; + virtual NetworkConnectionState update_handleDisconnecting() override; + virtual NetworkConnectionState update_handleDisconnected () override; + + private: const char * _pin; const char * _apn; const char * _login; const char * _pass; - unsigned long _lastConnectionTickTime; GSM _gsm; GPRS _gprs; GSMUDP _gsm_udp; GSMClient _gsm_client; - - NetworkConnectionState update_handleInit (); - NetworkConnectionState update_handleConnecting (); - NetworkConnectionState update_handleConnected (); - NetworkConnectionState update_handleDisconnecting(); - NetworkConnectionState update_handleDisconnected (); }; #endif /* #ifdef BOARD_HAS_GSM */ diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp index faf3b5a1..7b3a00d2 100644 --- a/src/Arduino_LoRaConnectionHandler.cpp +++ b/src/Arduino_LoRaConnectionHandler.cpp @@ -50,7 +50,6 @@ LoRaConnectionHandler::LoRaConnectionHandler(char const * appeui, char const * a , _appkey(appkey) , _band(band) , _device_class(device_class) -, _lastConnectionTickTime(millis()) { } @@ -59,30 +58,6 @@ LoRaConnectionHandler::LoRaConnectionHandler(char const * appeui, char const * a PUBLIC MEMBER FUNCTIONS ******************************************************************************/ -NetworkConnectionState LoRaConnectionHandler::check() -{ - unsigned long const now = millis(); - unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(_netConnectionState)]; - - if((now - _lastConnectionTickTime) > connectionTickTimeInterval) - { - _lastConnectionTickTime = now; - - switch (_netConnectionState) - { - case NetworkConnectionState::INIT: _netConnectionState = update_handleInit(); break; - case NetworkConnectionState::CONNECTING: _netConnectionState = update_handleConnecting(); break; - case NetworkConnectionState::CONNECTED: _netConnectionState = update_handleConnected(); break; - case NetworkConnectionState::DISCONNECTING: _netConnectionState = update_handleDisconnecting(); break; - case NetworkConnectionState::DISCONNECTED: _netConnectionState = update_handleDisconnected(); break; - case NetworkConnectionState::ERROR: break; - case NetworkConnectionState::CLOSED: break; - } - } - - return _netConnectionState; -} - int LoRaConnectionHandler::write(const uint8_t * buf, size_t size) { _modem.beginPacket(); @@ -122,7 +97,7 @@ bool LoRaConnectionHandler::available() } /****************************************************************************** - PRIVATE MEMBER FUNCTIONS + PROTECTED MEMBER FUNCTIONS ******************************************************************************/ NetworkConnectionState LoRaConnectionHandler::update_handleInit() diff --git a/src/Arduino_LoRaConnectionHandler.h b/src/Arduino_LoRaConnectionHandler.h index b90c705d..a0cff734 100644 --- a/src/Arduino_LoRaConnectionHandler.h +++ b/src/Arduino_LoRaConnectionHandler.h @@ -35,26 +35,27 @@ class LoRaConnectionHandler : public ConnectionHandler LoRaConnectionHandler(char const * appeui, char const * appkey, _lora_band const band = _lora_band::EU868, _lora_class const device_class = _lora_class::CLASS_A); - virtual NetworkConnectionState check() override; virtual int write(const uint8_t *buf, size_t size) override; virtual int read() override; virtual bool available() override; + protected: + + virtual NetworkConnectionState update_handleInit () override; + virtual NetworkConnectionState update_handleConnecting () override; + virtual NetworkConnectionState update_handleConnected () override; + virtual NetworkConnectionState update_handleDisconnecting() override; + virtual NetworkConnectionState update_handleDisconnected () override; + + private: char const * _appeui; char const * _appkey; _lora_band _band; _lora_class _device_class; - unsigned long _lastConnectionTickTime; LoRaModem _modem; - - NetworkConnectionState update_handleInit(); - NetworkConnectionState update_handleConnecting(); - NetworkConnectionState update_handleConnected(); - NetworkConnectionState update_handleDisconnecting(); - NetworkConnectionState update_handleDisconnected(); }; #endif /* ARDUINO_LORA_CONNECTION_HANDLER_H_ */ diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp index a8198290..15cb3cdc 100644 --- a/src/Arduino_NBConnectionHandler.cpp +++ b/src/Arduino_NBConnectionHandler.cpp @@ -59,7 +59,6 @@ NBConnectionHandler::NBConnectionHandler(char const * pin, char const * apn, cha , _apn(apn) , _login(login) , _pass(pass) -, _lastConnectionTickTime(millis()) { } @@ -73,30 +72,6 @@ unsigned long NBConnectionHandler::getTime() return _nb.getTime(); } -NetworkConnectionState NBConnectionHandler::check() -{ - unsigned long const now = millis(); - unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(_netConnectionState)]; - - if((now - _lastConnectionTickTime) > connectionTickTimeInterval) - { - _lastConnectionTickTime = now; - - switch (_netConnectionState) - { - case NetworkConnectionState::INIT: _netConnectionState = update_handleInit (); break; - case NetworkConnectionState::CONNECTING: _netConnectionState = update_handleConnecting (); break; - case NetworkConnectionState::CONNECTED: _netConnectionState = update_handleConnected (); break; - case NetworkConnectionState::DISCONNECTING: _netConnectionState = update_handleDisconnecting(); break; - case NetworkConnectionState::DISCONNECTED: _netConnectionState = update_handleDisconnected (); break; - case NetworkConnectionState::ERROR: break; - case NetworkConnectionState::CLOSED: break; - } - } - - return _netConnectionState; -} - /****************************************************************************** PRIVATE MEMBER FUNCTIONS ******************************************************************************/ diff --git a/src/Arduino_NBConnectionHandler.h b/src/Arduino_NBConnectionHandler.h index bbae4acf..53d2174e 100644 --- a/src/Arduino_NBConnectionHandler.h +++ b/src/Arduino_NBConnectionHandler.h @@ -40,11 +40,19 @@ class NBConnectionHandler : public ConnectionHandler virtual unsigned long getTime() override; - virtual NetworkConnectionState check() override; virtual Client & getClient() override { return _nb_client; }; virtual UDP & getUDP() override { return _nb_udp; }; + protected: + + virtual NetworkConnectionState update_handleInit () override; + virtual NetworkConnectionState update_handleConnecting () override; + virtual NetworkConnectionState update_handleConnected () override; + virtual NetworkConnectionState update_handleDisconnecting() override; + virtual NetworkConnectionState update_handleDisconnected () override; + + private: void changeConnectionState(NetworkConnectionState _newState); @@ -53,18 +61,11 @@ class NBConnectionHandler : public ConnectionHandler char const * _apn; char const * _login; char const * _pass; - unsigned long _lastConnectionTickTime; NB _nb; GPRS _nb_gprs; NBUDP _nb_udp; NBClient _nb_client; - - NetworkConnectionState update_handleInit (); - NetworkConnectionState update_handleConnecting (); - NetworkConnectionState update_handleConnected (); - NetworkConnectionState update_handleDisconnecting(); - NetworkConnectionState update_handleDisconnected (); }; #endif /* #ifdef BOARD_HAS_NB */ diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp index a4db17bc..50dea8bd 100644 --- a/src/Arduino_WiFiConnectionHandler.cpp +++ b/src/Arduino_WiFiConnectionHandler.cpp @@ -31,7 +31,6 @@ WiFiConnectionHandler::WiFiConnectionHandler(char const * ssid, char const * pas : ConnectionHandler{keep_alive} , _ssid{ssid} , _pass{pass} -, _lastConnectionTickTime{millis()} { } @@ -49,32 +48,8 @@ unsigned long WiFiConnectionHandler::getTime() #endif } -NetworkConnectionState WiFiConnectionHandler::check() -{ - unsigned long const now = millis(); - unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(_netConnectionState)]; - - if((now - _lastConnectionTickTime) > connectionTickTimeInterval) - { - _lastConnectionTickTime = now; - - switch (_netConnectionState) - { - case NetworkConnectionState::INIT: _netConnectionState = update_handleInit (); break; - case NetworkConnectionState::CONNECTING: _netConnectionState = update_handleConnecting (); break; - case NetworkConnectionState::CONNECTED: _netConnectionState = update_handleConnected (); break; - case NetworkConnectionState::DISCONNECTING: _netConnectionState = update_handleDisconnecting(); break; - case NetworkConnectionState::DISCONNECTED: _netConnectionState = update_handleDisconnected (); break; - case NetworkConnectionState::ERROR: break; - case NetworkConnectionState::CLOSED: break; - } - } - - return _netConnectionState; -} - /****************************************************************************** - PRIVATE MEMBER FUNCTIONS + PROTECTED MEMBER FUNCTIONS ******************************************************************************/ NetworkConnectionState WiFiConnectionHandler::update_handleInit() diff --git a/src/Arduino_WiFiConnectionHandler.h b/src/Arduino_WiFiConnectionHandler.h index 22346e14..56670793 100644 --- a/src/Arduino_WiFiConnectionHandler.h +++ b/src/Arduino_WiFiConnectionHandler.h @@ -38,25 +38,25 @@ class WiFiConnectionHandler : public ConnectionHandler virtual unsigned long getTime() override; - virtual NetworkConnectionState check() override; virtual Client & getClient() override{ return _wifi_client; } virtual UDP & getUDP() override { return _wifi_udp; } + protected: + + virtual NetworkConnectionState update_handleInit () override; + virtual NetworkConnectionState update_handleConnecting () override; + virtual NetworkConnectionState update_handleConnected () override; + virtual NetworkConnectionState update_handleDisconnecting() override; + virtual NetworkConnectionState update_handleDisconnected () override; + private: char const * _ssid; char const * _pass; - unsigned long _lastConnectionTickTime; WiFiUDP _wifi_udp; WiFiClient _wifi_client; - - NetworkConnectionState update_handleInit (); - NetworkConnectionState update_handleConnecting (); - NetworkConnectionState update_handleConnected (); - NetworkConnectionState update_handleDisconnecting(); - NetworkConnectionState update_handleDisconnected (); }; #endif /* #ifdef BOARD_HAS_WIFI */ From 1d5589be9af817f32f568d9d69f83aaccd9c9fc1 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Thu, 12 Mar 2020 11:31:07 +0100 Subject: [PATCH 47/54] Deleting comment --- src/Arduino_NBConnectionHandler.cpp | 9 --------- 1 file changed, 9 deletions(-) diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp index 15cb3cdc..b3c719dd 100644 --- a/src/Arduino_NBConnectionHandler.cpp +++ b/src/Arduino_NBConnectionHandler.cpp @@ -19,15 +19,6 @@ INCLUDE ******************************************************************************/ -/* - static int const DBG_NONE = -1; - static int const DBG_ERROR = 0; - static int const DBG_WARNING = 1; - static int const DBG_INFO = 2; - static int const DBG_DEBUG = 3; - static int const DBG_VERBOSE = 4; -*/ - #include "Arduino_NBConnectionHandler.h" #ifdef BOARD_HAS_NB /* Only compile if this is a board with NB */ From 8f2118b1fe24b54f93a369cd14dafc1e4914554c Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Thu, 12 Mar 2020 13:26:11 +0100 Subject: [PATCH 48/54] Turning _netConnectionState private so that derived classes can't access it (which they should not need anyway) --- src/Arduino_ConnectionHandler.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h index a39fea0f..91ac8187 100644 --- a/src/Arduino_ConnectionHandler.h +++ b/src/Arduino_ConnectionHandler.h @@ -183,7 +183,6 @@ class ConnectionHandler { protected: bool _keep_alive; - NetworkConnectionState _netConnectionState; void execCallback(NetworkConnectionEvent const event); @@ -197,6 +196,7 @@ class ConnectionHandler { private: unsigned long _lastConnectionTickTime; + NetworkConnectionState _netConnectionState; OnNetworkEventCallback _on_connect_event_callback = NULL, _on_disconnect_event_callback = NULL, _on_error_event_callback = NULL; From 6503c26efd8571afabd25f81a57f2551fbd11209 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Thu, 12 Mar 2020 13:28:58 +0100 Subject: [PATCH 49/54] Deleting those NetworkConnectionEvent states for which one anyway can not register callbacks --- src/Arduino_ConnectionHandler.cpp | 32 ++++++++++++++----------------- src/Arduino_ConnectionHandler.h | 4 +++- 2 files changed, 17 insertions(+), 19 deletions(-) diff --git a/src/Arduino_ConnectionHandler.cpp b/src/Arduino_ConnectionHandler.cpp index 2e7bddaa..b41a64fe 100644 --- a/src/Arduino_ConnectionHandler.cpp +++ b/src/Arduino_ConnectionHandler.cpp @@ -76,15 +76,13 @@ void ConnectionHandler::disconnect() _netConnectionState = NetworkConnectionState::DISCONNECTING; } -void ConnectionHandler::addCallback(NetworkConnectionEvent const event, OnNetworkEventCallback callback) { - switch (event) { - case NetworkConnectionEvent::CONNECTED: _on_connect_event_callback = callback; break; - case NetworkConnectionEvent::DISCONNECTED: _on_disconnect_event_callback = callback; break; - case NetworkConnectionEvent::ERROR: _on_error_event_callback = callback; break; - case NetworkConnectionEvent::INIT: ; break; - case NetworkConnectionEvent::CONNECTING: ; break; - case NetworkConnectionEvent::DISCONNECTING: ; break; - case NetworkConnectionEvent::CLOSED: ; break; +void ConnectionHandler::addCallback(NetworkConnectionEvent const event, OnNetworkEventCallback callback) +{ + switch (event) + { + case NetworkConnectionEvent::CONNECTED: _on_connect_event_callback = callback; break; + case NetworkConnectionEvent::DISCONNECTED: _on_disconnect_event_callback = callback; break; + case NetworkConnectionEvent::ERROR: _on_error_event_callback = callback; break; } } @@ -102,14 +100,12 @@ void ConnectionHandler::addErrorCallback(OnNetworkEventCallback callback) { PRIVATE MEMBER FUNCTIONS ******************************************************************************/ -void ConnectionHandler::execCallback(NetworkConnectionEvent const event) { - switch (event) { - case NetworkConnectionEvent::CONNECTED: if(_on_connect_event_callback) _on_connect_event_callback (); break; - case NetworkConnectionEvent::DISCONNECTED: if(_on_disconnect_event_callback) _on_disconnect_event_callback(); break; - case NetworkConnectionEvent::ERROR: if(_on_error_event_callback) _on_error_event_callback (); break; - case NetworkConnectionEvent::INIT: break; - case NetworkConnectionEvent::CONNECTING: break; - case NetworkConnectionEvent::DISCONNECTING: break; - case NetworkConnectionEvent::CLOSED: break; +void ConnectionHandler::execCallback(NetworkConnectionEvent const event) +{ + switch (event) + { + case NetworkConnectionEvent::CONNECTED: if(_on_connect_event_callback) _on_connect_event_callback (); break; + case NetworkConnectionEvent::DISCONNECTED: if(_on_disconnect_event_callback) _on_disconnect_event_callback(); break; + case NetworkConnectionEvent::ERROR: if(_on_error_event_callback) _on_error_event_callback (); break; } } diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h index 91ac8187..e0b97168 100644 --- a/src/Arduino_ConnectionHandler.h +++ b/src/Arduino_ConnectionHandler.h @@ -124,7 +124,9 @@ enum class NetworkConnectionState : unsigned int { }; enum class NetworkConnectionEvent { - INIT, CONNECTING, CONNECTED, DISCONNECTING, DISCONNECTED, CLOSED, ERROR + CONNECTED, + DISCONNECTED, + ERROR }; typedef void (*OnNetworkEventCallback)(); From 6499bdf02cba8ac29285067298b4a77c58289b39 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Thu, 12 Mar 2020 13:30:10 +0100 Subject: [PATCH 50/54] Renaming _netConnectionState to _current_net_connection_state --- src/Arduino_ConnectionHandler.cpp | 28 ++++++++++++++-------------- src/Arduino_ConnectionHandler.h | 4 ++-- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/src/Arduino_ConnectionHandler.cpp b/src/Arduino_ConnectionHandler.cpp index b41a64fe..e9425bf3 100644 --- a/src/Arduino_ConnectionHandler.cpp +++ b/src/Arduino_ConnectionHandler.cpp @@ -27,7 +27,7 @@ ConnectionHandler::ConnectionHandler(bool const keep_alive) : _keep_alive{keep_alive} -, _netConnectionState{NetworkConnectionState::INIT} +, _current_net_connection_state{NetworkConnectionState::INIT} , _lastConnectionTickTime{millis()} { @@ -40,40 +40,40 @@ ConnectionHandler::ConnectionHandler(bool const keep_alive) NetworkConnectionState ConnectionHandler::check() { unsigned long const now = millis(); - unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(_netConnectionState)]; + unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast(_current_net_connection_state)]; if((now - _lastConnectionTickTime) > connectionTickTimeInterval) { _lastConnectionTickTime = now; - switch (_netConnectionState) + switch (_current_net_connection_state) { - case NetworkConnectionState::INIT: _netConnectionState = update_handleInit (); break; - case NetworkConnectionState::CONNECTING: _netConnectionState = update_handleConnecting (); break; - case NetworkConnectionState::CONNECTED: _netConnectionState = update_handleConnected (); break; - case NetworkConnectionState::DISCONNECTING: _netConnectionState = update_handleDisconnecting(); break; - case NetworkConnectionState::DISCONNECTED: _netConnectionState = update_handleDisconnected (); break; - case NetworkConnectionState::ERROR: break; - case NetworkConnectionState::CLOSED: break; + case NetworkConnectionState::INIT: _current_net_connection_state = update_handleInit (); break; + case NetworkConnectionState::CONNECTING: _current_net_connection_state = update_handleConnecting (); break; + case NetworkConnectionState::CONNECTED: _current_net_connection_state = update_handleConnected (); break; + case NetworkConnectionState::DISCONNECTING: _current_net_connection_state = update_handleDisconnecting(); break; + case NetworkConnectionState::DISCONNECTED: _current_net_connection_state = update_handleDisconnected (); break; + case NetworkConnectionState::ERROR: break; + case NetworkConnectionState::CLOSED: break; } } - return _netConnectionState; + return _current_net_connection_state; } void ConnectionHandler::connect() { - if (_netConnectionState != NetworkConnectionState::INIT && _netConnectionState != NetworkConnectionState::CONNECTING) + if (_current_net_connection_state != NetworkConnectionState::INIT && _current_net_connection_state != NetworkConnectionState::CONNECTING) { _keep_alive = true; - _netConnectionState = NetworkConnectionState::INIT; + _current_net_connection_state = NetworkConnectionState::INIT; } } void ConnectionHandler::disconnect() { _keep_alive = false; - _netConnectionState = NetworkConnectionState::DISCONNECTING; + _current_net_connection_state = NetworkConnectionState::DISCONNECTING; } void ConnectionHandler::addCallback(NetworkConnectionEvent const event, OnNetworkEventCallback callback) diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h index e0b97168..afde4b11 100644 --- a/src/Arduino_ConnectionHandler.h +++ b/src/Arduino_ConnectionHandler.h @@ -171,7 +171,7 @@ class ConnectionHandler { #endif NetworkConnectionState getStatus() __attribute__((deprecated)) { - return _netConnectionState; + return _current_net_connection_state; } void connect(); @@ -198,7 +198,7 @@ class ConnectionHandler { private: unsigned long _lastConnectionTickTime; - NetworkConnectionState _netConnectionState; + NetworkConnectionState _current_net_connection_state; OnNetworkEventCallback _on_connect_event_callback = NULL, _on_disconnect_event_callback = NULL, _on_error_event_callback = NULL; From 3a8298326e76285770550554fe6a612e0b47c3ec Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Thu, 12 Mar 2020 13:32:10 +0100 Subject: [PATCH 51/54] Adding callback in case of network error to example file --- examples/ConnectionHandlerDemo/ConnectionHandlerDemo.ino | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/examples/ConnectionHandlerDemo/ConnectionHandlerDemo.ino b/examples/ConnectionHandlerDemo/ConnectionHandlerDemo.ino index 3cf16200..eecbda31 100644 --- a/examples/ConnectionHandlerDemo/ConnectionHandlerDemo.ino +++ b/examples/ConnectionHandlerDemo/ConnectionHandlerDemo.ino @@ -37,6 +37,7 @@ void setup() { conMan.addCallback(NetworkConnectionEvent::CONNECTED, onNetworkConnect); conMan.addCallback(NetworkConnectionEvent::DISCONNECTED, onNetworkDisconnect); + conMan.addCallback(NetworkConnectionEvent::ERROR, onNetworkError); } void loop() { @@ -59,3 +60,7 @@ void onNetworkConnect() { void onNetworkDisconnect() { Serial.println(">>>> DISCONNECTED from network"); } + +void onNetworkError() { + Serial.println(">>>> ERROR"); +} From 821180d18c9d414f832b0e06c8d0b8b98860fcc2 Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Thu, 12 Mar 2020 13:47:09 +0100 Subject: [PATCH 52/54] Perform callbacks in case of state transitions in base class now --- src/Arduino_ConnectionHandler.cpp | 55 +++++++++++++++++---------- src/Arduino_ConnectionHandler.h | 2 - src/Arduino_GSMConnectionHandler.cpp | 5 --- src/Arduino_LoRaConnectionHandler.cpp | 19 ++++----- src/Arduino_WiFiConnectionHandler.cpp | 4 -- 5 files changed, 42 insertions(+), 43 deletions(-) diff --git a/src/Arduino_ConnectionHandler.cpp b/src/Arduino_ConnectionHandler.cpp index e9425bf3..51f63fc8 100644 --- a/src/Arduino_ConnectionHandler.cpp +++ b/src/Arduino_ConnectionHandler.cpp @@ -45,16 +45,43 @@ NetworkConnectionState ConnectionHandler::check() if((now - _lastConnectionTickTime) > connectionTickTimeInterval) { _lastConnectionTickTime = now; + NetworkConnectionState next_net_connection_state = _current_net_connection_state; + /* While the state machine is implemented here, the concrete implementation of the + * states is done in the derived connection handlers. + */ switch (_current_net_connection_state) { - case NetworkConnectionState::INIT: _current_net_connection_state = update_handleInit (); break; - case NetworkConnectionState::CONNECTING: _current_net_connection_state = update_handleConnecting (); break; - case NetworkConnectionState::CONNECTED: _current_net_connection_state = update_handleConnected (); break; - case NetworkConnectionState::DISCONNECTING: _current_net_connection_state = update_handleDisconnecting(); break; - case NetworkConnectionState::DISCONNECTED: _current_net_connection_state = update_handleDisconnected (); break; - case NetworkConnectionState::ERROR: break; - case NetworkConnectionState::CLOSED: break; + case NetworkConnectionState::INIT: next_net_connection_state = update_handleInit (); break; + case NetworkConnectionState::CONNECTING: next_net_connection_state = update_handleConnecting (); break; + case NetworkConnectionState::CONNECTED: next_net_connection_state = update_handleConnected (); break; + case NetworkConnectionState::DISCONNECTING: next_net_connection_state = update_handleDisconnecting(); break; + case NetworkConnectionState::DISCONNECTED: next_net_connection_state = update_handleDisconnected (); break; + case NetworkConnectionState::ERROR: break; + case NetworkConnectionState::CLOSED: break; + } + + /* Here we are determining whether a state transition from one state to the next has + * occurred - and if it has, we call eventually registered callbacks. + */ + if(next_net_connection_state != _current_net_connection_state) + { + /* Check the next state to determine the kind of state conversion which has occurred (and call the appropriate callback) */ + if(next_net_connection_state == NetworkConnectionState::CONNECTED) + { + if(_on_connect_event_callback) _on_connect_event_callback(); + } + if(next_net_connection_state == NetworkConnectionState::DISCONNECTED) + { + if(_on_disconnect_event_callback) _on_disconnect_event_callback(); + } + if(next_net_connection_state == NetworkConnectionState::ERROR) + { + if(_on_error_event_callback) _on_error_event_callback(); + } + + /* Assign new state to the member variable holding the state */ + _current_net_connection_state = next_net_connection_state; } } @@ -95,17 +122,3 @@ void ConnectionHandler::addDisconnectCallback(OnNetworkEventCallback callback) { void ConnectionHandler::addErrorCallback(OnNetworkEventCallback callback) { _on_error_event_callback = callback; } - -/****************************************************************************** - PRIVATE MEMBER FUNCTIONS - ******************************************************************************/ - -void ConnectionHandler::execCallback(NetworkConnectionEvent const event) -{ - switch (event) - { - case NetworkConnectionEvent::CONNECTED: if(_on_connect_event_callback) _on_connect_event_callback (); break; - case NetworkConnectionEvent::DISCONNECTED: if(_on_disconnect_event_callback) _on_disconnect_event_callback(); break; - case NetworkConnectionEvent::ERROR: if(_on_error_event_callback) _on_error_event_callback (); break; - } -} diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h index afde4b11..64520189 100644 --- a/src/Arduino_ConnectionHandler.h +++ b/src/Arduino_ConnectionHandler.h @@ -186,8 +186,6 @@ class ConnectionHandler { bool _keep_alive; - void execCallback(NetworkConnectionEvent const event); - virtual NetworkConnectionState update_handleInit () = 0; virtual NetworkConnectionState update_handleConnecting () = 0; virtual NetworkConnectionState update_handleConnected () = 0; diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp index 97d56644..951038bd 100644 --- a/src/Arduino_GSMConnectionHandler.cpp +++ b/src/Arduino_GSMConnectionHandler.cpp @@ -67,7 +67,6 @@ NetworkConnectionState GSMConnectionHandler::update_handleInit() else { Debug.print(DBG_ERROR, "SIM not present or wrong PIN"); - execCallback(NetworkConnectionEvent::ERROR); return NetworkConnectionState::ERROR; } } @@ -80,7 +79,6 @@ NetworkConnectionState GSMConnectionHandler::update_handleConnecting() { Debug.print(DBG_ERROR, "GPRS attach failed"); Debug.print(DBG_ERROR, "Make sure the antenna is connected and reset your board."); - execCallback(NetworkConnectionEvent::ERROR); return NetworkConnectionState::ERROR; } Debug.print(DBG_INFO, "Sending PING to outer space..."); @@ -95,7 +93,6 @@ NetworkConnectionState GSMConnectionHandler::update_handleConnecting() else { Debug.print(DBG_INFO, "Connected to GPRS Network"); - execCallback(NetworkConnectionEvent::CONNECTED); return NetworkConnectionState::CONNECTED; } } @@ -105,7 +102,6 @@ NetworkConnectionState GSMConnectionHandler::update_handleConnected() int const is_gsm_access_alive = _gsm.isAccessAlive(); if (is_gsm_access_alive != 1) { - execCallback(NetworkConnectionEvent::DISCONNECTED); return NetworkConnectionState::DISCONNECTED; } return NetworkConnectionState::CONNECTED; @@ -114,7 +110,6 @@ NetworkConnectionState GSMConnectionHandler::update_handleConnected() NetworkConnectionState GSMConnectionHandler::update_handleDisconnecting() { _gsm.shutdown(); - execCallback(NetworkConnectionEvent::DISCONNECTED); return NetworkConnectionState::DISCONNECTED; } diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp index 7b3a00d2..4f62c25f 100644 --- a/src/Arduino_LoRaConnectionHandler.cpp +++ b/src/Arduino_LoRaConnectionHandler.cpp @@ -104,8 +104,8 @@ NetworkConnectionState LoRaConnectionHandler::update_handleInit() { if (!_modem.begin(_band)) { - execCallback(NetworkConnectionEvent::ERROR); Debug.print(DBG_ERROR, "Something went wrong; are you indoor? Move near a window, then reset and retry."); + return NetworkConnectionEvent::ERROR; } //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 delay(100); @@ -120,22 +120,21 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnecting() bool const network_status = _modem.joinOTAA(_appeui, _appkey); if (network_status != true) { - execCallback(NetworkConnectionEvent::ERROR); Debug.print(DBG_ERROR, "Something went wrong; are you indoor? Move near a window, then reset and retry."); return NetworkConnectionState::ERROR; } - - Debug.print(DBG_INFO, "Connected to the network"); - execCallback(NetworkConnectionEvent::CONNECTED); - return NetworkConnectionState::CONNECTED; + else + { + Debug.print(DBG_INFO, "Connected to the network"); + return NetworkConnectionState::CONNECTED; + } } NetworkConnectionState LoRaConnectionHandler::update_handleConnected() { bool const network_status = _modem.connected(); - if (network_status != true) { - execCallback(NetworkConnectionEvent::DISCONNECTED); - + if (network_status != true) + { Debug.print(DBG_ERROR, "Connection to the network lost."); if (_keep_alive) { @@ -148,8 +147,6 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnected() NetworkConnectionState LoRaConnectionHandler::update_handleDisconnecting() { - execCallback(NetworkConnectionEvent::DISCONNECTED); - Debug.print(DBG_ERROR, "Connection to the network lost."); if (_keep_alive) { diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp index 50dea8bd..24bbceb0 100644 --- a/src/Arduino_WiFiConnectionHandler.cpp +++ b/src/Arduino_WiFiConnectionHandler.cpp @@ -58,7 +58,6 @@ NetworkConnectionState WiFiConnectionHandler::update_handleInit() Debug.print(DBG_INFO, "WiFi.status(): %d", WiFi.status()); if (WiFi.status() == NETWORK_HARDWARE_ERROR) { - execCallback(NetworkConnectionEvent::ERROR); Debug.print(DBG_ERROR, "WiFi Hardware failure.\nMake sure you are using a WiFi enabled board/shield."); Debug.print(DBG_ERROR, "Then reset and retry."); return NetworkConnectionState::ERROR; @@ -101,7 +100,6 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnecting() else { Debug.print(DBG_INFO, "Connected to \"%s\"", _ssid); - execCallback(NetworkConnectionEvent::CONNECTED); #ifdef BOARD_ESP8266 configTime(0, 0, "time.arduino.cc", "pool.ntp.org", "time.nist.gov"); #endif @@ -113,8 +111,6 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnected() { if (WiFi.status() != WL_CONNECTED) { - execCallback(NetworkConnectionEvent::DISCONNECTED); - Debug.print(DBG_VERBOSE, "WiFi.status(): %d", WiFi.status()); Debug.print(DBG_ERROR, "Connection to \"%s\" lost.", _ssid); From 28fb13e869168bde8bd3be33d3335668a8b9a63a Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Thu, 12 Mar 2020 14:07:46 +0100 Subject: [PATCH 53/54] Enable CI compilation for MKRWAN1300/1310 --- .github/workflows/compile-examples.yml | 4 +++- examples/ConnectionHandlerDemo/ConnectionHandlerDemo.ino | 2 ++ examples/ConnectionHandlerDemo/arduino_secrets.h | 5 ++++- src/Arduino_LoRaConnectionHandler.cpp | 2 +- 4 files changed, 10 insertions(+), 3 deletions(-) diff --git a/.github/workflows/compile-examples.yml b/.github/workflows/compile-examples.yml index 6e7fc53e..a3de50dc 100644 --- a/.github/workflows/compile-examples.yml +++ b/.github/workflows/compile-examples.yml @@ -5,7 +5,7 @@ jobs: runs-on: ubuntu-latest env: - LIBRARIES: Arduino_DebugUtils WiFi101 WiFiNINA MKRGSM MKRNB + LIBRARIES: Arduino_DebugUtils WiFi101 WiFiNINA MKRGSM MKRNB MKRWAN strategy: matrix: fqbn: [ @@ -14,6 +14,8 @@ jobs: "arduino:samd:nano_33_iot", "arduino:samd:mkrgsm1400", "arduino:samd:mkrnb1500", + "arduino:samd:mkrwan1300", + "arduino:samd:mkrwan1310", '"esp8266:esp8266:huzzah" "https://arduino.esp8266.com/stable/package_esp8266com_index.json"' ] diff --git a/examples/ConnectionHandlerDemo/ConnectionHandlerDemo.ino b/examples/ConnectionHandlerDemo/ConnectionHandlerDemo.ino index eecbda31..2246fc10 100644 --- a/examples/ConnectionHandlerDemo/ConnectionHandlerDemo.ino +++ b/examples/ConnectionHandlerDemo/ConnectionHandlerDemo.ino @@ -26,6 +26,8 @@ WiFiConnectionHandler conMan(SECRET_SSID, SECRET_PASS); GSMConnectionHandler conMan(SECRET_APN, SECRET_PIN, SECRET_GSM_USER, SECRET_GSM_PASS); #elif defined(BOARD_HAS_NB) NBConnectionHandler conMan(SECRET_PIN); +#elif defined(BOARD_HAS_LORA) +LoRaConnectionHandler conMan(SECRET_APP_EUI, SECRET_APP_KEY); #endif void setup() { diff --git a/examples/ConnectionHandlerDemo/arduino_secrets.h b/examples/ConnectionHandlerDemo/arduino_secrets.h index 2cc38da9..0a2a2fe6 100644 --- a/examples/ConnectionHandlerDemo/arduino_secrets.h +++ b/examples/ConnectionHandlerDemo/arduino_secrets.h @@ -4,4 +4,7 @@ const char SECRET_PASS[] = "NETWORK PASSWORD"; const char SECRET_APN[] = "MOBILE PROVIDER APN ADDRESS"; const char SECRET_PIN[] = "0000"; const char SECRET_GSM_USER[] = "GSM USERNAME"; -const char SECRET_GSM_PASS[] = "GSM PASSWORD"; \ No newline at end of file +const char SECRET_GSM_PASS[] = "GSM PASSWORD"; + +const char SECRET_APP_EUI[] = "APP_EUI"; +const char SECRET_APP_KEY[] = "APP_KEY"; diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp index 4f62c25f..d3b86c97 100644 --- a/src/Arduino_LoRaConnectionHandler.cpp +++ b/src/Arduino_LoRaConnectionHandler.cpp @@ -105,7 +105,7 @@ NetworkConnectionState LoRaConnectionHandler::update_handleInit() if (!_modem.begin(_band)) { Debug.print(DBG_ERROR, "Something went wrong; are you indoor? Move near a window, then reset and retry."); - return NetworkConnectionEvent::ERROR; + return NetworkConnectionState::ERROR; } //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 delay(100); From bf2b5b022113e0c807890cc8752d8a83b6bf183c Mon Sep 17 00:00:00 2001 From: Alexander Entinger Date: Mon, 16 Mar 2020 06:41:48 +0100 Subject: [PATCH 54/54] Fixing keywords --- keywords.txt | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/keywords.txt b/keywords.txt index 2e63dae4..8d9e9434 100644 --- a/keywords.txt +++ b/keywords.txt @@ -5,19 +5,24 @@ #################################################### # Datatypes (KEYWORD1) #################################################### -Client KEYWORD1 ConnectionHandler KEYWORD1 WiFiConnectionHandler KEYWORD1 GSMConnectionHandler KEYWORD1 NBConnectionHandler KEYWORD1 -EthernetConnectionHandler KEYWORD1 +LoRaConnectionHandler KEYWORD1 #################################################### # Methods and Functions (KEYWORD2) #################################################### ConnectionHandler KEYWORD2 -begin KEYWORD2 +check KEYWORD2 +connect KEYWORD2 +disconnect KEYWORD2 +addCallback KEYWORD2 +getTime KEYWORD2 +getClient KEYWORD2 +getUDP KEYWORD2 #################################################### # Constants (LITERAL1)