Mirror sensor state and trigger a twin command

Compare a DHT22 reading with its local digital-twin mirror, history, prediction, and temperature-triggered LED command.

Blueprint Bina: I want you to compare the observed state, the model’s prediction, and the command that actually changes the LED., your practice guide

Blueprint Bina: I want you to compare the observed state, the model’s prediction, and the command that actually changes the LED.
Predict the reading, then compare it with the measurement.

Wokwi ESP32

Third party Tool

Tier 1 · Web · No account

Version tested: Compiled and booted by the Wokwi gate (ESP32 Arduino core 3.3.11); captured in the Wokwi web editor on 2026-09-09. Date: 2026-09-09.

Open the ESP32 editor, paste diagram.json, then paste sketch.ino.

Open Wokwi to paste in the files (new tab)

Get the files

Use both prepared files. This is a paste-in setup; saving a project requires a Wokwi account.

diagram.json

1,885 bytes · Circuit connections

Download

{
  "version": 1,
  "author": "IoTClass",
  "editor": "wokwi",
  "parts": [
    {
      "type": "wokwi-esp32-devkit-v1",
      "id": "esp",
      "top": 100,
      "left": 50,
      "attrs": {}
    },
    {
      "type": "wokwi-dht22",
      "id": "dht",
      "top": -100,
      "left": 0,
      "attrs": {
        "temperature": "24",
        "humidity": "40"
      }
    },
    {
      "type": "wokwi-led",
      "id": "led",
      "top": -70,
      "left": 250,
      "attrs": {
        "color": "red"
      }
    },
    {
      "type": "wokwi-resistor",
      "id": "ledR",
      "top": -5,
      "left": 250,
      "attrs": {
        "value": "220"
      }
    },
    {
      "type": "wokwi-pushbutton",
      "id": "sync",
      "top": 210,
      "left": 270,
      "attrs": {
        "color": "green",
        "bounce": "0"
      }
    },
    {
      "type": "wokwi-resistor",
      "id": "syncR",
      "top": 280,
      "left": 270,
      "attrs": {
        "value": "10000"
      }
    }
  ],
  "connections": [
    [
      "esp:TX0",
      "$serialMonitor:RX",
      "",
      []
    ],
    [
      "esp:RX0",
      "$serialMonitor:TX",
      "",
      []
    ],
    [
      "dht:VCC",
      "esp:3V3",
      "red",
      []
    ],
    [
      "dht:GND",
      "esp:GND.1",
      "black",
      []
    ],
    [
      "dht:SDA",
      "esp:D4",
      "green",
      []
    ],
    [
      "esp:D2",
      "led:A",
      "red",
      []
    ],
    [
      "led:C",
      "ledR:1",
      "black",
      []
    ],
    [
      "ledR:2",
      "esp:GND.1",
      "black",
      []
    ],
    [
      "esp:D15",
      "sync:1.l",
      "green",
      []
    ],
    [
      "sync:2.l",
      "esp:3V3",
      "red",
      []
    ],
    [
      "sync:1.l",
      "syncR:1",
      "black",
      []
    ],
    [
      "syncR:2",
      "esp:GND.1",
      "black",
      []
    ]
  ]
}

sketch.ino

13,043 bytes · ESP32 program

Download

/*
 * Digital Twin Demonstration - ESP32
 *
 * This program demonstrates core digital twin concepts:
 * 1. Physical State Monitoring - Reading sensors (temperature, button)
 * 2. Digital Twin State - Maintaining a virtual copy of device state
 * 3. Bidirectional Sync - Physical updates twin, twin controls LED
 * 4. State History - Circular buffer tracking past states
 * 5. Prediction - Simple trend analysis for forecasting
 *
 * Hardware: ESP32 + DHT22 + LED + Button
 */

#include <DHT.h>

// ============ PIN DEFINITIONS ============
#define DHT_PIN 4          // DHT22 data pin
#define LED_PIN 2          // LED output pin
#define BUTTON_PIN 15      // Button input pin
#define DHT_TYPE DHT22

