Add GSM and Ethernet conn_manager + add fallback UDP based getTime()

examples/ArduinoIoTCloud_LED_switch/ArduinoIoTCloud_LED_switch.ino

@@ -5,7 +5,11 @@
   When the potentiometer (or sensor) value changes the data is sent to the Cloud.
   When you flip the switch in the Cloud dashboard the onboard LED lights gets turned ON or OFF.
 
-
+  IMPORTANT:
+  This sketch will work with both WiFi and GSM enabled boards supported by Arduino IoT Cloud.
+  By default settings for WiFi are chosen. If you prefer to use a GSM board take a look at thingProperties.h arduino_secrets.h,
+  to make sure you uncomment what's needed and comment incompatible instructions.
+
 */
 #include "arduino_secrets.h"
 #include "thingProperties.h"

examples/ArduinoIoTCloud_LED_switch/arduino_secrets.h

@@ -1,3 +1,15 @@
+/*
+	Fill in your login credentials:
+
+	The following lines are used for WiFi enabled boards (MKR1000, MKR WiFi 1010)
+*/
 #define SECRET_SSID "YOUR_WIFI_NETWORK_NAME"
 #define SECRET_PASS "YOUR_WIFI_PASSWORD"
-
+/*
+	If you prefer using a MKR GSM 1400 comment the lines above and uncommet the following.
+	PIN, APN, Login and Password are supplied by your Cellular Data provider.
+*/
+//#define SECRET_PIN ""
+//#define SECRET_APN ""
+//#define SECRET_LOGIN ""
+//#define SECRET_PASS ""

examples/ArduinoIoTCloud_LED_switch/thingProperties.h

@@ -1,9 +1,13 @@
 #include <ArduinoIoTCloud.h>
+/* 
+	The following include line is used for WiFi enabled boards (MKR1000, MKR WiFi 1010)
+*/
 #include <WiFiConnectionManager.h>
+/* 
+	If you prefer using a MKR GSM 1400 comment the line above and uncommet the following.
+*/
+//#include <GSMConnectionManager.h>
 
-
-char ssid[] = SECRET_SSID;        // your network SSID (name)
-char pass[] = SECRET_PASS;    // your network password (use for WPA, or use as key for WEP)
 // Your THING_ID
 #define THING_ID "ARDUINO_IOT_CLOUD_THING_ID"
 
@@ -18,4 +22,11 @@ void initProperties() {
   ArduinoCloud.addProperty(potentiometer, READ, ON_CHANGE);
 }
 
-ConnectionManager *ArduinoIoTPreferredConnection = new WiFiConnectionManager(SECRET_SSID, SECRET_PASS);
+/* 
+	The following include line is used for WiFi enabled boards (MKR1000, MKR WiFi 1010)
+*/
+ConnectionManager *ArduinoIoTPreferredConnection = new WiFiConnectionManager(SECRET_SSID, SECRET_PASS);
+/* 
+	If you prefer using a MKR GSM 1400 comment the line above and uncommet the following.
+*/
+//ConnectionManager *ArduinoIoTPreferredConnection = new GSMConnectionManager(SECRET_PIN, SECRET_APN, SECRET_LOGIN, SECRET_PASS);

library.properties

@@ -1,5 +1,5 @@
 name=ArduinoIoTCloud
-version=0.5.0
+version=0.5.1
 author=Arduino
 maintainer=Arduino <[email protected]>
 sentence=This library allows to connect to the Arduino IoT Cloud service.

src/ArduinoIoTCloud.cpp

@@ -29,7 +29,12 @@ static ConnectionManager *getTimeConnection = NULL;
 
 static unsigned long getTime() {
   if (!getTimeConnection) return 0;
-  return getTimeConnection->getTime();
+  unsigned long time = getTimeConnection->getTime();
+  if (!NTPUtils::isTimeValid(time)) {
+    debugMessage("Bogus NTP time from API, fallback to UDP method", 0);
+    time = NTPUtils(getTimeConnection->getUDP()).getTime();
+  }
+  return time;
 }
 
 ArduinoIoTCloudClass::ArduinoIoTCloudClass() :
