Skip to content

Commit edc1a19

Browse files
aentingeraentinger
committed
Converting enum 'NetworkConnectionState' to enum class
1 parent d911558 commit edc1a19

5 files changed

+58
-58
lines changed

‎src/ArduinoIoTCloud.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -378,7 +378,7 @@ void ArduinoIoTCloudClass::connectionCheck()
378378
if(connection != NULL){
379379
connection->check();
380380

381-
if (connection->getStatus() != ArduinoIoTConnectionStatus::CONNECTED) {
381+
if (connection->getStatus() != NetworkConnectionState::CONNECTED) {
382382
if(iotStatus == ArduinoIoTConnectionStatus::CONNECTED){
383383
setIoTConnectionState(ArduinoIoTConnectionStatus::DISCONNECTED);
384384
}

‎src/ConnectionManager.h

+9-9
Original file line numberDiff line numberDiff line change
@@ -32,14 +32,14 @@
3232
* TYPEDEFS
3333
******************************************************************************/
3434

35-
enum NetworkConnectionState {
36-
CONNECTION_STATE_INIT,
37-
CONNECTION_STATE_CONNECTING,
38-
CONNECTION_STATE_CONNECTED,
39-
CONNECTION_STATE_GETTIME,
40-
CONNECTION_STATE_DISCONNECTING,
41-
CONNECTION_STATE_DISCONNECTED,
42-
CONNECTION_STATE_ERROR
35+
enum class NetworkConnectionState {
36+
INIT,
37+
CONNECTING,
38+
CONNECTED,
39+
GETTIME,
40+
DISCONNECTING,
41+
DISCONNECTED,
42+
ERROR
4343
};
4444

4545
/******************************************************************************
@@ -58,7 +58,7 @@ class ConnectionManager {
5858

5959
protected:
6060
unsigned long lastValidTimestamp = 0;
61-
NetworkConnectionState netConnectionState = CONNECTION_STATE_INIT;
61+
NetworkConnectionState netConnectionState = NetworkConnectionState::INIT;
6262

6363
};
6464

‎src/EthernetConnectionManager.cpp

+18-18
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,7 @@ void EthConnectionManager::check() {
5757
int networkStatus = 0;
5858
if (now - lastConnectionTickTime > connectionTickTimeInterval) {
5959
switch (netConnectionState) {
60-
case CONNECTION_STATE_INIT: {
60+
case NetworkConnectionState::INIT: {
6161
if (ss_pin == -1) {
6262
networkStatus = Ethernet.begin(mac);
6363
} else {
@@ -68,7 +68,7 @@ void EthConnectionManager::check() {
6868
if (networkStatus == EthernetNoHardware) {
6969
debugMessage(DebugLevel::Error, "No Ethernet chip connected");
7070
// don't continue:
71-
changeConnectionState(CONNECTION_STATE_ERROR);
71+
changeConnectionState(NetworkConnectionState::ERROR);
7272
lastConnectionTickTime = now;
7373
return;
7474
}
@@ -77,15 +77,15 @@ void EthConnectionManager::check() {
7777
if (networkStatus == LinkOFF) {
7878
debugMessage(DebugLevel::Error, "Failed to configure Ethernet via dhcp");
7979
// don't continue:
80-
changeConnectionState(CONNECTION_STATE_ERROR);
80+
changeConnectionState(NetworkConnectionState::ERROR);
8181
lastConnectionTickTime = now;
8282
return;
8383
}
8484
debugMessage(DebugLevel::Error, "Ethernet shield recognized: ID", Ethernet.hardwareStatus());
85-
changeConnectionState(CONNECTION_STATE_CONNECTING);
85+
changeConnectionState(NetworkConnectionState::CONNECTING);
8686
}
8787
break;
88-
case CONNECTION_STATE_CONNECTING: {
88+
case NetworkConnectionState::CONNECTING: {
8989
debugMessage(DebugLevel::Info, "Connecting via dhcp");
9090
if (ss_pin == -1) {
9191
networkStatus = Ethernet.begin(mac);
@@ -96,42 +96,42 @@ void EthConnectionManager::check() {
9696
if (networkStatus == 0) {
9797
debugMessage(DebugLevel::Error, "Connection failed");
9898
debugMessage(DebugLevel::Info, "Retrying in \"%d\" milliseconds", connectionTickTimeInterval);
99-
//changeConnectionState(CONNECTION_STATE_CONNECTING);
99+
//changeConnectionState(NetworkConnectionState::CONNECTING);
100100
return;
101101
} else {
102102
debugMessage(DebugLevel::Info, "Connected!");
103-
changeConnectionState(CONNECTION_STATE_GETTIME);
103+
changeConnectionState(NetworkConnectionState::GETTIME);
104104
return;
105105
}
106106
}
107107
break;
108-
case CONNECTION_STATE_GETTIME: {
108+
case NetworkConnectionState::GETTIME: {
109109
debugMessage(DebugLevel::Debug, "Acquiring Time from Network");
110110
unsigned long networkTime;
111111
networkTime = getTime();
112112
debugMessage(DebugLevel::Debug, "Network Time: %u", networkTime);
113113
if(networkTime > lastValidTimestamp){
114114
lastValidTimestamp = networkTime;
115-
changeConnectionState(CONNECTION_STATE_CONNECTED);
115+
changeConnectionState(NetworkConnectionState::CONNECTED);
116116
}
117117
}
118118
break;
119-
case CONNECTION_STATE_CONNECTED: {
119+
case NetworkConnectionState::CONNECTED: {
120120
// keep testing connection
121121
Ethernet.maintain();
122122
networkStatus = Ethernet.linkStatus();
123123
debugMessage(DebugLevel::Verbose, "Eth link status(): %d", networkStatus);
124124
if (networkStatus != LinkON) {
125-
changeConnectionState(CONNECTION_STATE_DISCONNECTED);
125+
changeConnectionState(NetworkConnectionState::DISCONNECTED);
126126
return;
127127
}
128128
debugMessage(DebugLevel::Info, "Connected");
129129
}
130130
break;
131-
case CONNECTION_STATE_DISCONNECTED: {
131+
case NetworkConnectionState::DISCONNECTED: {
132132
debugMessage(DebugLevel::Error, "Connection lost.");
133133
debugMessage(DebugLevel::Info, "Attempting reconnection");
134-
changeConnectionState(CONNECTION_STATE_CONNECTING);
134+
changeConnectionState(NetworkConnectionState::CONNECTING);
135135
//wifiClient.stop();
136136
}
137137
break;
@@ -148,11 +148,11 @@ void EthConnectionManager::changeConnectionState(NetworkConnectionState _newStat
148148
netConnectionState = _newState;
149149
int newInterval = CHECK_INTERVAL_IDLE;
150150
switch (_newState) {
151-
case CONNECTION_STATE_INIT: newInterval = CHECK_INTERVAL_INIT; break;
152-
case CONNECTION_STATE_CONNECTING: newInterval = CHECK_INTERVAL_CONNECTING; break;
153-
case CONNECTION_STATE_GETTIME: newInterval = CHECK_INTERVAL_GETTIME; break;
154-
case CONNECTION_STATE_CONNECTED: newInterval = CHECK_INTERVAL_CONNECTED; break;
155-
case CONNECTION_STATE_DISCONNECTED: newInterval = CHECK_INTERVAL_DISCONNECTED; break;
151+
case NetworkConnectionState::INIT: newInterval = CHECK_INTERVAL_INIT; break;
152+
case NetworkConnectionState::CONNECTING: newInterval = CHECK_INTERVAL_CONNECTING; break;
153+
case NetworkConnectionState::GETTIME: newInterval = CHECK_INTERVAL_GETTIME; break;
154+
case NetworkConnectionState::CONNECTED: newInterval = CHECK_INTERVAL_CONNECTED; break;
155+
case NetworkConnectionState::DISCONNECTED: newInterval = CHECK_INTERVAL_DISCONNECTED; break;
156156
}
157157
connectionTickTimeInterval = newInterval;
158158
lastConnectionTickTime = millis();

‎src/GSMConnectionManager.cpp

+15-15
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ void GSMConnectionManager::init() {
5151
if (gsmAccess.begin(pin) == GSM_READY) {
5252
debugMessage(DebugLevel::Info, "SIM card ok");
5353
gsmAccess.setTimeout(CHECK_INTERVAL_RETRYING);
54-
changeConnectionState(CONNECTION_STATE_CONNECTING);
54+
changeConnectionState(NetworkConnectionState::CONNECTING);
5555
} else {
5656
debugMessage(DebugLevel::Error, "SIM not present or wrong PIN");
5757
while(1);
@@ -67,18 +67,18 @@ void GSMConnectionManager::check() {
6767
int gsmAccessAlive;
6868
if (now - lastConnectionTickTime > connectionTickTimeInterval) {
6969
switch (netConnectionState) {
70-
case CONNECTION_STATE_INIT: {
70+
case NetworkConnectionState::INIT: {
7171
init();
7272
}
7373
break;
74-
case CONNECTION_STATE_CONNECTING: {
74+
case NetworkConnectionState::CONNECTING: {
7575
// NOTE: Blocking Call when 4th parameter == true
7676
GSM3_NetworkStatus_t networkStatus;
7777
networkStatus = gprs.attachGPRS(apn, login, pass, true);
7878
debugMessage(DebugLevel::Debug, "GPRS.attachGPRS(): %d", networkStatus);
7979
if (networkStatus == GSM3_NetworkStatus_t::ERROR) {
8080
// NO FURTHER ACTION WILL FOLLOW THIS
81-
changeConnectionState(CONNECTION_STATE_ERROR);
81+
changeConnectionState(NetworkConnectionState::ERROR);
8282
return;
8383
}
8484
debugMessage(DebugLevel::Info, "Sending PING to outer space...");
@@ -91,24 +91,24 @@ void GSMConnectionManager::check() {
9191
return;
9292
} else {
9393
debugMessage(DebugLevel::Info, "Connected to GPRS Network");
94-
changeConnectionState(CONNECTION_STATE_CONNECTED);
94+
changeConnectionState(NetworkConnectionState::CONNECTED);
9595
return;
9696
}
9797
}
9898
break;
99-
case CONNECTION_STATE_CONNECTED: {
99+
case NetworkConnectionState::CONNECTED: {
100100
gsmAccessAlive = gsmAccess.isAccessAlive();
101101
debugMessage(DebugLevel::Verbose, "GPRS.isAccessAlive(): %d", gsmAccessAlive);
102102
if (gsmAccessAlive != 1) {
103-
changeConnectionState(CONNECTION_STATE_DISCONNECTED);
103+
changeConnectionState(NetworkConnectionState::DISCONNECTED);
104104
return;
105105
}
106106
debugMessage(DebugLevel::Verbose, "Connected to Cellular Network");
107107
}
108108
break;
109-
case CONNECTION_STATE_DISCONNECTED: {
109+
case NetworkConnectionState::DISCONNECTED: {
110110
gprs.detachGPRS();
111-
changeConnectionState(CONNECTION_STATE_CONNECTING);
111+
changeConnectionState(NetworkConnectionState::CONNECTING);
112112
}
113113
break;
114114
}
@@ -123,28 +123,28 @@ void GSMConnectionManager::check() {
123123
void GSMConnectionManager::changeConnectionState(NetworkConnectionState _newState) {
124124
int newInterval = CHECK_INTERVAL_IDLE;
125125
switch (_newState) {
126-
case CONNECTION_STATE_INIT: {
126+
case NetworkConnectionState::INIT: {
127127
newInterval = CHECK_INTERVAL_INIT;
128128
}
129129
break;
130-
case CONNECTION_STATE_CONNECTING: {
130+
case NetworkConnectionState::CONNECTING: {
131131
debugMessage(DebugLevel::Info, "Connecting to Cellular Network");
132132
newInterval = CHECK_INTERVAL_CONNECTING;
133133
}
134134
break;
135-
case CONNECTION_STATE_CONNECTED: {
135+
case NetworkConnectionState::CONNECTED: {
136136
newInterval = CHECK_INTERVAL_CONNECTED;
137137
}
138138
break;
139-
case CONNECTION_STATE_DISCONNECTED: {
140-
if(netConnectionState == CONNECTION_STATE_CONNECTED){
139+
case NetworkConnectionState::DISCONNECTED: {
140+
if(netConnectionState == NetworkConnectionState::CONNECTED){
141141
debugMessage(DebugLevel::Error, "Disconnected from Cellular Network");
142142
debugMessage(DebugLevel::Error, "Attempting reconnection");
143143
}
144144
newInterval = CHECK_INTERVAL_DISCONNECTED;
145145
}
146146
break;
147-
case CONNECTION_STATE_ERROR: {
147+
case NetworkConnectionState::ERROR: {
148148
debugMessage(DebugLevel::Error, "GPRS attach failed\n\rMake sure the antenna is connected and reset your board.");
149149
}
150150
break;

‎src/WiFiConnectionManager.cpp

+15-15
Original file line numberDiff line numberDiff line change
@@ -56,12 +56,12 @@ void WiFiConnectionManager::check() {
5656
int networkStatus = 0;
5757
if (now - lastConnectionTickTime > connectionTickTimeInterval) {
5858
switch (netConnectionState) {
59-
case CONNECTION_STATE_INIT: {
59+
case NetworkConnectionState::INIT: {
6060
networkStatus = WiFi.status();
6161
debugMessage(DebugLevel::Info, "WiFi.status(): %d", networkStatus);
6262
if (networkStatus == NETWORK_HARDWARE_ERROR) {
6363
// NO FURTHER ACTION WILL FOLLOW THIS
64-
changeConnectionState(CONNECTION_STATE_ERROR);
64+
changeConnectionState(NetworkConnectionState::ERROR);
6565
lastConnectionTickTime = now;
6666
return;
6767
}
@@ -71,38 +71,38 @@ void WiFiConnectionManager::check() {
7171
debugMessage(DebugLevel::Error, "Please update to the latest version for best performance.");
7272
delay(5000);
7373
}
74-
changeConnectionState(CONNECTION_STATE_CONNECTING);
74+
changeConnectionState(NetworkConnectionState::CONNECTING);
7575
}
7676
break;
77-
case CONNECTION_STATE_CONNECTING: {
77+
case NetworkConnectionState::CONNECTING: {
7878
networkStatus = WiFi.begin(ssid, pass);
7979
debugMessage(DebugLevel::Verbose, "WiFi.status(): %d", networkStatus);
8080
if (networkStatus != NETWORK_CONNECTED) {
8181
debugMessage(DebugLevel::Error, "Connection to \"%s\" failed", ssid);
8282
debugMessage(DebugLevel::Info, "Retrying in \"%d\" milliseconds", connectionTickTimeInterval);
83-
//changeConnectionState(CONNECTION_STATE_CONNECTING);
83+
//changeConnectionState(NetworkConnectionState::CONNECTING);
8484
return;
8585
} else {
8686
debugMessage(DebugLevel::Info, "Connected to \"%s\"", ssid);
87-
changeConnectionState(CONNECTION_STATE_CONNECTED);
87+
changeConnectionState(NetworkConnectionState::CONNECTED);
8888
return;
8989
}
9090
}
9191
break;
92-
case CONNECTION_STATE_CONNECTED: {
92+
case NetworkConnectionState::CONNECTED: {
9393
// keep testing connection
9494
networkStatus = WiFi.status();
9595
debugMessage(DebugLevel::Verbose, "WiFi.status(): %d", networkStatus);
9696
if (networkStatus != WL_CONNECTED) {
97-
changeConnectionState(CONNECTION_STATE_DISCONNECTED);
97+
changeConnectionState(NetworkConnectionState::DISCONNECTED);
9898
return;
9999
}
100100
debugMessage(DebugLevel::Verbose, "Connected to \"%s\"", ssid);
101101
}
102102
break;
103-
case CONNECTION_STATE_DISCONNECTED: {
103+
case NetworkConnectionState::DISCONNECTED: {
104104
WiFi.end();
105-
changeConnectionState(CONNECTION_STATE_CONNECTING);
105+
changeConnectionState(NetworkConnectionState::CONNECTING);
106106
}
107107
break;
108108
}
@@ -117,27 +117,27 @@ void WiFiConnectionManager::check() {
117117
void WiFiConnectionManager::changeConnectionState(NetworkConnectionState _newState) {
118118
int newInterval = CHECK_INTERVAL_INIT;
119119
switch (_newState) {
120-
case CONNECTION_STATE_INIT: {
120+
case NetworkConnectionState::INIT: {
121121
newInterval = CHECK_INTERVAL_INIT;
122122
}
123123
break;
124-
case CONNECTION_STATE_CONNECTING: {
124+
case NetworkConnectionState::CONNECTING: {
125125
debugMessage(DebugLevel::Info, "Connecting to \"%s\"", ssid);
126126
newInterval = CHECK_INTERVAL_CONNECTING;
127127
}
128128
break;
129-
case CONNECTION_STATE_CONNECTED: {
129+
case NetworkConnectionState::CONNECTED: {
130130
newInterval = CHECK_INTERVAL_CONNECTED;
131131
}
132132
break;
133-
case CONNECTION_STATE_DISCONNECTED: {
133+
case NetworkConnectionState::DISCONNECTED: {
134134
debugMessage(DebugLevel::Verbose, "WiFi.status(): %d", WiFi.status());
135135
debugMessage(DebugLevel::Error, "Connection to \"%s\" lost.", ssid);
136136
debugMessage(DebugLevel::Error, "Attempting reconnection");
137137
newInterval = CHECK_INTERVAL_DISCONNECTED;
138138
}
139139
break;
140-
case CONNECTION_STATE_ERROR: {
140+
case NetworkConnectionState::ERROR: {
141141
debugMessage(DebugLevel::Error, "WiFi Hardware failure.\nMake sure you are using a WiFi enabled board/shield.");
142142
debugMessage(DebugLevel::Error, "Then reset and retry.");
143143
}

0 commit comments

Comments
 (0)