// ============ DIGITAL TWIN CONFIGURATION ============
#define HISTORY_SIZE 10    // Circular buffer size for state history
#define SYNC_INTERVAL 2000 // Milliseconds between sync cycles
#define PREDICTION_HORIZON 3 // Predict N cycles ahead

// ============ DATA STRUCTURES ============

// Physical Device State - What the actual hardware reports
struct PhysicalState {
  float temperature;
  float humidity;
  bool buttonPressed;
  bool ledState;
  unsigned long timestamp;
};

// Digital Twin State - Virtual copy with additional metadata
struct DigitalTwin {
  // Mirrored physical state
  float temperature;
  float humidity;
  bool buttonPressed;
  bool ledState;

// Twin-specific metadata
  unsigned long lastSyncTime;
  unsigned long syncCount;
  bool isOnline;
  float syncLatencyMs;

// Derived analytics
  float avgTemperature;
  float tempTrend;           // Degrees per cycle (positive = rising)
  float predictedTemp;       // Forecasted temperature
  String healthStatus;

// Alert thresholds (configurable from "cloud")
  float tempAlertHigh;
  float tempAlertLow;
};

// State History Entry
struct HistoryEntry {
  float temperature;
  float humidity;
  bool buttonState;
  unsigned long timestamp;
};

// ============ GLOBAL VARIABLES ============
DHT dht(DHT_PIN, DHT_TYPE);

PhysicalState physicalDevice;
DigitalTwin digitalTwin;
HistoryEntry stateHistory[HISTORY_SIZE];
int historyIndex = 0;
int historyCount = 0;

unsigned long lastSyncTime = 0;
unsigned long lastButtonTime = 0;
bool lastButtonState = false;

// ============ INITIALIZATION ============
void setup() {
  Serial.begin(115200);
  delay(1000);

// Initialize hardware
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT);
  dht.begin();
  // Seed edge detection from the real input level; boot is not a button press.
  lastButtonState = digitalRead(BUTTON_PIN) == HIGH;

// Initialize digital twin with defaults
  initializeDigitalTwin();

Serial.println("\n========================================");
  Serial.println("   DIGITAL TWIN DEMONSTRATION");
  Serial.println("========================================");
  Serial.println("Physical Device: ESP32 + DHT22 + LED + Button");
  Serial.println("Digital Twin: Virtual state mirror with predictions");
  Serial.println("----------------------------------------");
  Serial.println("Press button to trigger manual sync");
  Serial.println("Watch temperature trends and predictions");
  Serial.println("========================================\n");
}

void initializeDigitalTwin() {
  digitalTwin.temperature = 0;
  digitalTwin.humidity = 0;
  digitalTwin.buttonPressed = false;
  digitalTwin.ledState = false;
  digitalTwin.lastSyncTime = 0;
  digitalTwin.syncCount = 0;
  digitalTwin.isOnline = true;
  digitalTwin.syncLatencyMs = 0;
  digitalTwin.avgTemperature = 0;
  digitalTwin.tempTrend = 0;
  digitalTwin.predictedTemp = 0;
  digitalTwin.healthStatus = "Initializing";
  digitalTwin.tempAlertHigh = 30.0;  // Alert if above 30C
  digitalTwin.tempAlertLow = 15.0;   // Alert if below 15C
}

// ============ MAIN LOOP ============
void loop() {
  // Check for button press (manual sync trigger)
  handleButtonInput();

// Periodic synchronization cycle
  if (millis() - lastSyncTime >= SYNC_INTERVAL) {
    performSyncCycle();
    lastSyncTime = millis();
  }
}

// ============ BUTTON HANDLING ============
void handleButtonInput() {
  bool currentButton = digitalRead(BUTTON_PIN) == HIGH;

// Debounce and detect press
  if (currentButton && !lastButtonState && (millis() - lastButtonTime > 200)) {
    lastButtonTime = millis();
    physicalDevice.buttonPressed = true;

Serial.println("\n[PHYSICAL] Button pressed - Triggering immediate sync");

// Button press toggles LED (bidirectional: physical input -> twin -> physical output)
    toggleLedFromTwin();
    performSyncCycle();
  } else {
    physicalDevice.buttonPressed = false;
  }

lastButtonState = currentButton;
}

