Arduino Nano 33 IoT: WiFi and BLE in One Small Package

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.

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.

Recommended: Arduino Nano 33 IoT with Header — the official Arduino board with pre-soldered headers, ready to plug into a breadboard or shield for immediate prototyping.

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.

Recommended: Arduino Nano Every with Headers — if you need 5V compatibility and don’t need wireless, the Nano Every is the classic Nano replacement with a more powerful AVR processor.

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).

Recommended: Arduino Nano RP2040 Connect with Header — the RP2040-based sibling with dual-core ARM processor, also includes WiFi and BLE plus a built-in microphone, great for voice-controlled IoT projects.

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 ArduinoLowPower library 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.

Recommended: Arduino Tiny Machine Learning Kit — pair the Nano 33 BLE Sense (included) with TensorFlow Lite for edge AI projects like keyword detection or gesture recognition alongside your Nano 33 IoT builds.

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.