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

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

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
DHT22 data is on GPIO 4, the red LED uses GPIO 2 through 220 Ω, and the GPIO 15 button has a 10 kΩ pull-down.
Why it matters
The host distinguishes telemetry, properties, and commands. These connections define which physical input and output the local model represents.
Step 2
Do
Start the simulation at 115200 baud and wait for the first periodic synchronization.
You will see
[PHYSICAL] Temp: 24.0C, Humidity: 40.0%, LED: OFF is followed by [TWIN] State synchronized successfully.
Why it matters
The SYNC_INTERVAL is 2000 ms. The host chooses cadence from decision needs rather than assuming the fastest possible update is always best.
Step 3
Do
Compare Physical Device State with Digital Twin Mirror in the status output.
You will see
Both temperatures read 24.0 C and both humidity values read 40.0%; the mirror marks its sensor values as synced.
Why it matters
A mirror should identify which observed values it represents. Here both objects live on one ESP32, so agreement does not prove a remote service is current.
Step 4
Do
Keep the DHT22 at 24 °C and 40% RH for at least ten periodic cycles.
You will see
The history buffer reaches 10/10 entries; the stable trend is +0.00 C/cycle and the three-cycle prediction is 24.0 C.
Why it matters
A bounded history supports a simple prediction while limiting memory. This extrapolation is a teaching model, not a validated model of physical equipment.
Step 5
Do
Set the DHT22 temperature to 35 °C and wait for a valid updated sample.
You will see
The mirror reports 35.0 C, Status becomes WARNING: High Temp, and [COMMAND] Twin activating LED due to high temperature appears as the LED turns on.
Why it matters
This is a model-to-device command as well as device-to-model telemetry. The host requires the command’s physical result to be verified.
Step 6
Do
Set temperature back to 24 °C, leave humidity at 40%, and wait until ten new stable samples replace the history.
You will see
Temperature, average, and prediction return to 24.0 C and Status returns to NORMAL, but the LED remains ON.
Why it matters
The supplied policy only activates the LED on high temperature; it has no automatic clearing command. A current sensor value alone does not explain a latched actuator state.
Step 7
Do
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
Stop and restart with the sensor at 24 °C and 40% RH.
You will see
The LED starts OFF, history restarts at 1/10 entries, and the first periodic mirror again reports 24.0 C and 40.0%.
Why it matters
Reset clears this local model’s memory. The host’s production freshness and quality contract would also need to distinguish resets, failed samples, and stale observations.

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