Why does the generated JSON document contain garbage?

Description

You called JsonObject::printTo() and expected to get the following output:

{"hello":"world"} 

but instead you got:

{"hello":"�"} 

or any other kind of strange output.

Why does this happen?

Garbage in the output always has the same cause: the JsonObject contains pointers to destructed variables.

This problem happens when the JsonObject is constructed with variables that are destroyed before the call to printTo()

Example 1: the JsonBuffer is destructed

The following program creates a JsonObject from a temporary JsonBuffer. The problem is that the JsonBuffer is destructed as soon as the function returns, so the reference points to a destructed variable.

// DON'T DO THAT!!! JsonObject& createObject() { StaticJsonBuffer<200> jsonBuffer; JsonObject& obj = jsonBuffer.createObject(); obj["hello"] = "world"; return obj; } 

The best way to fix this function is to pass the JsonBuffer as an argument:

template<typename TJsonBuffer> JsonObject& createObject(TJsonBuffer& jsonBuffer) { JsonObject& obj = jsonBuffer.createObject(); obj["hello"] = "world"; return obj; } 

Note that this function uses a template to allow any kind of JsonBuffer to be used, not just StaticJsonBuffer<200>.

Example 2: destructed string

The following program fills a JsonObject with a temporary String:

// DON'T DO THAT!!! JsonObject& obj = jsonBuffer.createObject(); obj["address"] = address.toString().c_str(); obj.printTo(Serial); // <- likely to produce garbage 

The problem is that the call to address.toString() produce a temporary String that is destructed as soon as the line is executed.

By calling String::c_str(), the program gets a pointer to the temporary string and gives it to ArduinoJson. Since ArduinoJson sees a const char* it doesn’t duplicate the string and simply saves the pointer.

The problem can be avoided by removing the call to String::c_str():

JsonObject& obj = jsonBuffer.createObject(); obj["address"] = address.toString(); // <- duplicates obj.printTo(Serial); 

Now, ArduinoJson sees a String and knows that it needs to make a copy of the string in the JsonBuffer.

Example 3: destructed input in zero-copy mode

The following function uses the zero-copy mode, but doesn’t keep the input in memory:

JsonObject& loadPlastic(DynamicJsonBuffer& jsonBuffer){ File file = SPIFFS.open(HISTORY_FILE, "r"); // DON'T DO THAT!!! size_t size = file.size(); std::unique_ptr<char[]> buf (new char[size]); file.readBytes(buf.get(), size); JsonObject& root = jsonBuffer.parseObject(buf.get()); file.close(); return root; } 

Indeed, when called with a char* (or a char[]), JsonBuffer::parseObject() uses the zero-copy mode. In this mode, the JsonObject stores pointers to bytes in the input.

The zero-copy mode is very efficient, but it requires that the input variable has a longer lifetime than the JsonObject.

To fix this function, just change the type of the input to something that is read-only. In this particular case, it’s possible to pass the file directly:

JsonObject& loadPlastic(DynamicJsonBuffer& jsonBuffer){ File file = SPIFFS.open(HISTORY_FILE, "r"); JsonObject& root = jsonBuffer.parseObject(file); file.close(); return root; } 

Now, ArduinoJson will duplicates the relevant pieces of the input in the JsonBuffer.