// ============ SYNCHRONIZATION CYCLE ============
void performSyncCycle() {
  unsigned long syncStart = millis();

Serial.println("\n========== SYNC CYCLE ==========");

// STEP 1: Read Physical State (Physical -> Digital)
  readPhysicalState();

// STEP 2: Update Digital Twin (Mirror physical state)
  updateDigitalTwin();

// STEP 3: Record History (Circular buffer)
  recordStateHistory();

// STEP 4: Run Analytics (Twin-side processing)
  runTwinAnalytics();

// STEP 5: Make Predictions (Forecasting)
  calculatePredictions();

// STEP 6: Execute Twin Commands (Digital -> Physical)
  executeTwinCommands();

// Calculate sync latency
  digitalTwin.syncLatencyMs = millis() - syncStart;
  digitalTwin.syncCount++;

// STEP 7: Display Twin Status
  displayTwinStatus();
}

// ============ PHYSICAL STATE READING ============
void readPhysicalState() {
  Serial.println("[PHYSICAL] Reading sensor data...");

// Read DHT22 sensor
  float temp = dht.readTemperature();
  float hum = dht.readHumidity();

// Validate readings
  if (isnan(temp) || isnan(hum)) {
    Serial.println("[PHYSICAL] WARNING: Sensor read failed, using last known values");
    // Keep previous values if read fails
  } else {
    physicalDevice.temperature = temp;
    physicalDevice.humidity = hum;
  }

physicalDevice.ledState = digitalRead(LED_PIN) == HIGH;
  physicalDevice.timestamp = millis();

Serial.print("[PHYSICAL] Temp: ");
  Serial.print(physicalDevice.temperature, 1);
  Serial.print("C, Humidity: ");
  Serial.print(physicalDevice.humidity, 1);
  Serial.print("%, LED: ");
  Serial.println(physicalDevice.ledState ? "ON" : "OFF");
}

// ============ DIGITAL TWIN UPDATE ============
void updateDigitalTwin() {
  Serial.println("[TWIN] Synchronizing state from physical device...");

// Mirror physical state to twin (Physical -> Digital sync)
  digitalTwin.temperature = physicalDevice.temperature;
  digitalTwin.humidity = physicalDevice.humidity;
  digitalTwin.buttonPressed = physicalDevice.buttonPressed;
  digitalTwin.ledState = physicalDevice.ledState;
  digitalTwin.lastSyncTime = millis();
  digitalTwin.isOnline = true;

Serial.println("[TWIN] State synchronized successfully");
}

// ============ STATE HISTORY RECORDING ============
void recordStateHistory() {
  // Store current state in circular buffer
  stateHistory[historyIndex].temperature = physicalDevice.temperature;
  stateHistory[historyIndex].humidity = physicalDevice.humidity;
  stateHistory[historyIndex].buttonState = physicalDevice.buttonPressed;
  stateHistory[historyIndex].timestamp = millis();

// Advance circular buffer index
  historyIndex = (historyIndex + 1) % HISTORY_SIZE;
  if (historyCount < HISTORY_SIZE) {
    historyCount++;
  }

Serial.print("[HISTORY] Recorded state ");
  Serial.print(digitalTwin.syncCount);
  Serial.print(" (buffer: ");
  Serial.print(historyCount);
  Serial.print("/");
  Serial.print(HISTORY_SIZE);
  Serial.println(" entries)");
}

