Merge pull request #34 from arduino-libraries/troubleshoot-report

print troubleshooting info, added broker port, general cleanup

Author: ubidefeo

Diff for: examples/ArduinoIoTCloud_LED_switch/ArduinoIoTCloud_LED_switch.ino

@@ -34,7 +34,7 @@ void setup() {
       
       setDebugMessageLevel(3);
   */
-
+  ArduinoCloud.printDebugInfo();
 }
 
 void loop() {
@@ -51,5 +51,5 @@ void loop() {
 void onLedChange() {
   Serial.print("LED set to ");
   Serial.println(led);
-  digitalWrite(LED_BUILTIN, ledSwitch);
+  digitalWrite(LED_BUILTIN, led);
 }

Diff for: src/ArduinoIoTCloud.cpp

@@ -53,32 +53,37 @@ ArduinoIoTCloudClass::~ArduinoIoTCloudClass()
   }
 }
 
-int ArduinoIoTCloudClass::begin(ConnectionManager *c, String brokerAddress)
+int ArduinoIoTCloudClass::begin(ConnectionManager *c, String brokerAddress, uint16_t brokerPort)
 {
   connection = c;
   Client &connectionClient = c->getClient();
   _brokerAddress = brokerAddress;
-  return begin(connectionClient, _brokerAddress);
+  _brokerPort = brokerPort;
+  return begin(connectionClient, _brokerAddress, _brokerPort);
 }
 
-int ArduinoIoTCloudClass::begin(Client& net, String brokerAddress)
+int ArduinoIoTCloudClass::begin(Client& net, String brokerAddress, uint16_t brokerPort)
 {
 
   _net = &net;
   // store the broker address as class member
   _brokerAddress = brokerAddress;
+  _brokerPort = brokerPort;
   byte thingIdBytes[72];
 
   if (!ECCX08.begin()) {
+    debugMessage("Cryptography processor failure. Make sure you have a compatible board.", 0);
     return 0;
   }
 
   if (!ECCX08.readSlot(thingIdSlot, thingIdBytes, sizeof(thingIdBytes))) {
+    debugMessage("Cryptography processor read failure.", 0);
     return 0;
   }
   _id = (char*)thingIdBytes;
 
   if (!ECCX08Cert.beginReconstruction(keySlot, compressedCertSlot, serialNumberAndAuthorityKeyIdentifierSlot)) {
+    debugMessage("Cryptography certificate reconstruction failure.", 0);
     return 0;
   }
 
@@ -89,6 +94,7 @@ int ArduinoIoTCloudClass::begin(Client& net, String brokerAddress)
   ECCX08Cert.setIssuerCommonName("Arduino");
 
   if (!ECCX08Cert.endReconstruction()) {
+    debugMessage("Cryptography certificate reconstruction failure.", 0);
     return 0;
   }
 
@@ -117,7 +123,6 @@ int ArduinoIoTCloudClass::begin(Client& net, String brokerAddress)
   mqttClientBegin();
 
   Thing.begin();
-
   return 1;
 }
 
@@ -152,7 +157,7 @@ int ArduinoIoTCloudClass::connect()
 {
   // Username: device id
   // Password: empty
-  if (!_mqttClient->connect(_brokerAddress.c_str(), 8883)) {
+  if (!_mqttClient->connect(_brokerAddress.c_str(), _brokerPort)) {
     return 0;
   }
   _mqttClient->subscribe(_stdinTopic);
@@ -298,15 +303,14 @@ void ArduinoIoTCloudClass::handleMessage(int length)
   }
 }
 
