Peixing You Hackaday · GitHub
EWNA 2026 · Industrial Automation · First Prize

CRATE

Chironomy Recognition As a Touchless Experience

A worker with both hands on a box still has to confirm, skip, or cancel the station. CRATE reads the hand in the camera and answers on the board itself: an icon on the LED matrix and a sound from the buzzer, with no cloud and no touchscreen.

What it does

embedded world North America, Anaheim, September 22–24, 2026. Team 3, Industrial Automation.

The prompt was a warehouse station. The worker walks up holding a box and cannot reach a screen. The device has to notice a hand, decide which of three commands it is, and respond in a few hundred milliseconds. It also had to catch as many gestures as it could inside a 30-second window.

Logitech C920→ YOLOv5 on Arduino Uno Q→ gesture tracker→ LED matrix + buzzer + pixels
GestureLabelCommandWhat the board does
Open palmfivePause / cancelPause bars on the matrix. Music pauses.
Pointing swipeskipSkipFast-forward icon. Pixel strip flushes and the next tune starts.
Thumbs-upgoodConfirmThumbs-up icon. A short confirmation tune plays.

The tunes are the stand-in for the station. Confirm, cancel, and skip are real commands; the melody and the lights are how the worker knows the command landed without looking at a display. Lower the hand and the matrix clears after one second. The last command stays in effect.

Built in two days with Chaaruhaas Kandregula, Howie Zhang, and Terek J. I deployed the detector onto the Uno Q through App Lab, wrote the gesture-to-response path with Terek, and ran the failure-driven data loop once the pipeline was up.

Technologies

What actually ran on the board for the demo.

PieceRole
Arduino Uno QLinux MPU runs the camera and the model. The microcontroller drives the matrix, buzzer, and pixels.
YOLOv5 via Edge Impulse320×320 RGB detector, three classes. Deployed as a Linux aarch64 .eim (impulse v17) through the App Lab video-object-detection brick.
Logitech C920640×480 at 10 fps into the brick. The model then sees a 320×320 crop.
Python on the MPUPicks the strongest known box above 0.5 confidence, holds the active gesture, and clears it after 1 s with no hand.
Arduino sketch on the MCUDraws the 8×13 icon, plays the tune on the Modulino buzzer, and streams note color down eight Qwiic pixels.
RouterBridgematrix_draw is a notify. music is a call, so the measured latency includes the MCU acknowledging the command.

Why these

Each choice is a constraint from the challenge, not a default stack.

Detection, not a single label

YOLOv5, one box per hand

A classifier would score the whole frame. The hand is not centered, and a hard case we cared about puts two hands in one image doing different things. A detector localizes each hand and labels it on its own. The published examples show two skip boxes in a single frame, at 0.88 and 0.86.

Poses instead of a video model

Still frames of the swipe, not a temporal network

Skip is a motion. A video model would have needed a longer window and more of the latency budget, and we had two days. A swipe is a sequence of pointing poses. If those poses are in the dataset, a per-frame detector can fire on the gesture without waiting for a clip. That is also why a sideways thumb works as a backup skip when a full swipe is awkward while holding weight.

Edge Impulse, because the example model was the wrong gestures

Train on the floor, export .eim, load it in App Lab

Qualcomm’s Uno Q example showed how to get a detector onto this board. Its weights did not include palm, swipe, or thumbs-up. We kept the deployment path and replaced the model. Edge Impulse was the route that turned a labeled set into the aarch64 impulse the video brick already knew how to run.

Split the board on purpose

Python for vision, the sketch for actuators

The Uno Q is a Linux computer attached to a microcontroller. The camera and YOLO belong on Linux. The matrix, buzzer, and pixels belong on the MCU, where the music state machine can run without waiting on Python for every note. Calling across the bridge, instead of only notifying, makes the latency number include the moment the command is actually accepted.

Light and sound, not a screen

Onboard matrix, Modulino buzzer, Modulino pixels

The worker’s hands are full, and the point of the device is that they do not look down at a panel. The matrix is the command echo (thumbs-up, pause bars, fast-forward). The buzzer is the same echo in sound. The pixel strip is a running display of the note, so skip is visible as the lights flushing to the next tune.

Failures picked the next photos

About a 30-minute loop: train, deploy, find the miss, shoot that miss, retrain

Adding random hands did not fix the confusions we could already name. Swipe and thumbs-up collided, so we photographed both in the same frame and the mix-up dropped. Open palm was next: missed entirely, or called swipe, or called thumbs-up. The following batches were palms at new angles, distances, people, and backgrounds. Eleven-plus retrains, not one big collect-and-train.

A hotspot, because the hall Wi-Fi would not

SSH from the laptop to the Uno Q

We did not have the USB hub the bring-up assumed, and the venue network blocked device-to-device traffic. Terek’s phone hotspot put the laptop and the board on one network so we could deploy and read logs without the hub. That is what kept the 30-minute loop possible on the show floor.

Results

Numbers from the Edge Impulse run and the final hardware log. The architecture figure is the 341-image snapshot; later collection pushed the set past 450.

0.94mAP@50 on the detector
175 msaverage on-device inference
0.50 → 0.94mAP@50 across 11+ retrains
< 200 msunder the latency cap
Edge Impulse object-detection metrics: mAP@50 0.94, mAP 0.58, mAP@75 0.67, precision 93.1%, accuracy 97%.
mAP 0.58, mAP@50 0.94, mAP@75 0.67. Legacy precision 93.1%, accuracy 97%. Recall at 10 and 100 detections is 0.64. Small boxes are the weak spot (mAP 0.45); large boxes are 0.68.
Dataset of 341 images in three classes and YOLOv5 detections: open palm 0.93, two skip hands at 0.88 and 0.86, thumbs-up 0.91.
Published split: 341 images, 79% train (269) and 21% test (72). five 75, skip 130, good 136. Example scores: palm 0.93, two skips 0.88 and 0.86, thumbs-up 0.91. The final write-up counts 450+ images after the later, targeted batches.

On the hardware, inference stayed under 200 ms and averaged about 175 ms, which is the number the challenge asked for. In our swipe tests, about one frame in ten was a miss. A sideways thumb still registered as skip when a full swipe was hard to make. The closed loop on the floor was camera, YOLOv5, matrix icon, and buzzer together, not a model score on a laptop.

The same system took first prize in the Industrial Automation track of the EWNA 2026 Edge AI Hackathon.

Conclusions

  1. A short, stereotyped motion does not need a video model if the dataset contains the poses inside that motion. Sampling the swipe as stills is what left room for a 175 ms detector instead of a clip model.
  2. The score moved when the next batch was a specific confusion. Swipe versus thumbs-up improved after both gestures were in the same photo. Volume without a named failure would not have done that in eleven loops.
  3. The head has to be a detector. Two hands in one frame, off-center, is a normal case here, and a single frame-level label cannot say which hand issued the command.
  4. Latency that matters is inference plus the MCU accepting the command. Notifying the matrix and calling the music routine makes that path measurable, and it is the path the worker actually feels.
  5. Three commands, each with an icon and a sound, are enough for this station. The model does not need to understand the warehouse. It needs to not confuse cancel with confirm, and to say so before the worker has shifted the box.