// ============ TWIN ANALYTICS ============
void runTwinAnalytics() {
  Serial.println("[ANALYTICS] Processing twin data...");

// Calculate average temperature from history
  if (historyCount > 0) {
    float sum = 0;
    for (int i = 0; i < historyCount; i++) {
      sum += stateHistory[i].temperature;
    }
    digitalTwin.avgTemperature = sum / historyCount;
  }

// Calculate temperature trend (simple linear regression)
  if (historyCount >= 3) {
    // Compare recent readings to determine trend
    int newestIdx = (historyIndex - 1 + HISTORY_SIZE) % HISTORY_SIZE;
    int olderIdx = (historyIndex - min(3, historyCount) + HISTORY_SIZE) % HISTORY_SIZE;

float newestTemp = stateHistory[newestIdx].temperature;
    float olderTemp = stateHistory[olderIdx].temperature;
    int samples = min(3, historyCount);

// Trend = change per cycle
    digitalTwin.tempTrend = (newestTemp - olderTemp) / samples;
  }

// Determine health status based on thresholds
  if (physicalDevice.temperature > digitalTwin.tempAlertHigh) {
    digitalTwin.healthStatus = "WARNING: High Temp";
  } else if (physicalDevice.temperature < digitalTwin.tempAlertLow) {
    digitalTwin.healthStatus = "WARNING: Low Temp";
  } else if (abs(digitalTwin.tempTrend) > 0.5) {
    digitalTwin.healthStatus = "NOTICE: Rapid Change";
  } else {
    digitalTwin.healthStatus = "NORMAL";
  }

Serial.print("[ANALYTICS] Avg Temp: ");
  Serial.print(digitalTwin.avgTemperature, 1);
  Serial.print("C, Trend: ");
  Serial.print(digitalTwin.tempTrend >= 0 ? "+" : "");
  Serial.print(digitalTwin.tempTrend, 2);
  Serial.println("C/cycle");
}

// ============ PREDICTION ENGINE ============
void calculatePredictions() {
  Serial.println("[PREDICTION] Forecasting future state...");

// Simple linear extrapolation: predicted = current + (trend * horizon)
  digitalTwin.predictedTemp = digitalTwin.temperature +
                              (digitalTwin.tempTrend * PREDICTION_HORIZON);

Serial.print("[PREDICTION] In ");
  Serial.print(PREDICTION_HORIZON);
  Serial.print(" cycles, predicted temp: ");
  Serial.print(digitalTwin.predictedTemp, 1);
  Serial.println("C");

// Predictive alert: warn if prediction crosses threshold
  if (digitalTwin.predictedTemp > digitalTwin.tempAlertHigh &&
      digitalTwin.temperature <= digitalTwin.tempAlertHigh) {
    Serial.println("[PREDICTION] ALERT: Temperature predicted to exceed high threshold!");
  }
  if (digitalTwin.predictedTemp < digitalTwin.tempAlertLow &&
      digitalTwin.temperature >= digitalTwin.tempAlertLow) {
    Serial.println("[PREDICTION] ALERT: Temperature predicted to drop below low threshold!");
  }
}

// ============ TWIN COMMAND EXECUTION ============
void executeTwinCommands() {
  // This demonstrates Digital -> Physical command flow
  // The twin can decide to turn LED on/off based on conditions

// Example rule: Turn LED on if temperature exceeds high threshold
  bool shouldLedBeOn = digitalTwin.temperature > digitalTwin.tempAlertHigh;

// Alternative: LED follows button toggle state (already handled)
  // Here we show how twin-side logic could override physical state

if (shouldLedBeOn && !digitalTwin.ledState) {
    Serial.println("[COMMAND] Twin activating LED due to high temperature");
    digitalWrite(LED_PIN, HIGH);
    digitalTwin.ledState = true;
  }
}

void toggleLedFromTwin() {
  // Twin-mediated LED toggle (button press -> twin logic -> LED control)
  bool newState = !digitalTwin.ledState;
  digitalWrite(LED_PIN, newState ? HIGH : LOW);
  digitalTwin.ledState = newState;

Serial.print("[COMMAND] Twin toggled LED to: ");
  Serial.println(newState ? "ON" : "OFF");
}

