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

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
Shake and tap LED paths start at ESP32 GPIO12 and GPIO13 through r1 and r2 (diagram.json lines 21, 24). Tilt and circle LED paths start at ESP32 GPIO14 and GPIO15 through r3 and r4 (diagram.json lines 27, 30). Each of the four LED cathodes returns to ESP32 ground (diagram.json lines 23, 26, 29, 32). Button connects ESP32 GPIO4 to ground when pressed (diagram.json lines 33–34). Potentiometer signal connects to ESP32 GPIO34 (diagram.json line 35). Potentiometer power connects to ESP32 3.3 V and ground (diagram.json lines 36–37).
Why it matters
The four resistor-protected LEDs identify later gesture classes. GPIO4 changes mode and GPIO34 reads the noise control, so prediction changes can be traced to separate inputs.
Step 2
Do
In Wokwi's sketch editor, inspect the model constants, input profiles, and float and int8 weight arrays before starting.
You will see
Set input width: #define INPUT_SIZE 12 (sketch.ino line 19). Set hidden-layer width: #define HIDDEN_SIZE 8 (sketch.ino line 20). Set class count: #define CLASS_COUNT 4 (sketch.ino line 21). Map shake LED to GPIO12: #define PIN_LED_SHAKE 12 (sketch.ino line 23). Map tap LED to GPIO13: #define PIN_LED_TAP 13 (sketch.ino line 24). Map tilt LED to GPIO14: #define PIN_LED_TILT 14 (sketch.ino line 25). Map circle LED to GPIO15: #define PIN_LED_CIRCLE 15 (sketch.ino line 26). Map button to GPIO4: #define PIN_BUTTON 4 (sketch.ino line 27). Map potentiometer to GPIO34: #define PIN_POT 34 (sketch.ino line 28). Allocate first-layer weights: float w1[INPUT_SIZE][HIDDEN_SIZE]; (sketch.ino line 45). Allocate output-layer weights: float w2[HIDDEN_SIZE][CLASS_COUNT]; (sketch.ino line 47). Allocate quantized first-layer weights: int8_t qw1[INPUT_SIZE][HIDDEN_SIZE]; (sketch.ino line 50).
Why it matters
The dimensions fix the 12-input, 8-hidden, 4-class model used later. The visible GPIO defines class LEDs and controls, and the float and int8 arrays make the two weight representations explicit.
Step 3
Do
On Wokwi's simulation toolbar, start the simulation with the supplied potentiometer setting and wait for Mode 0 in Serial Monitor.
You will see
Input: start Mode 0 with the potentiometer near its supplied setting. Observed: "Target: SHAKE | Noise: 52%". Observed: "Prediction: SHAKE | Confidence: 73.4% | Latency: 414 us". Observed: "Accepted: yes".
Why it matters
The target and prediction match in this run. Confidence exceeds the sketch's acceptance threshold. The latency is reported in microseconds. The observed 52% noise belongs to this run, not a fixed promise.
Step 4
Do
Press the mode button once, or send 1 in Serial Monitor, and wait for Mode 1.
You will see
Input: send 1 in the Wokwi Serial Monitor. Observed: "Float bytes: 560 | Int8-style bytes: 184". Observed: "Float: SHAKE | 68.4% | 414 us". Observed: "Int8-style: SHAKE | 68.4% | 208 us".
Why it matters
Both representations predicted SHAKE in the displayed comparison. The Int8-style fixture reports fewer bytes. Its displayed latency is 208 us versus 414 us for float. One matching run does not establish deployment accuracy.
Step 5
Do
Press the mode button again, or send 2 in Serial Monitor, and wait for Mode 2.
You will see
Input: send 2 in the Wokwi Serial Monitor. Observed: "Prune 0% -> TAP 46.7% | 412 us". Observed: "Prune 30% -> TAP 35.3% | 463 us" and "Prune 60% -> TAP 34.9% | 587 us". Observed: "Prune 85% -> TILT 25.8% | 428 us".
Why it matters
Confidence falls across the first three displayed levels. The class changes from TAP to TILT at 85%. Latency is not monotonic in this fixture. The displayed gate warns that heavy pruning can change class or confidence.
Step 6
Do
Send 3 in the Wokwi Serial Monitor and wait for Mode 3 at the current potentiometer setting.
You will see
Input: send 3 with the potentiometer at its current setting. Observed: "[MODE 3] Threshold and noise test". Observed: "Noise: 51% | Threshold: 70%". Observed: "Passes: 3/12".
Why it matters
The run reports the same 70% threshold for this mode. Three of twelve fixture windows pass at 51% noise. The setting and count are visible in the same monitor group. The gate requests repetition across other noise settings.
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
Input: send H in the Wokwi Serial Monitor. Observed: "Noise override: 100%". Observed: "Noise: 100% | Threshold: 70%". Observed: "Passes: 4/12".
Why it matters
The H command changed the noise input to 100%. The threshold remained 70%. This run reported four passes out of twelve. The count changed under noise while the decision rule stayed fixed.

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