Test a TinyML gesture acceptance gate

Compare baseline, int8-style, pruning, and noise behavior against a visible on-device acceptance gate.

Edge Eddie: I want you to keep the memory, latency, sensor-match, and confidence gates visible before approving a real-device trial., your practice guide

Edge Eddie: I want you to keep the memory, latency, sensor-match, and confidence gates visible before approving a real-device trial.
Predict the reading, then compare it with the measurement.

Wokwi ESP32

Third party Tool

Compare baseline, int8-style, pruning, and noise behavior against a visible on-device acceptance gate.

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

2,015 bytes · Circuit connections

Download

{
  "version": 1,
  "author": "IoTClass",
  "editor": "wokwi",
  "parts": [
    { "type": "wokwi-esp32-devkit-v1", "id": "esp", "top": 0, "left": 0, "attrs": {} },
    { "type": "wokwi-led", "id": "ledShake", "top": -88, "left": 235, "attrs": { "color": "red" } },
    { "type": "wokwi-led", "id": "ledTap", "top": -40, "left": 235, "attrs": { "color": "yellow" } },
    { "type": "wokwi-led", "id": "ledTilt", "top": 8, "left": 235, "attrs": { "color": "green" } },
    { "type": "wokwi-led", "id": "ledCircle", "top": 56, "left": 235, "attrs": { "color": "blue" } },
    { "type": "wokwi-resistor", "id": "r1", "top": -78, "left": 184, "attrs": { "value": "220" } },
    { "type": "wokwi-resistor", "id": "r2", "top": -30, "left": 184, "attrs": { "value": "220" } },
    { "type": "wokwi-resistor", "id": "r3", "top": 18, "left": 184, "attrs": { "value": "220" } },
    { "type": "wokwi-resistor", "id": "r4", "top": 66, "left": 184, "attrs": { "value": "220" } },
    { "type": "wokwi-pushbutton", "id": "btn", "top": 156, "left": 228, "attrs": { "color": "gray" } },
    { "type": "wokwi-potentiometer", "id": "pot", "top": 178, "left": -132, "attrs": {} }
  ],
  "connections": [
    [ "esp:TX0", "$serialMonitor:RX", "", [] ],
    [ "esp:RX0", "$serialMonitor:TX", "", [] ],
    [ "esp:12", "r1:1", "green", [] ],
    [ "r1:2", "ledShake:A", "green", [] ],
    [ "ledShake:C", "esp:GND.1", "black", [] ],
    [ "esp:13", "r2:1", "green", [] ],
    [ "r2:2", "ledTap:A", "green", [] ],
    [ "ledTap:C", "esp:GND.1", "black", [] ],
    [ "esp:14", "r3:1", "green", [] ],
    [ "r3:2", "ledTilt:A", "green", [] ],
    [ "ledTilt:C", "esp:GND.1", "black", [] ],
    [ "esp:15", "r4:1", "green", [] ],
    [ "r4:2", "ledCircle:A", "green", [] ],
    [ "ledCircle:C", "esp:GND.1", "black", [] ],
    [ "esp:4", "btn:1.l", "blue", [] ],
    [ "btn:2.l", "esp:GND.1", "black", [] ],
    [ "esp:34", "pot:SIG", "blue", [] ],
    [ "esp:3V3", "pot:VCC", "red", [] ],
    [ "esp:GND.1", "pot:GND", "black", [] ]
  ]
}

sketch.ino

12,305 bytes · ESP32 program

Download

/*
 * TinyML Gesture Classification Lab
 * ---------------------------------
 * Educational ESP32 simulator:
 * - Four synthetic accelerometer gesture classes
 * - Dense network: 12 inputs -> 8 hidden ReLU units -> 4 outputs
 * - Float-style and int8-style weight storage comparison
 * - Simulated pruning and confidence threshold tests
 *
 * Controls:
 * - Button on GPIO 4 changes mode
 * - Potentiometer on GPIO 34 changes input noise
 * - LEDs on GPIO 12-15 show predicted class
 */

#include <Arduino.h>
#include <math.h>

#define INPUT_SIZE 12
#define HIDDEN_SIZE 8
#define CLASS_COUNT 4

#define PIN_LED_SHAKE 12
#define PIN_LED_TAP 13
#define PIN_LED_TILT 14
#define PIN_LED_CIRCLE 15
#define PIN_BUTTON 4
#define PIN_POT 34

const char *CLASS_NAMES[CLASS_COUNT] = {
  "SHAKE", "TAP", "TILT", "CIRCLE"
};