@@ -118,7 +123,6 @@ int ArduinoIoTCloudClass::begin(Client& net, String brokerAddress, uint16_t brok
 
 
   // TODO: Find a better way to allow callback into object method
-
   // Begin function for the MQTTClient
   mqttClientBegin();
 
@@ -212,13 +216,6 @@ void ArduinoIoTCloudClass::update(int const reconnectionMaxRetries, int const re
   if(iotStatus != IOT_STATUS_CLOUD_CONNECTED){
     return;
   }
-  // Method's argument controls
-  int const maxRetries = (reconnectionMaxRetries > 0) ? reconnectionMaxRetries : MAX_RETRIES;
-  int const timeout    = (reconnectionTimeoutMs  > 0) ? reconnectionTimeoutMs  : RECONNECTION_TIMEOUT;
-
-  // If the reconnect() culd not establish the connection, return the control to the user sketch
-  if (!mqttReconnect(maxRetries, timeout))
-    return;
 
   // MTTQClient connected!, poll() used to retrieve data from MQTT broker
   _mqttClient->poll();
@@ -321,21 +318,8 @@ void ArduinoIoTCloudClass::connectionCheck()
 
   switch (iotStatus) {
     case IOT_STATUS_IDLE:
-    {
-      int connectionAttempt;
-      if(connection == NULL){
-        connectionAttempt = begin(*_net, _brokerAddress, _brokerPort);
-      }else{
-        connectionAttempt = begin(connection, _brokerAddress, _brokerPort);
-      }
-      if(!connectionAttempt){
-        debugMessage("Error Starting Arduino Cloud\nTrying again in a few seconds", 0);
-        setIoTConnectionState(IOT_STATUS_CLOUD_ERROR);
-        return;
-      }
       setIoTConnectionState(IOT_STATUS_CLOUD_CONNECTING);
       break;
-    }
     case IOT_STATUS_CLOUD_ERROR:
       debugMessage("Cloud Error. Retrying...", 0);
       setIoTConnectionState(IOT_STATUS_CLOUD_RECONNECTING);

src/CloudSerial.cpp

@@ -38,35 +38,30 @@ void CloudSerialClass::end()
 
 int CloudSerialClass::available()
 {
-  ArduinoCloud.update();
 
   return _rxBuffer.available();
 }
 
 int CloudSerialClass::availableForWrite()
 {
-  ArduinoCloud.update();
 
   return _txBuffer.availableForStore();
 }
 
 int CloudSerialClass::peek()
 {
-  ArduinoCloud.update();
 
   return _rxBuffer.peek();
 }
 
 int CloudSerialClass::read()
 {
-  ArduinoCloud.update();
 
   return _rxBuffer.read_char();
 }
 
 void CloudSerialClass::flush()
 {
-  ArduinoCloud.update();
 
   byte out[CLOUD_SERIAL_TX_BUFFER_SIZE];
   int length = 0;
@@ -91,7 +86,6 @@ size_t CloudSerialClass::write(const uint8_t data)
 
 CloudSerialClass::operator bool()
 {
-  ArduinoCloud.update();
 
   return ArduinoCloud.connected();
 }

src/ConnectionManager.h

@@ -21,6 +21,8 @@
 #define ARDUINO_CLOUD_DEBUG_LEVEL 2
 
 #include <Client.h>
+#include <Udp.h>
+#include "utility/NTPUtils.h"
 
 enum NetworkConnectionState {
   CONNECTION_STATE_INIT,
@@ -38,6 +40,7 @@ class ConnectionManager {
   virtual void check() = 0;
   virtual unsigned long getTime() = 0;
   virtual Client &getClient();
+  virtual UDP &getUDP();
 
   virtual NetworkConnectionState getStatus() { return netConnectionState; }
 
@@ -82,14 +85,14 @@ inline void debugMessage(char *_msg, int _debugLevel, bool _timestamp = true, bo
   if (_debugLevel <= debugMessageLevel) {
     char prepend[20];
     sprintf(prepend, "\n[ %d ] ", millis());
-    if(_timestamp)
+    if(_timestamp){
       Serial.print(prepend);
+    }
     if(_newline){
       Serial.println(_msg);
     }else{
       Serial.print(_msg);
     }
-
   }
 }
 

src/EthernetConnectionManager.h

@@ -0,0 +1,187 @@
+#include "ConnectionManager.h"
+
+#include <Ethernet.h>
+#define BOARD_HAS_ETHERNET
+
+class EthConnectionManager : public ConnectionManager {
+public:
+  EthConnectionManager(uint8_t *mac, int ss_pin);
+
+  virtual unsigned long getTime();
+  virtual void init();
+  virtual void check();
+  virtual Client &getClient() { return ethClient; };
+  virtual UDP &getUDP() { return udp; };
+
+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_GETTIME = 100;
+  const int CHECK_INTERVAL_CONNECTED = 10000;
+  const int CHECK_INTERVAL_RETRYING = 5000;
+  const int CHECK_INTERVAL_DISCONNECTED = 1000;
+  const int CHECK_INTERVAL_ERROR = 500;
+
+  unsigned long lastConnectionTickTime, lastNetworkStep;
+  uint8_t* mac;
+  int ss_pin;
+  EthernetClient ethClient;
+  EthernetUDP udp;
+  int connectionTickTimeInterval;
+};
+
+#if !defined(BOARD_HAS_WIFI) && !defined(BOARD_HAS_GSM)
+static const unsigned long NETWORK_CONNECTION_INTERVAL = 30000;
+#endif
+
+EthConnectionManager::EthConnectionManager(uint8_t *mac, int ss_pin = -1) :
+  mac(mac),
+  ss_pin(ss_pin),
+  lastConnectionTickTime(millis()),
+  connectionTickTimeInterval(CHECK_INTERVAL_IDLE) {
+}
+
+unsigned long EthConnectionManager::getTime() {
+  //handled by fallback manager
+  return lastValidTimestamp + 1;
+}
+
+void EthConnectionManager::init() {
+}
+
+void EthConnectionManager::changeConnectionState(NetworkConnectionState _newState) {
+  netConnectionState = _newState;
+  int newInterval = CHECK_INTERVAL_IDLE;
+  switch (_newState) {
+    case CONNECTION_STATE_INIT:
+      newInterval = CHECK_INTERVAL_INIT;
+      break;
+    case CONNECTION_STATE_CONNECTING:
+      newInterval = CHECK_INTERVAL_CONNECTING;
+      break;
+    case CONNECTION_STATE_GETTIME:
+      newInterval = CHECK_INTERVAL_GETTIME;
+      break;
+    case CONNECTION_STATE_CONNECTED:
+      newInterval = CHECK_INTERVAL_CONNECTED;
+      break;
+    case CONNECTION_STATE_DISCONNECTED:
+      newInterval = CHECK_INTERVAL_DISCONNECTED;
+
+      break;
+  }
+  connectionTickTimeInterval = newInterval;
+  lastConnectionTickTime = millis();
+}
+
+void EthConnectionManager::check() {
+  char msgBuffer[120];
+  unsigned long const now = millis();
+  int networkStatus = 0;
+  if (now - lastConnectionTickTime > connectionTickTimeInterval) {
+    switch (netConnectionState) {
+      case CONNECTION_STATE_INIT:
+        if (ss_pin == -1) {
+          networkStatus = Ethernet.begin(mac);
+        } else {
+          networkStatus = Ethernet.begin(mac, ss_pin);
+        }
+        networkStatus = Ethernet.hardwareStatus();
+        *msgBuffer = 0;
+        sprintf(msgBuffer, "Eth hardware status(): %d", networkStatus);
+        debugMessage(msgBuffer, 2);
+        if (networkStatus == EthernetNoHardware) {
+          debugMessage("No Ethernet chip connected", 0);
+          // don't continue:
+          changeConnectionState(CONNECTION_STATE_ERROR);
+          lastConnectionTickTime = now;
+          return;
+        }
+        networkStatus = Ethernet.linkStatus();
+        *msgBuffer = 0;
+        sprintf(msgBuffer, "Eth link status(): %d", networkStatus);
+        debugMessage(msgBuffer, 2);
+        if (networkStatus == LinkOFF) {
+          debugMessage("Failed to configure Ethernet via dhcp", 0);
+          // don't continue:
+          changeConnectionState(CONNECTION_STATE_ERROR);
+          lastConnectionTickTime = now;
+          return;
+        }
+        *msgBuffer = 0;
+        sprintf(msgBuffer, "Ethernet shield recognized: ID", Ethernet.hardwareStatus());
+        debugMessage(msgBuffer, 0);
+        changeConnectionState(CONNECTION_STATE_CONNECTING);
+        break;
+      case CONNECTION_STATE_CONNECTING:
+        *msgBuffer = 0;
+        sprintf(msgBuffer, "Connecting via dhcp");
+        debugMessage(msgBuffer, 2);
+        if (ss_pin == -1) {
+          networkStatus = Ethernet.begin(mac);
+        } else {
+          networkStatus = Ethernet.begin(mac, ss_pin);
+        }
+        *msgBuffer = 0;
+        sprintf(msgBuffer, "Ethernet.status(): %d", networkStatus);
+        debugMessage(msgBuffer, 2);
+        if (networkStatus == 0) {
+          *msgBuffer = 0;
+          sprintf(msgBuffer, "Connection failed");
+          debugMessage(msgBuffer, 0);
+
+          *msgBuffer = 0;
+          sprintf(msgBuffer, "Retrying in  \"%d\" milliseconds", connectionTickTimeInterval);
+          debugMessage(msgBuffer, 2);
+          //changeConnectionState(CONNECTION_STATE_CONNECTING);
+          return;
+        } else {
+          *msgBuffer = 0;
+          sprintf(msgBuffer, "Connected!");
+          debugMessage(msgBuffer, 2);
+          changeConnectionState(CONNECTION_STATE_GETTIME);
+          return;
+        }
+        break;
+      case CONNECTION_STATE_GETTIME:
+        debugMessage("Acquiring Time from Network", 3);
+        unsigned long networkTime;
+        networkTime = getTime();
+        *msgBuffer = 0;
+        sprintf(msgBuffer, "Network Time: %u", networkTime);
+        debugMessage(msgBuffer, 3);
+        if(networkTime > lastValidTimestamp){
+          lastValidTimestamp = networkTime;
+          changeConnectionState(CONNECTION_STATE_CONNECTED);
+        }
+        break;
+      case CONNECTION_STATE_CONNECTED:
+        // keep testing connection
+        Ethernet.maintain();
+        networkStatus = Ethernet.linkStatus();
+        *msgBuffer = 0;
+        sprintf(msgBuffer, "Eth link status(): %d", networkStatus);
+        debugMessage(msgBuffer, 4);
+        if (networkStatus != LinkON) {
+          changeConnectionState(CONNECTION_STATE_DISCONNECTED);
+          return;
+        }
+        *msgBuffer = 0;
+        sprintf(msgBuffer, "Connected");
+        debugMessage(msgBuffer, 2);
+        break;
+      case CONNECTION_STATE_DISCONNECTED:
+        *msgBuffer = 0;
+        sprintf(msgBuffer, "Connection lost.");
+        debugMessage(msgBuffer, 0);
+        debugMessage("Attempting reconnection", 1);
+        changeConnectionState(CONNECTION_STATE_CONNECTING);
+        //wifiClient.stop();
+        break;
+    }
+    lastConnectionTickTime = now;
+  }
+}