Deploy an Edge Impulse Motion Classifier with Atym Ocre Cont

Atym extends WebAssembly (Wasm) beyond the browser to secure, resource-constrained edge devices. In this project, we combine Atym with Edge Impulse's motion classifier to create a closed-loop inference system: raw sensor data is published, classified, and the prediction is validated -- all on device.

The system runs on both Linux and Zephyr targets and is organized as three independent containers that communicate via Atym Ocre's internal messaging bus:

• Classifier Container -- Receives raw sensor samples, runs the Edge Impulse motion classifier, and publishes predictions.
• Data Container -- Publishes labeled test samples from the dataset, collects prediction results, and reports overall accuracy.
• Assets Container -- Embeds the test dataset CBOR files and extracts them to the filesystem at runtime.

The data publisher validates predictions in a closed loop, so you can measure accuracy without any external tooling.

• Atym Documentation
• Edge Impulse C Library Documentation
• Edge Impulse Standalone Inferencing Example
• Atym Samples: EI Motion Classifier (GitHub)

Before you can build and deploy containers, you need an Atym account. Head to the Atym Eval Program signup page and fill out the form with your name, email, phone number, industry, and role. Once submitted, Atym will provision your account and send you login credentials via email.

Atym provides a preconfigured Dev Container with the full toolchain for building WebAssembly containers. This is the recommended approach.

Prerequisites:

• Docker installed and running
• Visual Studio Code with the Dev Containers extension

Clone the Atym getting-started repository:

Open the directory in VS Code:

Run Dev Containers: Open Folder in Container... from the Command Palette (Cmd+Shift+P on Mac, Ctrl+Shift+P on Windows/Linux). Select the folder and wait for the container to build. This may take a few minutes the first time.

Once inside the Dev Container, verify the toolchain:

You should see output like:

Then associate the CLI with your Atym account:

You need the Atym Ocre runtime installed on a Linux device (like a Raspberry Pi 4) and registered with your account.

Register the device from your development machine:

Save the deviceUUID, pskSecret, and tenantUUID from the output -- you'll need them to configure the runtime.

Install the Atym runtime on your Pi. SSH in and download the latest runtime. Check the Atym Quickstart Guide for the most current download link:

Configure and start the runtime with your device credentials:

You should see Client connected successfully when the device connects.

At this point you should have:

• A Linux device (e.g., Raspberry Pi 4) with the Atym Ocre runtime installed and connected
• The Atym CLI set up on your development machine (via Dev Container or direct install)
• Git and CMake available for building (included in the Dev Container)
• Optionally, a Zephyr board (e.g., Nordic nRF52840) if you want to test on an MCU target
• Optionally, an Edge Impulse account if you want to train and export your own motion classifier

On your development machine (or inside the Dev Container), clone the example repo:

The repo includes an Edge Impulse motion classifier model and test dataset in the edge-impulse-sdk and data/testing/ directories, so you can build and deploy immediately without needing an Edge Impulse account.

If you want to use the included model, skip ahead to the build step. To use your own model instead:

1. Train a motion classification project on Edge Impulse.
2. Export the trained impulse as a C++ Library (not C++ Standalone).
3. Extract the exported library into this repository, replacing the existing edge-impulse-sdk folder.
4. Download the test dataset CBOR files from your Edge Impulse project's Data Acquisition section.
5. Place all .cbor files in the data/testing/ directory.

Edge Impulse generates model_metadata.h and model_variables.h in the model-parameters/ directory when you export. These define the raw sample count, input frame size, and labels -- they generally don't require editing.

Before building, make sure you're logged in to your Atym registry:

Then build and push all three containers:

This will:

1. Build the assets, data, and classifier containers.
2. Automatically push them to your Atym registry as ei-assets, ei-data, and ei-classifier.
3. Generate C headers for any CBOR files in data/testing/ and embed them into the assets container at build time.

The containers must be deployed in a specific order:

1. Assets container -- Extracts the test dataset to /testing on the device filesystem.
2. Data container -- Publishes sample windows and collects validation results.
3. Classifier container -- Subscribes to sample messages and publishes predictions.

Deploy the assets container first because the data container depends on the extracted dataset, and the classifier must be listening before data is published. On Zephyr targets, this order is especially important to populate the filesystem before launching the other containers.

Deploy the assets container:

After the dataset is extracted, deploy the inference and data containers (this will automatically deploy in the correct order):

With all three containers running, you should see output similar to the following.

Data container output:

Classifier container output:

The data publisher streams sample windows from the test dataset, the classifier responds with predicted labels, and the publisher reports overall accuracy.

The three containers communicate via Atym Ocre's messaging bus:

The assets container extracts dataset files to the /testing directory. The data container reads samples from this directory and publishes them on the ei/sample/raw topic. The classifier container subscribes to this topic, runs inference, and publishes predictions on the ei/result topic. The data container subscribes to ei/result to compare expected and predicted labels.

You can reuse this infrastructure for your own motion classification model.

1. Train your motion classification model on Edge Impulse.
2. Go to Deployment > C++ Library and select the model version to export.
3. Download the exported ZIP file and extract it to this directory, replacing the existing edge-impulse-sdk/ folder.

The model-parameters/ directory contains model_metadata.h and model_variables.h, which define EI_CLASSIFIER_RAW_SAMPLE_COUNT, EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE, and the label count. These are automatically generated and should not need manual editing.

1. In Edge Impulse, go to Data Acquisition > Testing and download your test samples as CBOR files.
2. Place all .cbor files in the data/testing/ directory.

During the build, the gen_embedded_assets.py script will detect these files and embed them into the assets container automatically.

Run the build script and deployment commands as described in Steps 7 and 8. The CMake build system will automatically discover CBOR files in data/testing/, generate C headers to embed them via gen_embedded_assets.py, and link everything into the final containers.

This example has been tested on both Linux and Zephyr RTOS. If you're porting your own model to a WebAssembly/Zephyr environment, here's what to watch out for.

When exporting from Edge Impulse for Wasm targets, enable "Use xxd instead of INCBIN to link TFLite/ONNX files". Wasm doesn't support INCBIN's binary embedding method. This setting is found in Edge Impulse's Dashboard under Experiments.

The following flags are critical for Wasm compatibility:

These are already configured in the included CMakeLists.txt.

• Clock: WASI only supports CLOCK_MONOTONIC for timing. If you use your own model, the included patch in ei_classifier_porting.cpp will need to be manually added.
• Linking: The Edge Impulse SDK is statically linked (not as a shared library) for portability.
• Memory: Wasm modules run in isolated memory -- no cross-container memory sharing occurs.

By combining Atym Ocre with Edge Impulse's motion classifier, you can build a portable, closed-loop inference system that runs on both Linux and Zephyr devices. Because Atym uses WebAssembly, the same application can be built once and run across multiple hardware architectures with minimal changes, enabling efficient experimentation at the edge.

• Sign up for the Atym Eval Program
• Atym Discord
• More Atym projects on Hackster