Publish refactoring (#298)

* factoring of the publishing function
* integration of json publishing to MQTT
* receiving and transcode json messages from mqtt
* replace the TRACE runtime condition by a buildtime one so as to decrease program size
* remove retainFlag parameter not necessary for the moment
* Increase the scope of tests for arduino mega and esp32
* Update arduinojson library to 5.13.3
* add macros to choose between simple or json publishing or both
* differentiate build test for ATmega2560
* correct wrong sprintf definition
* change IDE version for continuous integration
* let default warning level in arduino ide
* correct pins for ESP32
* reorganize user_config

lib/ArduinoJson/src/ArduinoJson.hpp

@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include "ArduinoJson/version.hpp"
+
 #include "ArduinoJson/DynamicJsonBuffer.hpp"
 #include "ArduinoJson/JsonArray.hpp"
 #include "ArduinoJson/JsonObject.hpp"

lib/ArduinoJson/src/ArduinoJson/Deserialization/JsonParser.hpp

@@ -44,7 +44,6 @@ class JsonParser {
 
   const char *parseString();
   bool parseAnythingTo(JsonVariant *destination);
-  FORCE_INLINE bool parseAnythingToUnsafe(JsonVariant *destination);
 
   inline bool parseArrayTo(JsonVariant *destination);
   inline bool parseObjectTo(JsonVariant *destination);

lib/ArduinoJson/src/ArduinoJson/Deserialization/JsonParserImpl.hpp

@@ -20,17 +20,6 @@ template <typename TReader, typename TWriter>
 inline bool
 ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseAnythingTo(
     JsonVariant *destination) {
-  if (_nestingLimit == 0) return false;
-  _nestingLimit--;
-  bool success = parseAnythingToUnsafe(destination);
-  _nestingLimit++;
-  return success;
-}
-
-template <typename TReader, typename TWriter>
-inline bool
-ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseAnythingToUnsafe(
-    JsonVariant *destination) {
   skipSpacesAndComments(_reader);
 
   switch (_reader.current()) {
@@ -48,6 +37,9 @@ ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseAnythingToUnsafe(
 template <typename TReader, typename TWriter>
 inline ArduinoJson::JsonArray &
 ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseArray() {
+  if (_nestingLimit == 0) return JsonArray::invalid();
+  _nestingLimit--;
+
   // Create an empty array
   JsonArray &array = _buffer->createArray();
 
@@ -69,6 +61,7 @@ ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseArray() {
 
 SUCCESS_EMPTY_ARRAY:
 SUCCES_NON_EMPTY_ARRAY:
+  _nestingLimit++;
   return array;
 
 ERROR_INVALID_VALUE:
@@ -91,6 +84,9 @@ inline bool ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseArrayTo(
 template <typename TReader, typename TWriter>
 inline ArduinoJson::JsonObject &
 ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseObject() {
+  if (_nestingLimit == 0) return JsonObject::invalid();
+  _nestingLimit--;
+
   // Create an empty object
   JsonObject &object = _buffer->createObject();
 
@@ -117,6 +113,7 @@ ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseObject() {
 
 SUCCESS_EMPTY_OBJECT:
 SUCCESS_NON_EMPTY_OBJECT:
+  _nestingLimit++;
   return object;
 
 ERROR_INVALID_KEY:

lib/ArduinoJson/src/ArduinoJson/JsonObject.hpp

@@ -286,15 +286,21 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
 
   template <typename TStringRef, typename TValueRef>
   bool set_impl(TStringRef key, TValueRef value) {
+    // ignore null key
+    if (Internals::StringTraits<TStringRef>::is_null(key)) return false;
+
+    // search a matching key
     iterator it = findKey<TStringRef>(key);
     if (it == end()) {
+      // add the key
       it = Internals::List<JsonPair>::add();
       if (it == end()) return false;
-
       bool key_ok =
           Internals::ValueSaver<TStringRef>::save(_buffer, it->key, key);
       if (!key_ok) return false;
     }
+
+    // save the value
     return Internals::ValueSaver<TValueRef>::save(_buffer, it->value, value);
   }
 
@@ -318,5 +324,5 @@ struct JsonVariantDefault<JsonObject> {
     return JsonObject::invalid();
   }
 };
-}
-}
+}  // namespace Internals
+}  // namespace ArduinoJson

lib/ArduinoJson/src/ArduinoJson/JsonVariant.hpp

@@ -274,9 +274,11 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
   //
   // bool is<const char*>() const;
   // bool is<char*>() const;
+  // bool is<std::string>() const;
   template <typename T>
   typename Internals::EnableIf<Internals::IsSame<T, const char *>::value ||
-                                   Internals::IsSame<T, char *>::value,
+                                   Internals::IsSame<T, char *>::value ||
+                                   Internals::StringTraits<T>::has_append,
                                bool>::type
   is() const {
     return variantIsString();
@@ -352,4 +354,4 @@ DEPRECATED("Decimal places are ignored, use the double value instead")
 inline JsonVariant double_with_n_digits(double value, uint8_t) {
   return JsonVariant(value);
 }
-}
+}  // namespace ArduinoJson

lib/ArduinoJson/src/ArduinoJson/JsonVariantComparisons.hpp

@@ -129,10 +129,11 @@ class JsonVariantComparisons {
     if (is<JsonObject>() && right.template is<JsonObject>())
       return as<JsonObject>() == right.template as<JsonObject>();
     if (is<char *>() && right.template is<char *>())
-      return strcmp(as<char *>(), right.template as<char *>()) == 0;
+      return StringTraits<const char *>::equals(as<char *>(),
+                                                right.template as<char *>());
 
     return false;
   }
 };
-}
-}
+}  // namespace Internals
+}  // namespace ArduinoJson