const int CLASS_LEDS[CLASS_COUNT] = {
  PIN_LED_SHAKE, PIN_LED_TAP, PIN_LED_TILT, PIN_LED_CIRCLE
};

const float PROFILES[CLASS_COUNT][INPUT_SIZE] = {
  { 0.8, 0.1, 0.0, -0.8, 0.1, 0.0, 0.7, -0.1, 0.0, -0.7, 0.0, 0.0 },
  { 0.0, 0.0, 0.2,  0.1, 0.0, 0.9, 0.0,  0.0, -0.2, 0.0, 0.0, 0.1 },
  { 0.1, 0.7, 0.2,  0.2, 0.6, 0.2, 0.4,  0.4,  0.2, 0.7, 0.1, 0.2 },
  { 0.0, 0.7, 0.0,  0.7, 0.0, 0.0, 0.0, -0.7,  0.0, -0.7, 0.0, 0.0 }
};

float w1[INPUT_SIZE][HIDDEN_SIZE];
float b1[HIDDEN_SIZE];
float w2[HIDDEN_SIZE][CLASS_COUNT];
float b2[CLASS_COUNT];

int8_t qw1[INPUT_SIZE][HIDDEN_SIZE];
int8_t qw2[HIDDEN_SIZE][CLASS_COUNT];
float scaleW1 = 1.0f;
float scaleW2 = 1.0f;

int mode = 0;
int demoClass = -1;
unsigned long lastRunMs = 0;
unsigned long lastButtonMs = 0;
float noiseLevel = 0.0f;
float forcedNoise = -1.0f;

float relu(float x) {
  return x > 0.0f ? x : 0.0f;
}

float randomUnit() {
  return random(-100, 101) / 100.0f;
}

void softmax(const float *logits, float *out) {
  float maxVal = logits[0];
  for (int i = 1; i < CLASS_COUNT; i++) {
    if (logits[i] > maxVal) {
      maxVal = logits[i];
    }
  }

float sum = 0.0f;
  for (int i = 0; i < CLASS_COUNT; i++) {
    out[i] = expf(logits[i] - maxVal);
    sum += out[i];
  }

for (int i = 0; i < CLASS_COUNT; i++) {
    out[i] = out[i] / sum;
  }
}

void buildModel() {
  randomSeed(42);

for (int h = 0; h < HIDDEN_SIZE; h++) {
    int classIndex = h % CLASS_COUNT;
    b1[h] = -0.05f;

for (int i = 0; i < INPUT_SIZE; i++) {
      float jitter = randomUnit() * 0.05f;
      w1[i][h] = (PROFILES[classIndex][i] * 0.55f) + jitter;
    }
  }

for (int h = 0; h < HIDDEN_SIZE; h++) {
    int sourceClass = h % CLASS_COUNT;
    for (int c = 0; c < CLASS_COUNT; c++) {
      w2[h][c] = (sourceClass == c) ? 0.85f : -0.20f;
    }
  }

for (int c = 0; c < CLASS_COUNT; c++) {
    b2[c] = 0.0f;
  }
}

int8_t quantizeValue(float value, float scale) {
  int q = (int)roundf(value / scale);
  if (q > 127) {
    q = 127;
  }
  if (q < -127) {
    q = -127;
  }
  return (int8_t)q;
}

void quantizeWeights() {
  float maxW1 = 0.0f;
  float maxW2 = 0.0f;

for (int i = 0; i < INPUT_SIZE; i++) {
    for (int h = 0; h < HIDDEN_SIZE; h++) {
      maxW1 = max(maxW1, fabsf(w1[i][h]));
    }
  }

for (int h = 0; h < HIDDEN_SIZE; h++) {
    for (int c = 0; c < CLASS_COUNT; c++) {
      maxW2 = max(maxW2, fabsf(w2[h][c]));
    }
  }

scaleW1 = maxW1 > 0.0f ? maxW1 / 127.0f : 1.0f;
  scaleW2 = maxW2 > 0.0f ? maxW2 / 127.0f : 1.0f;

for (int i = 0; i < INPUT_SIZE; i++) {
    for (int h = 0; h < HIDDEN_SIZE; h++) {
      qw1[i][h] = quantizeValue(w1[i][h], scaleW1);
    }
  }

for (int h = 0; h < HIDDEN_SIZE; h++) {
    for (int c = 0; c < CLASS_COUNT; c++) {
      qw2[h][c] = quantizeValue(w2[h][c], scaleW2);
    }
  }
}

