The Arduino Nano 33 IoT is one of the most capable compact boards Arduino has ever released, packing WiFi, Bluetooth Low Energy (BLE), an IMU, and a 32-bit ARM Cortex-M0+ processor into the familiar Nano form factor. This arduino nano 33 iot guide walks you through everything from first setup and pinout to connecting to WiFi, using BLE, and building real IoT projects — all while staying under the physical footprint of a postage stamp.
Table of Contents
- Board Overview and Specs
- Pinout and Pin Differences from Classic Nano
- First Setup: Installing the Right Core
- Connecting to WiFi
- Using Bluetooth Low Energy
- On-Board IMU: LSM6DS3
- Power Considerations
- Project Ideas
- FAQ
Board Overview and Specs
The Arduino Nano 33 IoT is built around the SAMD21 microcontroller (ARM Cortex-M0+ at 48 MHz) paired with the u-blox NINA-W102 module for WiFi (802.11 b/g/n, 2.4 GHz) and Bluetooth 4.2 (including BLE). Here are the key specifications:
- MCU: SAMD21G18A, ARM Cortex-M0+ @ 48 MHz
- Flash: 256 KB
- RAM: 32 KB
- Wireless: WiFi 802.11 b/g/n + Bluetooth 4.2 / BLE (u-blox NINA-W102)
- IMU: LSM6DS3 (6-axis: accelerometer + gyroscope)
- Operating voltage: 3.3V logic (NOT 5V tolerant)
- Input voltage: 5V via USB or 4.5-21V via VIN
- Analog inputs: 8 (12-bit ADC)
- Digital I/O: 14 pins (with 5 PWM)
- Dimensions: 45 × 18 mm (classic Nano footprint)
Compared to the original Arduino Nano (ATmega328P, 16 MHz, 5V), the Nano 33 IoT is dramatically more powerful and adds wireless connectivity, but the 3.3V logic level is the most important thing to remember — connecting 5V signals directly will permanently damage the board.
Pinout and Pin Differences from Classic Nano
The Nano 33 IoT uses the same physical pin layout as the classic Nano, making it a drop-in upgrade for existing Nano-based designs — with one major caveat: the logic level is 3.3V, not 5V.
Key pin notes:
- A4/A5: These serve as SDA/SCL for I2C. Same as classic Nano.
- D11/D12/D13: SPI MOSI/MISO/SCK. Same positions.
- D0/D1: Hardware Serial (UART). The NINA module also uses a separate UART internally.
- 3V3 pin: Can output up to 50 mA — do not power high-current devices from it.
- VIN pin: When powered via USB, VIN outputs ~4.7V. When powered externally, it accepts up to 21V.
- AREF: Connected to 3.3V internally. External AREF is possible but unusual.
The 12-bit ADC is a significant upgrade from the classic Nano’s 10-bit ADC. By default, analogRead() still returns 0-1023 for compatibility, but you can unlock the full 12-bit resolution (0-4095) with analogReadResolution(12).
First Setup: Installing the Right Core
The Nano 33 IoT requires the Arduino SAMD Boards core, NOT the standard AVR core. Follow these steps:
- Open Arduino IDE (version 1.8.19 or 2.x).
- Go to Tools → Board → Boards Manager.
- Search for “Arduino SAMD Boards (32-bits ARM Cortex-M0+)”.
- Install the latest version (currently 1.8.x).
- Go to Tools → Board → Arduino SAMD Boards → Arduino Nano 33 IoT.
- Select your port and upload a Blink sketch to verify setup.
You’ll also need to install the WiFiNINA library for wireless functions:
- Go to Sketch → Include Library → Manage Libraries.
- Search for “WiFiNINA” and install it.
- Also install “ArduinoBLE” for BLE support.
Firmware update: It’s strongly recommended to update the NINA module firmware using the WiFiNINA library’s built-in firmware updater sketch. Old firmware has known bugs with some WiFi routers.
Connecting to WiFi
The WiFiNINA library makes WiFi connection straightforward. Here is a complete example that connects to your network and makes an HTTP GET request:
#include <WiFiNINA.h>
const char WIFI_SSID[] = "YourNetworkName";
const char WIFI_PASS[] = "YourPassword";
WiFiClient client;
void setup() {
Serial.begin(9600);
while (!Serial); // Wait for serial monitor
Serial.print("Connecting to WiFi...");
WiFi.begin(WIFI_SSID, WIFI_PASS);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
Serial.println("Connected!");
Serial.print("IP Address: ");
Serial.println(WiFi.localIP());
Serial.print("Signal Strength (RSSI): ");
Serial.print(WiFi.RSSI());
Serial.println(" dBm");
}
void loop() {
// Make an HTTP GET request every 30 seconds
if (client.connect("api.thingspeak.com", 80)) {
client.println("GET /channels/YOUR_CHANNEL_ID/feeds.json HTTP/1.1");
client.println("Host: api.thingspeak.com");
client.println("Connection: close");
client.println();
// Read response
while (client.available()) {
Serial.write(client.read());
}
client.stop();
}
delay(30000);
}HTTPS connections: The NINA module supports SSL/TLS natively. Use WiFiSSLClient instead of WiFiClient for HTTPS endpoints — no extra library needed. This is essential for posting to cloud APIs like AWS IoT Core or Google Cloud IoT.
WiFi reconnection: Real-world deployments need automatic reconnection logic. Add this to your loop():
if (WiFi.status() != WL_CONNECTED) {
Serial.println("WiFi lost — reconnecting...");
WiFi.begin(WIFI_SSID, WIFI_PASS);
delay(5000);
}Using Bluetooth Low Energy
BLE on the Nano 33 IoT uses the ArduinoBLE library, which wraps the GATT protocol into a simple API. Here’s a minimal BLE peripheral example that exposes a custom sensor characteristic:
#include <ArduinoBLE.h>
BLEService sensorService("180A"); // Standard Device Information Service UUID
BLEUnsignedIntCharacteristic moistureChar("2A58", BLERead | BLENotify);
void setup() {
Serial.begin(9600);
if (!BLE.begin()) {
Serial.println("BLE init failed!");
while (1);
}
BLE.setLocalName("SoilMonitor");
BLE.setAdvertisedService(sensorService);
sensorService.addCharacteristic(moistureChar);
BLE.addService(sensorService);
moistureChar.writeValue(0);
BLE.advertise();
Serial.println("BLE advertising started");
}
void loop() {
BLEDevice central = BLE.central();
if (central) {
Serial.print("Connected to: ");
Serial.println(central.address());
while (central.connected()) {
int moisture = analogRead(A0);
moistureChar.writeValue(moisture);
delay(1000);
}
Serial.println("Disconnected");
}
}You can connect to this peripheral using a phone app like nRF Connect (Android/iOS) to read the characteristic values in real time. This is ideal for wireless sensor nodes where you want low power consumption and close-range connectivity (up to ~10 metres).
On-Board IMU: LSM6DS3
The Nano 33 IoT includes an LSM6DS3 6-axis IMU (3-axis accelerometer + 3-axis gyroscope) connected via I2C internally. Install the Arduino_LSM6DS3 library from the Library Manager to use it.
#include <Arduino_LSM6DS3.h>
void setup() {
Serial.begin(9600);
if (!IMU.begin()) {
Serial.println("IMU init failed!");
while (1);
}
Serial.println("IMU ready");
}
void loop() {
float ax, ay, az, gx, gy, gz;
if (IMU.accelerationAvailable()) {
IMU.readAcceleration(ax, ay, az);
Serial.print("Accel: ");
Serial.print(ax); Serial.print(", ");
Serial.print(ay); Serial.print(", ");
Serial.println(az);
}
if (IMU.gyroscopeAvailable()) {
IMU.readGyroscope(gx, gy, gz);
Serial.print("Gyro: ");
Serial.print(gx); Serial.print(", ");
Serial.print(gy); Serial.print(", ");
Serial.println(gz);
}
delay(500);
}The accelerometer can detect orientation (tilt, free-fall), vibration, and movement — perfect for asset tracking, fall detection, or gesture-controlled interfaces.
Power Considerations
The Nano 33 IoT’s biggest power draw comes from the NINA module during WiFi transmissions, which can spike to 250 mA. Here are practical power tips:
- USB powered: Fine for prototyping. VIN can source up to 250 mA to external sensors.
- Battery powered: Use a 3.7V LiPo battery with a boost converter or a 4xAA pack (6V) via VIN.
- WiFi power: Disconnect from WiFi between measurements using
WiFi.end()to save power. Reconnect only when you need to transmit. - Deep sleep: The SAMD21 supports sleep modes, but sleeping with the NINA module active wastes power. Use the
ArduinoLowPowerlibrary for sleep functionality. - BLE vs WiFi: BLE (advertising) uses as little as 5-15 mA vs WiFi’s 100-250 mA during active connection. For battery-powered nodes that just need to push data to a nearby hub, prefer BLE.
Project Ideas
The combination of WiFi, BLE, and the IMU makes the Nano 33 IoT ideal for a wide range of projects:
- Wireless sensor node: Connect temperature (DHT22), air quality (MQ135), or soil moisture sensors and push readings to ThingSpeak, Adafruit IO, or a home Assistant MQTT broker every few minutes.
- BLE door sensor: Use the accelerometer to detect door open/close events and broadcast them via BLE to a Raspberry Pi hub.
- Fitness tracker prototype: Read accelerometer and gyroscope data over BLE to a smartphone app for step counting or gesture recognition.
- WiFi-controlled relay: Host a simple HTTP server on the board to control a relay module from any browser on your local network.
- OTA updates: Use the WiFiNINA library’s ArduinoOTA support to push new firmware wirelessly — no need to physically access the board after deployment.
FAQ
Is the Arduino Nano 33 IoT compatible with 5V sensors?
No — the Nano 33 IoT operates at 3.3V logic and is NOT 5V tolerant on any of its pins. Connecting a 5V signal directly will damage the board. Use a logic level converter (bidirectional) when interfacing with 5V sensors or modules.
Can the Nano 33 IoT use WiFi and BLE simultaneously?
Yes, the NINA-W102 module supports concurrent WiFi and BLE operation. However, both share the same 2.4 GHz radio, so performance of each will be slightly reduced. For most IoT applications this is perfectly acceptable.
How does the Nano 33 IoT compare to the ESP8266 or ESP32?
The ESP8266/ESP32 are cheaper and have more RAM/flash, but the Nano 33 IoT offers official Arduino support, the Arduino ecosystem, a proper bootloader with no boot mode issues, the on-board IMU, and much simpler library integration. Choose ESP for cost-sensitive high-volume projects; choose Nano 33 IoT for easier development and more reliable software support.
Why is my Nano 33 IoT not connecting to my 5 GHz WiFi network?
The NINA-W102 module only supports the 2.4 GHz band. If your router broadcasts the same SSID on both 2.4 GHz and 5 GHz, try temporarily creating a 2.4 GHz-only SSID or use a network analyser app to confirm your SSID is visible on 2.4 GHz.
Can I use the Nano 33 IoT as a USB HID device (keyboard, mouse)?
Unlike the Arduino Leonardo or Micro (which use an ATmega32U4 with native USB), the Nano 33 IoT’s SAMD21 also has native USB support and CAN act as a USB HID device using the PluggableUSB architecture. Check the Arduino SAMD core examples for USB keyboard/mouse examples.
Ready to build your first wireless Arduino project? The Nano 33 IoT gives you everything you need to start connecting sensors to the internet in a board small enough to embed anywhere. Browse our full selection of Arduino boards and IoT modules at Zbotic and get your project connected today.
Add comment