Arduino Mastery: Automating Embedded Data Models

JSON to Arduino: Generating ArduinoJson Structs from JSON Payloads

Arduino projects increasingly communicate over WiFi, MQTT, or serial with JSON-based APIs — weather data, IoT sensor configs, home automation commands. The ArduinoJson library is the standard way to parse and serialize JSON on Arduino/ESP32/ESP8266. Generating the C++ struct and deserialization code from your JSON payload saves the tedious work of mapping each key to a field manually.

Live Example: Weather API Response

// Input JSON (OpenWeather API response)
{
  "city": "Tokyo",
  "temperature": 24.5,
  "humidity": 68,
  "wind_speed": 12.3,
  "is_raining": false,
  "description": "partly cloudy"
}

// Generated Arduino Code
// Generated by TypeMorph (requires ArduinoJson library)
#include <ArduinoJson.h>

struct Data {
  String city;
  double temperature;
  double humidity;
  double wind_speed;
  bool is_raining;
  String description;
};

void deserializeData(Stream& stream, Data& data) {
  StaticJsonDocument<1024> doc;
  deserializeJson(doc, stream);

  data.city        = doc["city"].as<String>();
  data.temperature = doc["temperature"];
  data.humidity    = doc["humidity"];
  data.wind_speed  = doc["wind_speed"];
  data.is_raining  = doc["is_raining"];
  data.description = doc["description"].as<String>();
}

Refined: ESP32 HTTP + ArduinoJson 7

#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>

const char* SSID     = "YourWiFiName";
const char* PASSWORD = "YourWiFiPass";
const char* API_URL  = "https://api.openweathermap.org/data/2.5/weather?q=Tokyo&appid=YOUR_KEY&units=metric";

struct WeatherData {
  String city;
  float  temperature;    // float saves RAM vs double on AVR
  int    humidity;       // int not double for whole numbers
  float  wind_speed;
  bool   is_raining;
  String description;
};

WeatherData fetchWeather() {
  WeatherData weather = {};

  HTTPClient http;
  http.begin(API_URL);
  int httpCode = http.GET();

  if (httpCode != HTTP_CODE_OK) {
    Serial.println("HTTP error: " + String(httpCode));
    http.end();
    return weather;
  }

  // ArduinoJson 7: JsonDocument (dynamic, no size needed)
  JsonDocument doc;
  DeserializationError error = deserializeJson(doc, http.getStream());
  http.end();

  if (error) {
    Serial.print("JSON parse error: ");
    Serial.println(error.c_str());
    return weather;
  }

  weather.city        = doc["name"].as<String>();
  weather.temperature = doc["main"]["temp"];
  weather.humidity    = doc["main"]["humidity"];
  weather.wind_speed  = doc["wind"]["speed"];
  weather.description = doc["weather"][0]["description"].as<String>();

  return weather;
}

void setup() {
  Serial.begin(115200);
  WiFi.begin(SSID, PASSWORD);
  while (WiFi.status() != WL_CONNECTED) delay(500);
  Serial.println("WiFi connected");

  WeatherData w = fetchWeather();
  Serial.printf("City: %s, Temp: %.1f°C, Humidity: %d%%\n",
    w.city.c_str(), w.temperature, w.humidity);
}

void loop() {
  // Re-fetch every 5 minutes
  delay(300000);
  WeatherData w = fetchWeather();
  Serial.printf("%.1f°C %d%%\n", w.temperature, w.humidity);
}

StaticJsonDocument vs DynamicJsonDocument vs JsonDocument

// ArduinoJson 6: must choose size upfront
StaticJsonDocument<512>  doc;  // stack-allocated, fixed 512 bytes
DynamicJsonDocument doc(1024); // heap-allocated, flexible size

// ArduinoJson 7: just JsonDocument (auto-sizing, heap)
JsonDocument doc;

// Choosing the right size for StaticJsonDocument (v6):
// Rule: JSON string length × 1.5 to 2 + overhead
// A 300-byte JSON response → StaticJsonDocument<1024> is safe

// Memory-constrained boards (Arduino Uno, Nano: only 2KB SRAM):
// Parse only the fields you need, don't store the whole doc
const char* city = doc["name"];        // temporary C string
float temp       = doc["main"]["temp"]; // copy the float
// doc goes out of scope → memory freed

MQTT: Publishing and Subscribing with JSON

#include <PubSubClient.h>
#include <ArduinoJson.h>

// Serialize sensor data to JSON and publish
void publishSensorData(PubSubClient& client, float temp, int humidity) {
  JsonDocument doc;
  doc["temperature"] = temp;
  doc["humidity"]    = humidity;
  doc["device_id"]   = "sensor_001";
  doc["timestamp"]   = millis();

  char buffer[128];
  serializeJson(doc, buffer, sizeof(buffer));
  client.publish("sensors/room1", buffer);
}

// Subscribe and parse incoming JSON commands
void onMessage(char* topic, byte* payload, unsigned int length) {
  JsonDocument doc;
  deserializeJson(doc, payload, length);

  if (doc["command"] == "set_threshold") {
    float threshold = doc["value"];
    setAlarmThreshold(threshold);
  }
}

Frequently Asked Questions

What's the right StaticJsonDocument size? Use the ArduinoJson Assistant — paste your JSON and it calculates the exact size. As a rule of thumb: JSON string byte length × 2 + 64 bytes overhead. Undersizing causes silent parse failures; oversizing wastes precious RAM.

Why float instead of double for temperatures? AVR-based Arduinos (Uno, Nano, Mega) have no FPU — double and float both use 4 bytes and give identical precision. On ESP32/ESP8266, double is 8 bytes and more precise. For sensor readings, float is almost always sufficient and saves RAM on AVR boards.

How do I parse a JSON array (e.g., [{"id":1}, {"id":2}])? Use doc.as<JsonArray>() and iterate: for (JsonObject item : doc.as<JsonArray>()) { int id = item["id"]; }. If the response is an array at the top level, pass the stream directly to deserializeJson — ArduinoJson handles it automatically.

Is my JSON sent to a server? No. TypeMorph runs entirely in your browser — none of your data leaves your machine.