bool keepWeight(int inputIndex, int hiddenIndex, int prunePercent) {
  if (prunePercent <= 0) {
    return true;
  }
  int bucket = (inputIndex * 37 + hiddenIndex * 17 + 11) % 100;
  return bucket >= prunePercent;
}

void forwardFloat(const float *input, float *out, int prunePercent) {
  float hidden[HIDDEN_SIZE];

for (int h = 0; h < HIDDEN_SIZE; h++) {
    float sum = b1[h];
    for (int i = 0; i < INPUT_SIZE; i++) {
      if (keepWeight(i, h, prunePercent)) {
        sum += input[i] * w1[i][h];
      }
    }
    hidden[h] = relu(sum);
  }

float logits[CLASS_COUNT];
  for (int c = 0; c < CLASS_COUNT; c++) {
    float sum = b2[c];
    for (int h = 0; h < HIDDEN_SIZE; h++) {
      sum += hidden[h] * w2[h][c];
    }
    logits[c] = sum;
  }

softmax(logits, out);
}

void forwardInt8Style(const float *input, float *out) {
  float hidden[HIDDEN_SIZE];

for (int h = 0; h < HIDDEN_SIZE; h++) {
    float sum = b1[h];
    for (int i = 0; i < INPUT_SIZE; i++) {
      float dequantized = ((float)qw1[i][h]) * scaleW1;
      sum += input[i] * dequantized;
    }
    hidden[h] = relu(sum);
  }

float logits[CLASS_COUNT];
  for (int c = 0; c < CLASS_COUNT; c++) {
    float sum = b2[c];
    for (int h = 0; h < HIDDEN_SIZE; h++) {
      float dequantized = ((float)qw2[h][c]) * scaleW2;
      sum += hidden[h] * dequantized;
    }
    logits[c] = sum;
  }

softmax(logits, out);
}

void makeInput(int classIndex, float *input) {
  for (int i = 0; i < INPUT_SIZE; i++) {
    float noisy = PROFILES[classIndex][i] + (randomUnit() * noiseLevel);
    input[i] = constrain(noisy, -1.0f, 1.0f);
  }
}

int argMax(const float *out) {
  int best = 0;
  for (int i = 1; i < CLASS_COUNT; i++) {
    if (out[i] > out[best]) {
      best = i;
    }
  }
  return best;
}

void clearLeds() {
  for (int i = 0; i < CLASS_COUNT; i++) {
    digitalWrite(CLASS_LEDS[i], LOW);
  }
}

void showLed(int classIndex, bool accepted) {
  clearLeds();
  digitalWrite(CLASS_LEDS[classIndex], HIGH);

if (!accepted) {
    delay(100);
    digitalWrite(CLASS_LEDS[classIndex], LOW);
    delay(100);
    digitalWrite(CLASS_LEDS[classIndex], HIGH);
  }
}

void printScores(const float *out) {
  for (int i = 0; i < CLASS_COUNT; i++) {
    Serial.print(CLASS_NAMES[i]);
    Serial.print("=");
    Serial.print(out[i] * 100.0f, 1);
    Serial.print("% ");
  }
  Serial.println();
}

int floatWeightBytes() {
  int weights = (INPUT_SIZE * HIDDEN_SIZE) + (HIDDEN_SIZE * CLASS_COUNT);
  int biases = HIDDEN_SIZE + CLASS_COUNT;
  return (weights + biases) * 4;
}

int int8WeightBytes() {
  int weights = (INPUT_SIZE * HIDDEN_SIZE) + (HIDDEN_SIZE * CLASS_COUNT);
  int biases = HIDDEN_SIZE + CLASS_COUNT;
  int scales = 2;
  return weights + (biases * 4) + (scales * 4);
}

void runRecognition() {
  demoClass = (demoClass + 1) % CLASS_COUNT;

float input[INPUT_SIZE];
  float out[CLASS_COUNT];
  makeInput(demoClass, input);

unsigned long start = micros();
  forwardFloat(input, out, 0);
  unsigned long elapsed = micros() - start;

int predicted = argMax(out);
  float confidence = out[predicted];
  bool accepted = confidence >= 0.70f;

Serial.println();
  Serial.println("[MODE 0] Gesture recognition");
  Serial.print("Target: ");
  Serial.print(CLASS_NAMES[demoClass]);
  Serial.print(" | Noise: ");
  Serial.print(noiseLevel * 100.0f, 0);
  Serial.println("%");
  printScores(out);
  Serial.print("Prediction: ");
  Serial.print(CLASS_NAMES[predicted]);
  Serial.print(" | Confidence: ");
  Serial.print(confidence * 100.0f, 1);
  Serial.print("% | Latency: ");
  Serial.print(elapsed);
  Serial.println(" us");
  Serial.print("Accepted: ");
  Serial.println(accepted ? "yes" : "no");

showLed(predicted, accepted);
}

