Arduino Nano 33 BLE Sense: Machine Learning on a Tiny Board

The Arduino Nano 33 BLE Sense ML capabilities have redefined what is possible with embedded systems. This remarkable board packs a 64 MHz Cortex-M4F processor, nine onboard sensors, and Bluetooth 5.0 into a package barely larger than a matchbox — all while running TensorFlow Lite Micro models directly on the microcontroller. No cloud, no companion computer, no internet connection required. This comprehensive guide explores the hardware, the embedded machine learning workflow using Edge Impulse, and practical project examples that demonstrate why the Nano 33 BLE Sense has become the go-to board for TinyML development.

Table of Contents

• Hardware Overview: What Makes It Special?
• Understanding TinyML and Edge AI
• Setting Up the Development Environment
• Building a Model with Edge Impulse
• Project: Gesture Recognition
• Project: Wake Word / Keyword Spotting
• Project: Vibration Anomaly Detection
• Frequently Asked Questions

Hardware Overview: What Makes It Special?

The Arduino Nano 33 BLE Sense is built around the nRF52840 System-on-Chip from Nordic Semiconductor — a powerful Arm Cortex-M4F running at 64 MHz with 1 MB flash, 256 KB RAM, and a hardware floating-point unit (FPU). The FPU is critical for machine learning inference: it accelerates the matrix multiplication operations at the heart of neural network computation.

The onboard sensor suite is extraordinary for a board this size:

• LSM9DS1: 9-axis IMU — 3-axis accelerometer, 3-axis gyroscope, 3-axis magnetometer
• MP34DT05: Digital microphone — stereo PDM microphone for audio ML applications
• APDS-9960: Proximity, ambient light, RGB colour, and gesture sensor
• LPS22HB: Barometric pressure sensor (260–1260 hPa)
• HTS221: Temperature and humidity sensor
• Bluetooth 5.0: BLE with long-range mode and 2 Mbps data rate

This onboard sensor array means you can collect training data and run inference without any external hardware — the entire ML pipeline from data collection to deployment happens on a single board.

Important distinction: The original Nano 33 BLE Sense (Rev 1) uses the LSM9DS1 + APDS-9960. The Rev 2 variant (Nano 33 BLE Sense Rev2) replaces these with a BMI270 IMU and APDS-9960 v2 — different library names apply. Check your board markings before installing libraries.

Understanding TinyML and Edge AI

Traditional machine learning runs on powerful servers — GPUs processing millions of data points to train and even run inference. TinyML (Tiny Machine Learning) refers to optimised ML models that run inference on microcontrollers with kilobytes of RAM and milliwatts of power.

The key trade-offs in TinyML are:

• Model size vs. accuracy: Quantising a neural network from 32-bit float weights to 8-bit integer weights reduces size by 4x and speeds up inference 2-3x with typically less than 5% accuracy loss.
• Latency vs. power: The Nano 33 BLE Sense can run gesture recognition inference in under 1ms, enabling real-time response. Deep sleep between inferences extends battery life to months.
• Privacy and latency: On-device inference means sensor data never leaves the device — critical for medical, industrial, and personal applications.

The primary framework for TinyML on Arduino is TensorFlow Lite for Microcontrollers (TFLM), an optimised subset of TensorFlow Lite designed for devices without operating systems or standard C libraries. Arduino wraps TFLM in the Arduino_TensorFlowLite library for easy integration.

Setting Up the Development Environment

Follow these steps to prepare your Arduino IDE for Nano 33 BLE Sense development:

1. Install Arduino IDE 2.x from arduino.cc — IDE 2.x has better library management and improved Cortex-M support.
2. Install the Mbed OS boards package: Go to Tools → Board → Boards Manager → search for “Arduino Mbed OS Nano Boards” → Install.
3. Select the board: Tools → Board → Arduino Mbed OS Nano Boards → Arduino Nano 33 BLE.
4. Install core libraries:
   • Arduino_LSM9DS1 (or Arduino_BMI270_BMM150 for Rev2)
   • Arduino_APDS9960
   • Arduino_HTS221
   • Arduino_LPS22HB
   • Arduino_TensorFlowLite
5. Test the installation: Open File → Examples → Arduino_LSM9DS1 → SimpleAccelerometer and upload. Verify you see x/y/z accelerometer data in the Serial Monitor.

For Edge Impulse workflow (recommended for most ML projects), also install the Edge Impulse CLI via npm: npm install -g edge-impulse-cli

Building a Model with Edge Impulse

Edge Impulse is the leading end-to-end development platform for embedded machine learning. It handles data collection, feature engineering, model training, and deployment to Arduino in a browser-based interface — no data science background required.

The general workflow:

1. Create a project at edgeimpulse.com and select Arduino Nano 33 BLE Sense as your target device.
2. Connect your board via the Edge Impulse CLI: edge-impulse-daemon. This streams sensor data directly from the board to Edge Impulse.
3. Collect training data through the Data Acquisition tab. For gesture recognition, you’d record 2–3 second windows of accelerometer data for each gesture class (e.g., “wave”, “circle”, “idle”).
4. Create an Impulse: Define the input block (e.g., time-series data at 100 Hz), processing block (Spectral Features or Raw Features), and learning block (Classification neural network).
5. Train the model — Edge Impulse’s AutoML finds optimal hyperparameters. Training takes 1–5 minutes on their cloud infrastructure.
6. Deploy to Arduino — Edge Impulse exports the quantised TensorFlow Lite model wrapped in an Arduino library (.zip). Install it via Sketch → Include Library → Add .ZIP Library.
7. Run inference using the generated header file and the example sketch Edge Impulse provides.

Edge Impulse generates highly optimised, quantised models with on-device DSP features computed efficiently by the Cortex-M4F’s CMSIS-DSP library. A typical 4-class gesture model uses 40–80 KB of flash and runs inference in under 2ms.