// ============ STATUS DISPLAY ============
void displayTwinStatus() {
  Serial.println("\n-------- DIGITAL TWIN STATUS --------");
  Serial.println("Physical Device State:");
  Serial.print("  Temperature: ");
  Serial.print(physicalDevice.temperature, 1);
  Serial.println(" C");
  Serial.print("  Humidity:    ");
  Serial.print(physicalDevice.humidity, 1);
  Serial.println(" %");
  Serial.print("  LED State:   ");
  Serial.println(physicalDevice.ledState ? "ON" : "OFF");

Serial.println("\nDigital Twin Mirror:");
  Serial.print("  Temperature: ");
  Serial.print(digitalTwin.temperature, 1);
  Serial.println(" C (synced)");
  Serial.print("  Humidity:    ");
  Serial.print(digitalTwin.humidity, 1);
  Serial.println(" % (synced)");
  Serial.print("  LED State:   ");
  Serial.println(digitalTwin.ledState ? "ON" : "OFF");

Serial.println("\nTwin Analytics:");
  Serial.print("  Avg Temp (");
  Serial.print(historyCount);
  Serial.print(" samples): ");
  Serial.print(digitalTwin.avgTemperature, 1);
  Serial.println(" C");
  Serial.print("  Temp Trend:  ");
  Serial.print(digitalTwin.tempTrend >= 0 ? "+" : "");
  Serial.print(digitalTwin.tempTrend, 2);
  Serial.println(" C/cycle");
  Serial.print("  Predicted:   ");
  Serial.print(digitalTwin.predictedTemp, 1);
  Serial.print(" C (in ");
  Serial.print(PREDICTION_HORIZON);
  Serial.println(" cycles)");

Serial.println("\nTwin Metadata:");
  Serial.print("  Sync Count:  ");
  Serial.println(digitalTwin.syncCount);
  Serial.print("  Sync Latency: ");
  Serial.print(digitalTwin.syncLatencyMs);
  Serial.println(" ms");
  Serial.print("  Status:      ");
  Serial.println(digitalTwin.healthStatus);

Serial.println("--------------------------------------\n");
}

Use the launch button above to open the ESP32 editor in Wokwi.
Select the editor’s diagram.json tab and replace all its text with the supplied diagram.json.
Select the sketch.ino tab, replace all its text with the supplied sketch.ino, then click Start Simulation.

Steps

Screens captured against Wokwi ESP32 Compiled and booted by the Wokwi gate (ESP32 Arduino core 3.3.11); captured in the Wokwi web editor on 2026-09-09 on 2026-09-09; the tool may have moved on — the text steps are the contract.