lib/ArduinoJson/src/ArduinoJson/Polyfills/isInteger.hpp

@@ -10,10 +10,10 @@ namespace ArduinoJson {
 namespace Internals {
 
 inline bool isInteger(const char* s) {
-  if (!s) return false;
+  if (!s || !*s) return false;
   if (issign(*s)) s++;
   while (isdigit(*s)) s++;
   return *s == '\0';
 }
-}
-}
+}  // namespace Internals
+}  // namespace ArduinoJson

lib/ArduinoJson/src/ArduinoJson/StringTraits/CharPointer.hpp

@@ -30,7 +30,9 @@ struct CharPointerTraits {
   };
 
   static bool equals(const TChar* str, const char* expected) {
-    return strcmp(reinterpret_cast<const char*>(str), expected) == 0;
+    const char* actual = reinterpret_cast<const char*>(str);
+    if (!actual || !expected) return actual == expected;
+    return strcmp(actual, expected) == 0;
   }
 
   static bool is_null(const TChar* str) {
@@ -58,5 +60,5 @@ struct CharPointerTraits {
 template <typename TChar>
 struct StringTraits<TChar*, typename EnableIf<IsChar<TChar>::value>::type>
     : CharPointerTraits<TChar> {};
-}
-}
+}  // namespace Internals
+}  // namespace ArduinoJson

lib/ArduinoJson/src/ArduinoJson/StringTraits/FlashString.hpp

@@ -31,7 +31,9 @@ struct StringTraits<const __FlashStringHelper*, void> {
   };
 
   static bool equals(const __FlashStringHelper* str, const char* expected) {
-    return strcmp_P(expected, (const char*)str) == 0;
+    const char* actual = reinterpret_cast<const char*>(str);
+    if (!actual || !expected) return actual == expected;
+    return strcmp_P(expected, actual) == 0;
   }
 
   static bool is_null(const __FlashStringHelper* str) {
@@ -53,7 +55,7 @@ struct StringTraits<const __FlashStringHelper*, void> {
   static const bool has_equals = true;
   static const bool should_duplicate = true;
 };
-}
-}
+}  // namespace Internals
+}  // namespace ArduinoJson
 
 #endif

lib/ArduinoJson/src/ArduinoJson/StringTraits/StdString.hpp

@@ -40,7 +40,10 @@ struct StdStringTraits {
   };
 
   static bool equals(const TString& str, const char* expected) {
-    return 0 == strcmp(str.c_str(), expected);
+    // Arduino's String::c_str() can return NULL
+    const char* actual = str.c_str();
+    if (!actual || !expected) return actual == expected;
+    return 0 == strcmp(actual, expected);
   }
 
   static void append(TString& str, char c) {
@@ -68,7 +71,7 @@ struct StringTraits<StringSumHelper, void> : StdStringTraits<StringSumHelper> {
 template <>
 struct StringTraits<std::string, void> : StdStringTraits<std::string> {};
 #endif
-}
-}
+}  // namespace Internals
+}  // namespace ArduinoJson
 
 #endif