void runQuantizationCompare() {
  float input[INPUT_SIZE];
  float floatOut[CLASS_COUNT];
  float int8Out[CLASS_COUNT];
  makeInput(0, input);

unsigned long startFloat = micros();
  forwardFloat(input, floatOut, 0);
  unsigned long floatTime = micros() - startFloat;

unsigned long startInt8 = micros();
  forwardInt8Style(input, int8Out);
  unsigned long int8Time = micros() - startInt8;

int floatPred = argMax(floatOut);
  int int8Pred = argMax(int8Out);

Serial.println();
  Serial.println("[MODE 1] Float vs int8-style comparison");
  Serial.print("Float bytes: ");
  Serial.print(floatWeightBytes());
  Serial.print(" | Int8-style bytes: ");
  Serial.println(int8WeightBytes());
  Serial.print("Float: ");
  Serial.print(CLASS_NAMES[floatPred]);
  Serial.print(" | ");
  Serial.print(floatOut[floatPred] * 100.0f, 1);
  Serial.print("% | ");
  Serial.print(floatTime);
  Serial.println(" us");
  Serial.print("Int8-style: ");
  Serial.print(CLASS_NAMES[int8Pred]);
  Serial.print(" | ");
  Serial.print(int8Out[int8Pred] * 100.0f, 1);
  Serial.print("% | ");
  Serial.print(int8Time);
  Serial.println(" us");
  Serial.println("Gate: predictions should match before int8 deployment.");

showLed(int8Pred, floatPred == int8Pred);
}

void runPruningSweep() {
  float input[INPUT_SIZE];
  float out[CLASS_COUNT];
  int levels[4] = { 0, 30, 60, 85 };
  makeInput(1, input);

Serial.println();
  Serial.println("[MODE 2] Simulated pruning sweep");

for (int i = 0; i < 4; i++) {
    int prunePercent = levels[i];
    unsigned long start = micros();
    forwardFloat(input, out, prunePercent);
    unsigned long elapsed = micros() - start;

int predicted = argMax(out);
    Serial.print("Prune ");
    Serial.print(prunePercent);
    Serial.print("% -> ");
    Serial.print(CLASS_NAMES[predicted]);
    Serial.print(" ");
    Serial.print(out[predicted] * 100.0f, 1);
    Serial.print("% | ");
    Serial.print(elapsed);
    Serial.println(" us");
  }

Serial.println("Gate: heavy pruning fails if confidence or class changes.");
  showLed(argMax(out), out[argMax(out)] >= 0.70f);
}

void runThresholdTest() {
  int passes = 0;
  int trials = 12;
  float threshold = 0.70f;

Serial.println();
  Serial.println("[MODE 3] Threshold and noise test");
  Serial.print("Noise: ");
  Serial.print(noiseLevel * 100.0f, 0);
  Serial.print("% | Threshold: ");
  Serial.print(threshold * 100.0f, 0);
  Serial.println("%");

for (int t = 0; t < trials; t++) {
    int expected = t % CLASS_COUNT;
    float input[INPUT_SIZE];
    float out[CLASS_COUNT];
    makeInput(expected, input);
    forwardFloat(input, out, 0);

int predicted = argMax(out);
    bool ok = predicted == expected && out[predicted] >= threshold;
    if (ok) {
      passes++;
    }
  }

Serial.print("Passes: ");
  Serial.print(passes);
  Serial.print("/");
  Serial.println(trials);
  Serial.println("Gate: repeat at low, medium, and high noise settings.");
}

void handleButton() {
  static int lastState = HIGH;
  int state = digitalRead(PIN_BUTTON);

if (state == LOW && lastState == HIGH) {
    if (millis() - lastButtonMs > 300) {
      lastButtonMs = millis();
      mode = (mode + 1) % 4;
      Serial.println();
      Serial.print("Changed to mode ");
      Serial.println(mode);
      clearLeds();
    }
  }

lastState = state;
}

void handleSerialMode() {
  while (Serial.available()) {
    char command = Serial.read();
    if (command >= '0' && command <= '3') {
      mode = command - '0';
      Serial.println();
      Serial.print("Changed to mode ");
      Serial.println(mode);
      clearLeds();
    } else if (command == 'H' || command == 'h') {
      forcedNoise = 1.0f;
      Serial.println("Noise override: 100%");
    } else if (command == 'L' || command == 'l') {
      forcedNoise = -1.0f;
      Serial.println("Noise override: potentiometer");
    }
  }
}