Step 1
Do
Paste diagram.json and sketch.ino into Wokwi ESP32 and install DHT sensor library using Library Manager. Inspect the circuit.
You will see
Power: DHT22 VCC connects to ESP32 3.3 V; GND returns to ground (diagram.json lines 75, 81). DHT22 data connects to ESP32 GPIO4 (diagram.json line 87). LED anode connects to ESP32 GPIO2; its cathode returns through ledR to ground (diagram.json lines 93, 99, 105). The LED’s series resistor ledR is 220 Ω (diagram.json line 34). Sync button joins ESP32 GPIO15 to 3.3 V when pressed (diagram.json lines 111, 117). A 10 kΩ syncR resistor pulls the sync input to ground (diagram.json lines 53, 123, 129).
Why it matters
GPIO4 supplies the physical temperature and humidity readings, while GPIO2 exposes the LED state. The GPIO15 button and its 10 kΩ pull-down provide a definite sync input for later mirror updates.
Step 2
Do
In the Simulation toolbar, start the run and read the first Serial Monitor sync cycle.
You will see
Input: DHT22 at 24 C and 40% RH. Observed: "[PHYSICAL] Temp: 24.0C, Humidity: 40.0%, LED: OFF". Observed: "[TWIN] State synchronized successfully". Expected: the physical reading enters the twin mirror.
Why it matters
The first sensor values are 24.0 C and 40.0%. The physical LED is OFF. The synchronization line follows the physical read. This is a simulated mirror update.
Step 3
Do
In the Serial Monitor panel, compare Physical Device State and Digital Twin Mirror.
You will see
Input: keep the DHT22 at 24 C and 40% RH. Observed physical: "Temperature: 24.0 C" and "Humidity: 40.0 %". Observed mirror: "Temperature: 24.0 C (synced)" and "Humidity: 40.0 % (synced)". Expected: both views show the same sensor pair.
Why it matters
The physical temperature is 24.0 C. The mirror temperature is also 24.0 C. Both humidity values are 40.0%. The mirror marks both values as synced.
Step 4
Do
In the Serial Monitor panel, follow the stable DHT22 history until the buffer is full.
You will see
Input: hold DHT22 at 24 C and 40% RH. Observed: "[HISTORY] Recorded state 12 (buffer: 10/10 entries)". Observed: "[ANALYTICS] Avg Temp: 24.0C, Trend: +0.00C/cycle". Observed: "[PREDICTION] In 3 cycles, predicted temp: 24.0C".
Why it matters
The ten-entry history is full. The average stays at the input temperature. The computed trend is zero per cycle. The forecast stays at 24.0 C while input is stable.
Step 5
Do
In the DHT22 control panel, set temperature to 35 C; read the next Serial Monitor metadata.
You will see
Input: DHT22 temperature 35 C, humidity 40%. Observed: "[COMMAND] Twin activating LED due to high temperature". Observed: "Predicted: 46.0 C (in 3 cycles)" and "Sync Count: 14". Observed: "Sync Latency: 41.00 ms" and "Status: WARNING: High Temp".
Why it matters
The high temperature crossed the model alert threshold. The twin commanded the LED ON. The prediction reflects the sudden rising trend. The warning and sync metadata match the real capture.
Step 6
Do
In the DHT22 control panel, restore 24 C and wait for ten new stable history samples.
You will see
Input: DHT22 restored to 24 C and 40% RH. Observed: "Predicted: 24.0 C (in 3 cycles)" and "Sync Count: 26". Observed: "Sync Latency: 30.00 ms" and "Status: NORMAL". Observed: "LED State: ON" remains after the warning clears.
Why it matters
The average and forecast return to baseline. The warning state clears to NORMAL. The LED remains ON in the mirror and physical state. The output shows no automatic deactivate command.
Step 7
Do
In Wokwi's sketch editor, inspect executeTwinCommands and compare its activation condition with the displayed LED state.
You will see
The condition is temperature > tempAlertHigh, with tempAlertHigh set to 30.0; there is no matching digitalWrite LOW in that function.
Why it matters
Observed state and commanded state have different owners. The host’s conflict rules require an explicit policy for a command that remains effective after its trigger ends.
Step 8
Do
In the Simulation toolbar, stop and start again at 24 C and 40% RH; read the first Serial Monitor metadata.
You will see
Input: fresh browser simulation at 24 C and 40% RH. Observed: "[PHYSICAL] Temp: 24.0C, Humidity: 40.0%, LED: OFF". Observed: "Sync Count: 1" and "Sync Latency: 30.00 ms". Observed: "Status: NORMAL" on the first mirror cycle.
Why it matters
The new run resets the cycle counter. The LED starts OFF. The sensor pair is back at baseline. The first mirror status is NORMAL.

Chapter checks

These questions refer to the chapter’s examples. Use the return links to review their answers.

A team wants every sensor to stream to the digital twin once per second because faster sounds more accurate. What is the better design rule?
Return to the chapter’s knowledge check
A pump twin shows outlet pressure as normal, but that value was last observed 38 minutes ago. The twin is used to recommend whether an operator should restart the pump after a trip. What should the system do?
Return to the chapter’s knowledge check

Return to Digital Twin Sync and Modeling · Browse Labs

Wokwi ESP32

Get the files

diagram.json

sketch.ino

Steps

1 Step 1

2 Step 2

3 Step 3

4 Step 4

5 Step 5

6 Step 6

7 Step 7

8 Step 8

Chapter checks

Step 1

Step 2

Step 3

Step 4

Step 5

Step 6

Step 7

Step 8