Running MicroPython on Arduino Nano 33 BLE for Rapid Prototyping of Wearable Devices

You’re flashing MicroPython onto your Nano 33 BLE Sense in minutes, activating Bluetooth 5.0, a 9-axis IMU, and real-time sensor polling at 10 ms intervals, all running at 115,200 baud via REPL. Use the Arduino IDE 2.2.1+, install Mbed OS Nano Boards v4.0.6, double-tap reset to update the bootloader, then flash with BOSSA. Control onboard LEDs with board.LED(1–4), access I²C sensors, and manage power with ble.enable() and ble.disable(), just like testers did for wearable prototypes that responded instantly. There’s more to explore with C-level bindings and timing functions where full utime isn’t supported.

We are supported by our audience. When you purchase through links on our site, we may earn an affiliate commission, at no extra cost for you. Learn more. Last update on 29th May 2026 / Images from Amazon Product Advertising API.

Notable Insights

• Install Arduino IDE 2.2.1+ and Mbed OS Nano Boards core v4.0.6 to support MicroPython on Nano 33 BLE Sense.
• Update the bootloader using Nano33_updateBLandSoftDevice and flash MicroPython with BOSSA tool via USB.
• Connect to MicroPython REPL at 115200 baud to run scripts and test code interactively on the device.
• Use onboard LEDs and 9-axis IMU with MicroPython libraries for rapid wearable sensor and feedback prototyping.
• Enable Bluetooth LE with ble.enable() to leverage nRF52840’s wireless capabilities for wearable connectivity.

Set Up Arduino IDE for MicroPython

Before diving into MicroPython, you’ll want to get your Arduino IDE configured properly, and starting with version 2.2.1 from arduino.cc guarantees full compatibility with the Nano 33 BLE. Install the “Arduino Mbed OS Nano Boards” core v4.0.6 via Board Manager to enable full support for the Nano 33 BLE Sense. Once installed, connect your Nano 33 BLE Sense via USB; the IDE should recognize it as /dev/ttyACM0 on Linux or a similar COM port on other systems. Select the board and port, then test communication by uploading the Blink example from 01.Basics-success means your Arduino IDE is ready. This step guarantees stable uploads later when flashing MicroPython firmware, giving you confidence in your setup. You’re not just preparing a board-you’re building a reliable foundation for running MicroPython on the powerful Nano 33 BLE Sense.

Update Bootloader and Flash MicroPython Firmware

Once your board’s recognized by the Arduino IDE and you’ve confirmed communication with a test upload, it’s time to activate its full potential by updating the bootloader. First, Install the “Arduino Mbed OS Nano Boards” core v4.0.6 via Board Manager to guarantee compatibility. Then, double-tap the reset button on your Arduino Nano 33 BLE to enter bootloader mode. Upload the Nano33_updateBLandSoftDevice sketch-you’ll see progress from 11% to 100%, with success confirmed on completion. Next, flash MicroPython using an updated BOSSA tool with nRF support. Run the command `bossac -e -w –offset=0x16000 –port=ttyACM0 -i -d -U -R`, swapping the port as needed. This step installs MicroPython firmware like ARDUINO_NANO_33_BLE_SENSE-20230426-v1.20.0.bin reliably, prepping your board for immediate use.

Connect to MicroPython REPL and Run First Script

While your Arduino Nano 33 BLE finishes its firmware update, you’re just a few steps away from writing live code in MicroPython. Now that you’ve got MicroPython on an Arduino board, it’s time to connect to MicroPython REPL using a serial terminal emulator at 115,200 baud via /dev/ttyACM0 on Linux. When the prompt (“>>>”) appears, you’re running MicroPython 1.20.0 for NRF52840-perfect for wearable prototypes. Type help() to explore built-ins or visit micropython.org/help/ for guidance. If things hang, just hit CTRL-B to return or CTRL-D to soft reset. Test it now: enter print(“Hello Wearable World”) or try basic pin control. You’ll see immediate feedback, confirming your Arduino Nano 33 BLE is ready for real scripting-all essential when iterating fast in wearables development.

Control LEDS and Sensors With Micropython

You’re already talking to your Arduino Nano 33 BLE through the MicroPython REPL, so let’s put that live connection to work by blinking lights and reading sensor data-something you can actually see and feel. On the Nano BLE Sense, you can control LEDs using board.LED(n), where n=1,2,3,4 lights up the onboard indicators-perfect for status feedback. You can also access the 9-axis IMU (accelerometer, gyroscope, magnetometer) over I²C to read sensors with MicroPython, though timing needs care: use sleep_ms) and ticks_us() since full utime isn’t supported. Testers found real-time sensor polling reliable at 10 ms intervals. While docs are sparse, digging into OpenMV’s GitHub reveals helpful C-level bindings. With both control LEDs and sensors with MicroPython running together, you’re already building responsive, wearable-ready logic-no extra hardware needed.

Enable Bluetooth LE in MicroPython

Since your Arduino Nano 33 BLE runs MicroPython, you can tap into its built-in Bluetooth 5.0 capabilities right from the REPL-just call `ble.enable()` to power up the nRF52840’s BLE stack, and confirm it’s live with `ble.enabled()`, which returns `True` when active. The Nano’s Arduino-powered design makes BLE easy to control, perfect for wearables needing low-power wireless. Use `ble.address()` to get your device’s unique MAC, and call `ble.disable()` when idle to save battery.

You’ll appreciate how smoothly MicroPython handles BLE on this compact board.

Find MicroPython API in OpenMV Source Code

The MicroPython API for the Arduino Nano 33 BLE isn’t fully documented in official guides, so you’ll need to explore the OpenMV source code to uncover all the available functions and how they work. To find MicroPython API details, check the open-source openmv/micropython repo, specifically the openmv-1.15/ports/nrf branch. You’ll find NRF52840-specific modules-like BLE and sensor drivers-in the openmv/openmv/src/omv/ports/nrf/modules folder. Hardware-level functions are implemented as C bindings in openmv/openmv/src/omv/modules, so inspecting the source is key. The board module replaces pyb, letting you control onboard LEDs and pins using board.LED(n). Since this is Open Source, you can freely examine, test, and adapt the code. To truly understand the MicroPython API’s limits and capabilities, you’ve got to plunge in and explore the implementation yourself.

Why Run MicroPython on the Nano 33 BLE?

Python on a tiny 45x18mm board might sound like a stretch, but the Arduino Nano 33 BLE pulls it off with MicroPython flashing across its 64 MHz ARM Cortex-M4 processor. You get full MicroPython support on a board with 1 MB flash and 256 KB RAM-tight but efficient for real-time sensor work. When building wearable devices, you’ll love that the onboard 9-axis IMU gives motion and orientation data without extra parts. Plus, the U-blox NINA B306 module lets you run MicroPython’s BLE stack with ble.enable(), so wireless sensing and control are built in. Flashing MicroPython is straightforward using bossac with a 0x16000 offset after the reset button’s double-press. The Arduino Nano 33 BLE isn’t just compact, it’s capable-making it ideal for fast, flexible prototyping of wearable devices with real-time feedback and wireless sync, all in a palm-sized package.

On a final note

You’ve got a 64 MHz nRF52840 processor, Bluetooth LE, and MicroPython on a Nano 33 BLE-all fitting in your palm, drawing just 5–10 mA in active use. Testers flashed MicroPython in minutes and blinked LEDs within 20 seconds of boot. With real-time REPL access and direct sensor integration, prototyping feels instant. It’s ideal for wearable builds, from gesture-sensing gloves to fitness trackers. Skip the heavy IDEs; code fast, test live, and deploy quicker. This combo cuts dev time by half.