Project: Gesture Recognition

Gesture recognition is the “hello world” of TinyML on the Nano 33 BLE Sense. Using the LSM9DS1 IMU’s accelerometer data, you can train a model to recognise distinct hand movements.

After deploying your Edge Impulse model (let’s call the library gesture_inferencing), the inference sketch looks like this:

#include <gesture_inferencing.h>
#include <Arduino_LSM9DS1.h>

float features[EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE];
int feature_ix = 0;

void setup() {
  Serial.begin(115200);
  IMU.begin();
}

void loop() {
  // Collect accelerometer samples at model's sample rate
  if (IMU.accelerationAvailable() && feature_ix < EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE) {
    float x, y, z;
    IMU.readAcceleration(x, y, z);
    features[feature_ix++] = x;
    features[feature_ix++] = y;
    features[feature_ix++] = z;
  }
  
  if (feature_ix == EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE) {
    feature_ix = 0;
    signal_t signal;
    numpy::signal_from_buffer(features, EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE, &signal);
    
    ei_impulse_result_t result;
    run_classifier(&signal, &result, false);
    
    // Print top result
    for (int i = 0; i < EI_CLASSIFIER_LABEL_COUNT; i++) {
      if (result.classification[i].value > 0.7) {
        Serial.println(result.classification[i].label);
      }
    }
  }
}

With 50–100 samples per class (each a 2-second window), you can achieve 90%+ accuracy on 4 distinct gestures. Gestures can then trigger Bluetooth commands to control a phone app, a relay, or any BLE peripheral.

Project: Wake Word / Keyword Spotting

The onboard MP34DT05 microphone enables voice control without any internet connection. Keyword spotting detects specific words (“yes”, “no”, “go”, “stop”) from continuous audio and triggers local actions.

Edge Impulse provides several pre-built keyword spotting datasets, or you can record your own words through the browser-based data collection tool. The audio pipeline uses MFCC (Mel-Frequency Cepstral Coefficients) features — the same technique used in phone voice recognition, but optimised for microcontroller computation.

A typical keyword spotting model for 3 words + background + unknown fits in:

• Flash: ~60 KB for model weights
• RAM: ~30 KB for activations and audio buffer
• Inference time: 8–15ms on the Cortex-M4F at 64 MHz
• Power: ~3mA continuous audio sampling + inference

The Arduino microphone library for PDM: install PDM library (included in Mbed OS boards package). Edge Impulse’s microphone example handles all the PDM buffer management automatically.

Project: Vibration Anomaly Detection

Industrial predictive maintenance is one of TinyML’s most valuable applications. Mount the Nano 33 BLE Sense directly on a motor, pump, or gearbox. Train a model on normal vibration patterns, then detect anomalies (bearing failure, imbalance, misalignment) before they cause breakdowns.

Edge Impulse’s K-means anomaly detection block works without negative examples — you only need normal data. The model learns the feature space of normal operation and flags anything statistically distant.

Deployment options for industrial use:

• Alert via BLE to a gateway Raspberry Pi that sends MQTT notifications
• Flash an LED or trigger a relay directly
• Log anomaly events with timestamps to an SD card (via SPI)

Frequently Asked Questions

How much training data do I need for a TinyML project on the Nano 33 BLE Sense?

For simple gesture or keyword recognition with 3–5 classes, 50–100 samples per class (each 1–3 seconds) is often enough to achieve 85–95% accuracy. More complex applications with subtle class differences need 200–500 samples per class. Edge Impulse’s data augmentation (adding noise, time-shifting, amplitude scaling) effectively multiplies your dataset to improve model robustness.

Can I train models directly on the Nano 33 BLE Sense?

No — training neural networks requires far more computation and memory than even a Cortex-M4 can provide. Training happens on cloud infrastructure (Edge Impulse, Google Colab, etc.) or on a PC. Only inference (running the trained model) happens on the board. The Nano 33 BLE Sense is purpose-built for inference, not training.

What is the difference between the Nano 33 BLE and the Nano 33 BLE Sense?

The Arduino Nano 33 BLE is the base version with only the nRF52840 SoC and BLE — no onboard sensors beyond the IMU. The Nano 33 BLE Sense adds the full sensor array (microphone, pressure, temperature/humidity, gesture/proximity). For ML applications, you want the Sense version; for BLE-only projects, the base version is sufficient and cheaper.

How do I power the Nano 33 BLE Sense in a portable/battery project?

The board has a 3.3V regulator and can be powered via USB, the VIN pin (from 4.5–21V), or 3.3V directly. For battery projects, a LiPo with a suitable charger/regulator circuit works well. Using deep sleep via the ArduinoLowPower library between inferences reduces consumption from ~20mA active to under 4µA in deep sleep — enabling months of battery life for periodic inference applications.

Is the Nano 33 BLE Sense compatible with standard Arduino shields?

Partially. The Nano 33 BLE Sense uses 3.3V logic — standard 5V Arduino shields may damage it. Always verify the shield’s voltage compatibility before connecting. The pin layout is compatible with standard Nano form factor shields, but check each specific shield’s voltage requirements. Use level shifters for 5V SPI/I2C peripherals.

The Arduino Nano 33 BLE Sense represents a genuine leap in what embedded hobbyists and professional engineers can achieve with machine learning. Its combination of a capable processor, rich onboard sensors, and accessible tools like Edge Impulse has democratised TinyML — bringing AI capabilities to battery-powered, private, always-on devices at a fraction of the cost of cloud-based alternatives.

Start your TinyML journey today. Browse our Arduino boards collection at Zbotic — including the Arduino Tiny Machine Learning Kit and all Nano family boards, with fast delivery across India.