void setup() {
  Serial.begin(115200);
  delay(500);

pinMode(PIN_LED_SHAKE, OUTPUT);
  pinMode(PIN_LED_TAP, OUTPUT);
  pinMode(PIN_LED_TILT, OUTPUT);
  pinMode(PIN_LED_CIRCLE, OUTPUT);
  pinMode(PIN_BUTTON, INPUT_PULLUP);
  pinMode(PIN_POT, INPUT);

buildModel();
  quantizeWeights();

Serial.println();
  Serial.println("TinyML Gesture Classification Lab");
  Serial.println("Button changes mode. Potentiometer changes noise.");
  Serial.println("Mode 0: recognition");
  Serial.println("Mode 1: float vs int8-style");
  Serial.println("Mode 2: pruning sweep");
  Serial.println("Mode 3: threshold test");
  Serial.println("Serial 0-3 also selects a mode.");
}

void loop() {
  handleButton();
  handleSerialMode();
  noiseLevel = forcedNoise >= 0.0f ? forcedNoise : analogRead(PIN_POT) / 4095.0f;

if (millis() - lastRunMs > 3000) {
    lastRunMs = millis();

if (mode == 0) {
      runRecognition();
    } else if (mode == 1) {
      runQuantizationCompare();
    } else if (mode == 2) {
      runPruningSweep();
    } else {
      runThresholdTest();
    }
  }

delay(10);
}

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 a new Wokwi ESP32 project, then inspect the four LED paths, mode button, and noise control.
You will see
Red, yellow, green, and blue LEDs use GPIO12 through GPIO15; the button uses GPIO4 and the potentiometer signal uses GPIO34.
Why it matters
The host chapter requires the complete input, inference, decision, and action path to fit the device.
Step 2
Do
Inspect the model constants, input profiles, and float and int8 weight arrays before starting.
You will see
The sketch declares 12 inputs, 8 hidden activations, 4 classes, and separate float and int8-style weight storage.
Why it matters
Making each budget visible prevents a model-file size from being mistaken for total runtime fit.
Step 3
Do
Start the simulation at the potentiometer's low-noise setting and wait for Mode 0.
You will see
Gesture recognition prints a target, prediction, confidence, latency in microseconds, and Accepted: yes or no.
Why it matters
A repeatable baseline connects sensor-window behavior to a measurable acceptance threshold.
Step 4
Do
Press the mode button once, or send 1 in Serial Monitor, and wait for Mode 1.
You will see
Float bytes and Int8-style bytes appear with both predictions, confidences, and measured latencies; the gate says predictions should match.
Why it matters
Quantization is useful only when the smaller representation still preserves the class decision on representative input.
Step 5
Do
Press the mode button again, or send 2 in Serial Monitor, and wait for Mode 2.
You will see
The pruning sweep reports 0%, 30%, 60%, and 85% pruning with a class, confidence, and latency for each level.
Why it matters
The host chapter warns that fitting memory is not enough when confidence or class behavior changes.
Step 6
Do
Press the mode button a third time, or send 3 in Serial Monitor, and wait for Mode 3 at low noise.
You will see
The threshold test reports Noise, a 70% threshold, Passes out of 12, and the instruction to repeat across noise settings.
Why it matters
A held acceptance gate turns a simulation result into evidence for or against a real-sensor trial.
Step 7
Do
Turn the potentiometer to its high end, or send H in Serial Monitor, and wait for the next Mode 3 result.
You will see
The reported noise rises above 70% and a new Passes out of 12 result appears at the same 70% threshold.
Why it matters
Changing only the noise control exposes distribution sensitivity without silently changing the decision rule.

Chapter checks

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

A team has a quantized model that fits in flash, but the tensor arena plus audio feature buffer leaves almost no SRAM for stack, logs, and firmware state. What should the team do before approving the TinyML deployment?
Return to the chapter’s knowledge check
A TinyML model has 80,000 INT8 weights. Where do the weights live, and what separately bounds SRAM use?
Return to the chapter’s knowledge check
A vibration anomaly model performs well in the notebook, but field firmware samples the accelerometer at a different rate and uses a different FFT window. What is the most likely problem?
Return to the chapter’s knowledge check

Return to TinyML on Microcontrollers · 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

Chapter checks

Step 1

Step 2

Step 3

Step 4

Step 5

Step 6

Step 7