Tinyml Model For Automated Electric Bicycle Hill Assist Engagement Based On Cadence Sensors

Nikodem Bartnik created a powerful robotic chassis using T-Motor AK series actuators and Arduino

Fabio Antonini loves to ride his bike, and while nearly all bike computers offer information such as cadence, distance, speed, and elevation, they lack the ability to tell if the cyclist is sitting or standing at any given time. So, after doing some research, he came across an example project that utilized Edge Impulse and an Arduino Nano 33 BLE 33 Sense’s onboard accelerometer to distinguish between various kinds of movements. Based on this previous work, he opted to create his own ML device using the same general framework.

Over the course of around 20 minutes, Fabio collected data for both standing and sitting by strapping a Nano 33 BLE Sense to his arm and connecting it to a laptop. Once the data had been processed and fed through a training algorithm, his freshly minted model was then deployed back to the board for real-time processing.

The program Antonini made classifies incoming data from the IMU into one of four different states: seated on a plain, seated on an uphill, jumping on the pedals during an uphill, or pushing on a sprint while on a plain. From here, the built-in RGB LED changes its color to notify the user of what was inferred.

You can read more about the creation process and usage of this project here in Antonini’s Medium blog post .

Source code and examples for using and testing your Tiny Machine Learning Kit and Shield.

TinyML is one of the most consequential shifts in applied artificial intelligence right now — and you don’t need a data center or a GPU cluster to participate. A TinyML project runs a trained machine learning model directly on a microcontroller the size of your thumb, consuming milliwatts of power, with no cloud dependency. This hands-on tutorial walks you through building a Smart Motion Detection System from scratch using an Arduino Nano 33 BLE Sense, TensorFlow Lite, and a free Python environment. By the end, you’ll have a working edge AI device and a foundational understanding of how intelligence is moving out of the cloud and into the physical world.

TinyML sits at the intersection of embedded systems and machine learning. Instead of sending sensor data to a remote server for inference, the model lives on the device itself — running predictions locally in real time. This architecture delivers three core advantages:

These properties explain why TinyML is already embedded in fitness trackers, industrial vibration monitors, smart-home motion sensors, and precision-agriculture nodes. Understanding this paradigm gives you a practical edge whether you’re building IoT products, pursuing a career in embedded AI, or simply want to understand where machine learning is heading.

This TinyML project produces a Motion Detection Device capable of classifying three movement states in real time, entirely on-device:

The workflow mirrors what production TinyML systems do: collect sensor data, train a lightweight classification model, compress it for constrained hardware, deploy it, and run live inference. The same four-stage pipeline powers everything from wearable health monitors to smart-security intrusion detectors.

This is the recommended starter board for TinyML beginners. It ships with an onboard 9-axis IMU (accelerometer, gyroscope, magnetometer), a microphone, a temperature/humidity/pressure sensor, and a Bluetooth LE radio — all on a board smaller than a USB stick. Crucially, it carries an ARM Cortex-M4 processor with enough flash memory to hold a compressed TensorFlow Lite model. You can find full specifications on the official Arduino website .

The free desktop IDE for writing, compiling, and uploading sketches. Download it from the Arduino IDE official download page .

You will train and convert the model using Python inside Google Colab , which requires no local GPU or installation. A standard Google account is all you need.

Before touching any code, internalize this pipeline. Every TinyML project — from beginner hobby boards to commercial wearables — follows the same four stages:

This is the same framework used when deploying machine learning models in Android apps , except the target runtime is a bare-metal microcontroller rather than a mobile OS. The constraints are far tighter: typical TinyML models must fit within 256 KB of flash and use under 100 KB of RAM.

Inside the Arduino IDE, navigate to Tools → Manage Libraries and install the following two libraries:

These two libraries are the foundation of almost every Arduino-based TinyML project. Good data preparation starts at the sensor driver level — the LSM9DS1 library handles raw register reads so your sketch receives calibrated floating-point acceleration values.