-void ArduinoIoTCloudClass::connectionCheck() {
+void ArduinoIoTCloudClass::connectionCheck()
+{
   if(connection != NULL){
     connection->check();
 
     if (connection->getStatus() != CONNECTION_STATE_CONNECTED) {
       if(iotStatus == IOT_STATUS_CLOUD_CONNECTED){
         setIoTConnectionState(IOT_STATUS_CLOUD_DISCONNECTED);
-      }else{
-        //setIoTConnectionState(IOT_STATUS_CLOUD_CONNECTING);
       }
       return;
     }
@@ -320,9 +324,9 @@ void ArduinoIoTCloudClass::connectionCheck() {
     {
       int connectionAttempt;
       if(connection == NULL){
-        connectionAttempt = begin(*_net, _brokerAddress);
+        connectionAttempt = begin(*_net, _brokerAddress, _brokerPort);
       }else{
-        connectionAttempt = begin(connection, _brokerAddress);
+        connectionAttempt = begin(connection, _brokerAddress, _brokerPort);
       }
       if(!connectionAttempt){
         debugMessage("Error Starting Arduino Cloud\nTrying again in a few seconds", 0);
@@ -331,8 +335,7 @@ void ArduinoIoTCloudClass::connectionCheck() {
       }
       setIoTConnectionState(IOT_STATUS_CLOUD_CONNECTING);
       break;
-    } 
-      
+    }
     case IOT_STATUS_CLOUD_ERROR:
       debugMessage("Cloud Error. Retrying...", 0);
       setIoTConnectionState(IOT_STATUS_CLOUD_RECONNECTING);
@@ -346,7 +349,6 @@ void ArduinoIoTCloudClass::connectionCheck() {
     case IOT_STATUS_CLOUD_RECONNECTING:
       int arduinoIoTReconnectionAttempt;
       arduinoIoTReconnectionAttempt = reconnect(*_net);
-      *msgBuffer = 0;
       sprintf(msgBuffer, "ArduinoCloud.reconnect(): %d", arduinoIoTReconnectionAttempt);
       debugMessage(msgBuffer, 2);
       if (arduinoIoTReconnectionAttempt == 1) {
@@ -356,10 +358,8 @@ void ArduinoIoTCloudClass::connectionCheck() {
       }
       break;
     case IOT_STATUS_CLOUD_CONNECTING:
-      
       int arduinoIoTConnectionAttempt;
       arduinoIoTConnectionAttempt = connect();
-      *msgBuffer = 0;
       sprintf(msgBuffer, "ArduinoCloud.connect(): %d", arduinoIoTConnectionAttempt);
       debugMessage(msgBuffer, 4);
       if (arduinoIoTConnectionAttempt == 1) {
@@ -371,7 +371,8 @@ void ArduinoIoTCloudClass::connectionCheck() {
   }
 }
 
-void ArduinoIoTCloudClass::setIoTConnectionState(ArduinoIoTConnectionStatus _newState){
+void ArduinoIoTCloudClass::setIoTConnectionState(ArduinoIoTConnectionStatus _newState)
+{
   switch(_newState){
     case IOT_STATUS_CLOUD_ERROR:
       debugMessage("Arduino, we have a problem.", 0);
@@ -392,4 +393,16 @@ void ArduinoIoTCloudClass::setIoTConnectionState(ArduinoIoTConnectionStatus _new
   iotStatus = _newState;
 }
 
+void ArduinoIoTCloudClass::printDebugInfo()
+{
+  char msgBuffer[120];
+  debugMessage("***** Arduino IoT Cloud - configuration info *****", 2);
+  sprintf(msgBuffer, "Device ID: %s", getDeviceId().c_str());
+  debugMessage(msgBuffer, 2);
+  sprintf(msgBuffer, "Thing ID: %s", getThingId().c_str());
+  debugMessage(msgBuffer, 2);
+  sprintf(msgBuffer, "MQTT Broker: %s:%d", _brokerAddress.c_str(), _brokerPort);
+  debugMessage(msgBuffer, 2);
+}
+
 ArduinoIoTCloudClass ArduinoCloud;

Diff for: src/ArduinoIoTCloud.h

@@ -25,6 +25,8 @@
 
 #include "CloudSerial.h"
 
+#define DEFAULT_BROKER_ADDRESS "mqtts-sa.iot.arduino.cc"
+#define DEFAULT_BROKER_PORT 8883
 typedef enum {
   READ      = 0x01,
   WRITE     = 0x02,
@@ -57,8 +59,8 @@ class ArduinoIoTCloudClass {
   ArduinoIoTCloudClass();
   ~ArduinoIoTCloudClass();
 
-  int begin(ConnectionManager *connection = ArduinoIoTPreferredConnection, String brokerAddress = "mqtts-sa.iot.arduino.cc");
-  int begin(Client& net, String brokerAddress = "mqtts-sa.iot.arduino.cc");
+  int begin(ConnectionManager *connection = ArduinoIoTPreferredConnection, String brokerAddress = DEFAULT_BROKER_ADDRESS, uint16_t brokerPort = DEFAULT_BROKER_PORT);
+  int begin(Client& net, String brokerAddress = DEFAULT_BROKER_ADDRESS, uint16_t brokerPort = DEFAULT_BROKER_PORT);
   // Class constant declaration
   static const int MQTT_TRANSMIT_BUFFER_SIZE = 256;
   static const int MAX_RETRIES = 5;
@@ -89,6 +91,8 @@ class ArduinoIoTCloudClass {
 
   static unsigned long const DEFAULT_MIN_TIME_BETWEEN_UPDATES_MILLIS = 100; /* Data rate throttled to 10 Hz */
 
+
+
   template<typename T, typename N=T>
   void addPropertyReal(T & property, String name, permissionType permission_type = READWRITE, long seconds = ON_CHANGE, void(*fn)(void) = NULL, N minDelta = N(0)) {
     Permission permission = Permission::ReadWrite;
@@ -110,6 +114,9 @@ class ArduinoIoTCloudClass {
   }
 
   void connectionCheck();
+  String getBrokerAddress(){ return _brokerAddress; }
+  uint16_t getBrokerPort() { return _brokerPort; }
+  void printDebugInfo();
 
 protected:
   friend class CloudSerialClass;
@@ -131,6 +138,7 @@ class ArduinoIoTCloudClass {
   String _id,
          _thing_id,
          _brokerAddress;
+  uint16_t _brokerPort;
   ArduinoCloudThing Thing;
   BearSSLClient* _bearSslClient;
   MqttClient* _mqttClient;

Diff for: src/WiFiConnectionManager.h

@@ -33,7 +33,7 @@ class WiFiConnectionManager : public ConnectionManager {
 
   const int CHECK_INTERVAL_INIT = 100;
   const int CHECK_INTERVAL_CONNECTING = 500;
-  const int CHECK_INTERVAL_GETTIME = 100;
+  const int CHECK_INTERVAL_GETTIME = 666;
   const int CHECK_INTERVAL_CONNECTED = 10000;
   const int CHECK_INTERVAL_RETRYING = 5000;
   const int CHECK_INTERVAL_DISCONNECTED = 1000;
@@ -73,7 +73,6 @@ void WiFiConnectionManager::changeConnectionState(NetworkConnectionState _newSta
       newInterval = CHECK_INTERVAL_INIT;
       break;
     case CONNECTION_STATE_CONNECTING:
-      *msgBuffer = 0;
       sprintf(msgBuffer, "Connecting to \"%s\"", ssid);
       debugMessage(msgBuffer, 2);
       newInterval = CHECK_INTERVAL_CONNECTING;
@@ -86,10 +85,9 @@ void WiFiConnectionManager::changeConnectionState(NetworkConnectionState _newSta
       newInterval = CHECK_INTERVAL_CONNECTED;
       break;
     case CONNECTION_STATE_DISCONNECTED:
-      *msgBuffer = 0;
+      debugMessage("", 3, false, true);
       sprintf(msgBuffer, "WiFi.status(): %d", WiFi.status());
       debugMessage(msgBuffer, 4);
-      *msgBuffer = 0;
       sprintf(msgBuffer, "Connection to \"%s\" lost.", ssid);
       debugMessage(msgBuffer, 0);
       debugMessage("Attempting reconnection", 0);
@@ -109,44 +107,37 @@ void WiFiConnectionManager::check() {
     switch (netConnectionState) {
       case CONNECTION_STATE_INIT:
         networkStatus = WiFi.status();
-        *msgBuffer = 0;
-        sprintf(msgBuffer, "WiFi.status(): %d", networkStatus);
-        debugMessage(msgBuffer, 2);
         if (networkStatus == NETWORK_HARDWARE_ERROR) {
           debugMessage("WiFi Hardware not available\nMake sure you are using a WiFi enabled board/shield", 0);
           // don't continue:
           changeConnectionState(CONNECTION_STATE_ERROR);
           lastConnectionTickTime = now;
           return;
         }
-        *msgBuffer = 0;
         sprintf(msgBuffer, "Current WiFi Firmware: %s", WiFi.firmwareVersion());
         debugMessage(msgBuffer, 0);
-        if(strcmp(WiFi.firmwareVersion(), WIFI_FIRMWARE_VERSION_REQUIRED) != 0){
-          *msgBuffer = 0;
+        if(WiFi.firmwareVersion() < WIFI_FIRMWARE_VERSION_REQUIRED){
           sprintf(msgBuffer, "Latest WiFi Firmware: %s", WIFI_FIRMWARE_VERSION_REQUIRED);
           debugMessage(msgBuffer, 0);
           debugMessage("Please update to latest version for optimal performance.", 0);
+          delay(5000);
         }
         changeConnectionState(CONNECTION_STATE_CONNECTING);
         break;
       case CONNECTION_STATE_CONNECTING:
         networkStatus = WiFi.begin(ssid, pass);
-        *msgBuffer = 0;
         sprintf(msgBuffer, "WiFi.status(): %d", networkStatus);
         debugMessage(msgBuffer, 4);
         if (networkStatus != NETWORK_CONNECTED) {
-          *msgBuffer = 0;
+          debugMessage("", 3, false, true);
           sprintf(msgBuffer, "Connection to \"%s\" failed", ssid);
           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 to \"%s\"", ssid);
           debugMessage(msgBuffer, 2);
           changeConnectionState(CONNECTION_STATE_GETTIME);
@@ -161,8 +152,8 @@ void WiFiConnectionManager::check() {
 
         debugMessage(".", 3, false, false);
         if(networkTime > lastValidTimestamp){
+          debugMessage("", 3, false, true);
           lastValidTimestamp = networkTime;
-          *msgBuffer = 0;
           sprintf(msgBuffer, "Network Time: %u", networkTime);
           debugMessage(msgBuffer, 3);
           changeConnectionState(CONNECTION_STATE_CONNECTED);
@@ -175,14 +166,12 @@ void WiFiConnectionManager::check() {
       case CONNECTION_STATE_CONNECTED:
         // keep testing connection
         networkStatus = WiFi.status();
-        *msgBuffer = 0;
         sprintf(msgBuffer, "WiFi.status(): %d", networkStatus);
         debugMessage(msgBuffer, 4);
         if (networkStatus != WL_CONNECTED) {
           changeConnectionState(CONNECTION_STATE_DISCONNECTED);
           return;
         }
-        *msgBuffer = 0;
         sprintf(msgBuffer, "Connected to \"%s\"", ssid);
         debugMessage(msgBuffer, 4);
         break;