lib/ArduinoJson/src/ArduinoJson/TypeTraits/FloatTraits.hpp

@@ -44,28 +44,46 @@ struct FloatTraits<T, 8 /*64bits*/> {
 
   static T positiveBinaryPowerOfTen(int index) {
     static T factors[] = {
-        1e1, 1e2, 1e4, 1e8, 1e16, 1e32,
-        // workaround to support platforms with single precision literals
-        forge(0x4D384F03, 0xE93FF9F5), forge(0x5A827748, 0xF9301D32),
-        forge(0x75154FDD, 0x7F73BF3C)};
+        1e1,
+        1e2,
+        1e4,
+        1e8,
+        1e16,
+        forge(0x4693B8B5, 0xB5056E17),  // 1e32
+        forge(0x4D384F03, 0xE93FF9F5),  // 1e64
+        forge(0x5A827748, 0xF9301D32),  // 1e128
+        forge(0x75154FDD, 0x7F73BF3C)   // 1e256
+    };
     return factors[index];
   }
 
   static T negativeBinaryPowerOfTen(int index) {
     static T factors[] = {
-        1e-1, 1e-2, 1e-4, 1e-8, 1e-16, 1e-32,
-        // workaround to support platforms with single precision literals
-        forge(0x32A50FFD, 0x44F4A73D), forge(0x255BBA08, 0xCF8C979D),
-        forge(0x0AC80628, 0x64AC6F43)};
+        forge(0x3FB99999, 0x9999999A),  // 1e-1
+        forge(0x3F847AE1, 0x47AE147B),  // 1e-2
+        forge(0x3F1A36E2, 0xEB1C432D),  // 1e-4
+        forge(0x3E45798E, 0xE2308C3A),  // 1e-8
+        forge(0x3C9CD2B2, 0x97D889BC),  // 1e-16
+        forge(0x3949F623, 0xD5A8A733),  // 1e-32
+        forge(0x32A50FFD, 0x44F4A73D),  // 1e-64
+        forge(0x255BBA08, 0xCF8C979D),  // 1e-128
+        forge(0x0AC80628, 0x64AC6F43)   // 1e-256
+    };
     return factors[index];
   }
 
   static T negativeBinaryPowerOfTenPlusOne(int index) {
     static T factors[] = {
-        1e0, 1e-1, 1e-3, 1e-7, 1e-15, 1e-31,
-        // workaround to support platforms with single precision literals
-        forge(0x32DA53FC, 0x9631D10D), forge(0x25915445, 0x81B7DEC2),
-        forge(0x0AFE07B2, 0x7DD78B14)};
+        1e0,
+        forge(0x3FB99999, 0x9999999A),  // 1e-1
+        forge(0x3F50624D, 0xD2F1A9FC),  // 1e-3
+        forge(0x3E7AD7F2, 0x9ABCAF48),  // 1e-7
+        forge(0x3CD203AF, 0x9EE75616),  // 1e-15
+        forge(0x398039D6, 0x65896880),  // 1e-31
+        forge(0x32DA53FC, 0x9631D10D),  // 1e-63
+        forge(0x25915445, 0x81B7DEC2),  // 1e-127
+        forge(0x0AFE07B2, 0x7DD78B14)   // 1e-255
+    };
     return factors[index];
   }
 
@@ -77,6 +95,9 @@ struct FloatTraits<T, 8 /*64bits*/> {
     return forge(0x7ff00000, 0x00000000);
   }
 
+  // constructs a double floating point values from its binary representation
+  // we use this function to workaround platforms with single precision literals
+  // (for example, when -fsingle-precision-constant is passed to GCC)
   static T forge(uint32_t msb, uint32_t lsb) {
     union {
       uint64_t integerBits;

lib/ArduinoJson/src/ArduinoJson/version.hpp

@@ -0,0 +1,10 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#pragma once
+
+#define ARDUINOJSON_VERSION "5.13.3"
+#define ARDUINOJSON_VERSION_MAJOR 5
+#define ARDUINOJSON_VERSION_MINOR 13
+#define ARDUINOJSON_VERSION_REVISION 3