Create a new Arduino sketch and paste the following code. This sketch streams accelerometer readings over the serial port at 10 Hz, which you will capture as your training dataset.

Upload the sketch, then open Tools → Serial Monitor (baud rate 9600). You will see comma-separated X, Y, Z values scrolling in real time. Now perform each of your target motion classes — stationary, walking, and shaking — for approximately 60 seconds each, copying the serial output into separate CSV files labeled by class. This labeled dataset is what you will feed into the training notebook.

Because the dataset is small, you may also benefit from lightweight automated approaches. Techniques explored in hyperparameter optimization for machine learning can help you tune learning rate and batch size without exhaustive manual search.

Once training is complete, convert the Keras model to TensorFlow Lite format and apply post-training quantization. Quantization maps 32-bit floating-point weights to 8-bit integers, shrinking model size by roughly 75% with minimal accuracy loss — a non-negotiable step for microcontroller deployment.

The output motion_model.h file is a C header containing your model as a byte array. This is how TensorFlow Lite for Microcontrollers loads models from flash memory — there is no file system on a microcontroller.

Copy motion_model.h into your Arduino sketch folder. Write a new Arduino sketch that:

Once uploaded, the board classifies motion in real time, entirely locally, with no Wi-Fi or cloud required. That is edge AI in its purest form.

If you want to explore model quality improvement before deployment, reducing overfitting with adversarial validation is a practical technique applicable even to small embedded datasets.

The motion detection pipeline you just built is a simplified version of the same architecture used in:

Basic Python familiarity is helpful, and an introductory understanding of what a neural network does will make the training steps easier to follow. However, the workflow is designed to be beginner-accessible — you do not need to derive backpropagation or understand advanced optimisation theory.

Yes. The ESP32, Raspberry Pi Pico, and STM32 series all support TensorFlow Lite for Microcontrollers. The Arduino Nano 33 BLE Sense is recommended here because its bundled sensor suite eliminates extra wiring for beginners. On other boards you may need to source and wire external IMU modules.

For the Arduino Nano 33 BLE Sense, aim for a quantized model under 200 KB. In practice, a two-hidden-layer dense network for three-class motion classification typically compresses to well under 50 KB after integer quantization, leaving ample room for the TFLite interpreter overhead.

No. Any environment with TensorFlow 2.x and Python 3 works — local Jupyter notebooks, Kaggle Kernels, or cloud notebooks from other providers. Colab is recommended because it is free, requires no setup, and is well-documented in the TinyML community.

Collect more data, ensure your class labels are consistent, check your feature window size, and experiment with slightly larger model architectures. Avoid increasing model size beyond memory constraints. Techniques like learning-rate scheduling and dropout regularisation can also improve generalisation on small datasets.

© Blockgeni.com 2026 All Rights Reserved, A Part of SKILL BLOCK Group of Companies

Figure 1: Running neural networks on Arduino microcontrollers — machine learning at the edge

Here's a fact that genuinely reframes what "small" means in machine learning: Google's wake-word detector — the model listening for "Hey Google" — is roughly 14 kilobytes. Not 14 megabytes. Fourteen kilobytes, small enough to run on a chip that costs less than a sandwich. Ever wondered how your phone hears a wake word without streaming raw audio to a server constantly? This is exactly the field responsible.

Building on the edge AI overview and hardware guide from earlier in this series, this is the actual hands-on project — training a genuinely tiny neural network, converting it, and getting it running on real Arduino hardware. No cloud, no GPU, just a microcontroller doing inference on its own.

By the end of this tutorial, you'll have trained a small model in Python, converted it to run on-device, and deployed it to an Arduino, watching a physical output respond to a neural network's prediction in real time. IMO, there's something genuinely delightful about a "hello world" project that ends with a blinking LED controlled by machine learning rather than a print statement :)

Every TinyML tutorial converges on essentially the same starting project, and for good reason: train a tiny neural network to approximate the sine function, then use its output to control something physical — typically an LED's brightness, pulsing smoothly like a heartbeat.