Original Arduino Nano 33 IOT ABX00027 Documentation

Component Name

Original Arduino Nano 33 IoT (ABX00027)

Overview

The Arduino Nano 33 IoT is a miniature microcontroller board designed for building IoT projects. It combines the functionality of the Arduino Nano with the capabilities of wireless communication, enabling users to create innovative IoT projects with ease.

Functionality

The Arduino Nano 33 IoT is a fully functional microcontroller board that can be used to create a wide range of IoT projects, including

Remote monitoring and control systems

Wireless sensor networks

Wearable devices

Home automation systems

Robotics and drones

Key Features

### Hardware Features

Microcontroller

ARM Cortex-M0+ 32-bit processor (SAMD21G18A)

Operating Frequency

48 MHz

Flash Memory

256 KB

SRAM

32 KB

EEPROM

4 KB

GPIO

14 digital input/output pins, 8 analog input pins, 2 analog output pins

Communication

IEEE 802.11b/g/n Wi-Fi, Bluetooth 4.2, NFC

### Wireless Communication

Wi-Fi

Onboard Wi-Fi module (u-blox NINA-W102) for wireless connectivity

Bluetooth

Onboard Bluetooth module (u-blox NINA-B112) for wireless communication

NFC

Onboard NFC tag (u-blox NXP NTAG) for near-field communication

### Power Management

Power Supply

USB or external power source (7-12V)

Power Consumption

1.5mA (idle), 15mA (active)

Low Power Modes

Supports multiple low power modes for power-efficient operation

### Additional Features

Onboard Antenna

Integrated Wi-Fi and Bluetooth antenna for improved wireless performance

Reset Button

Dedicated reset button for easy rebooting

LED Indicators

Onboard LED indicators for Wi-Fi, Bluetooth, and power status

Debugging

Built-in USB-TTL serial converter for debugging and programming

### Software Compatibility

Arduino IDE

Fully compatible with the Arduino Integrated Development Environment (IDE)

Programming Languages

Supports C, C++, and MicroPython programming languages

### Dimensions and Weight

Dimensions

45 x 18 mm (1.77 x 0.71 in)

Weight

5 grams (0.18 oz)

RoHS

Compliant with the Restriction of Hazardous Substances (RoHS) directive

CE

Conforms to the European Union's Conformit Europene (CE) marking

FCC

Compliant with the Federal Communications Commission (FCC) regulations

Accessories

The Arduino Nano 33 IoT comes with a variety of accessories, including

USB Cable

For programming and power supply

Antenna

Optional external antenna for improved wireless performance

Breadboard

For prototyping and testing IoT projects

Conclusion

The Arduino Nano 33 IoT is a powerful and versatile microcontroller board that enables users to create innovative IoT projects with ease. Its onboard wireless communication capabilities, power management features, and compact design make it an ideal choice for a wide range of applications.

Pin Configuration

Original Arduino Nano 33 IoT ABX00027 Pinout Explanation
The Arduino Nano 33 IoT is a microcontroller board based on the ATMEL ATSAMD21G18A chip. It has 14 digital input/output pins, 8 analog input pins, and several other pins for power, communication, andReset functionality. Here's a detailed explanation of each pin:
Digital Pins:
1. D0/RX: Digital pin 0 is also the serial receive (RX) pin. It's used for serial communication and can be used as a digital input/output.
2. D1/TX: Digital pin 1 is also the serial transmit (TX) pin. It's used for serial communication and can be used as a digital input/output.
3. D2: Digital pin 2 is a general-purpose digital input/output pin.
4. D3: Digital pin 3 is a general-purpose digital input/output pin.
5. D4: Digital pin 4 is a general-purpose digital input/output pin.
6. D5: Digital pin 5 is a general-purpose digital input/output pin.
7. D6: Digital pin 6 is a general-purpose digital input/output pin.
8. D7: Digital pin 7 is a general-purpose digital input/output pin.
9. D8: Digital pin 8 is a general-purpose digital input/output pin.
10. D9: Digital pin 9 is a general-purpose digital input/output pin.
11. D10: Digital pin 10 is a general-purpose digital input/output pin.
12. D11: Digital pin 11 is a general-purpose digital input/output pin.
13. D12: Digital pin 12 is a general-purpose digital input/output pin.
14. D13/L: Digital pin 13 is a general-purpose digital input/output pin and is connected to the on-board LED.
Analog Pins:
1. A0: Analog input pin 0.
2. A1: Analog input pin 1.
3. A2: Analog input pin 2.
4. A3: Analog input pin 3.
5. A4: Analog input pin 4.
6. A5: Analog input pin 5.
7. A6: Analog input pin 6.
8. A7: Analog input pin 7.
Power Pins:
1. VIN: Input voltage pin. It can be used to power the board with an external power source.
2. 3V3: 3.3V output pin. It can be used to power external components.
3. GND: Ground pin.
Communication Pins:
1. USB: USB port for programming and communication with a computer.
Reset Pin:
1. RST: Reset pin. It's used to reset the board.
Additional Pins:
1. NC: Not Connected pins (pins 32, 33, 34, and 35). These pins are not connected to any functionality.
How to Connect the Pins:
When connecting pins on the Arduino Nano 33 IoT, make sure to follow these guidelines:
Use jumper wires or breadboard-friendly cables to connect pins to external components.
Be careful when handling the board to avoid damaging the pins or the surrounding components.
Use the correct voltage levels for the pins. The operating voltage of the board is 3.3V.
When using external power sources, make sure they are within the recommended voltage range (3.3V to 5V) and that the current rating is sufficient for your project.
Use the Arduino IDE and the corresponding libraries to program and communicate with the board.
Remember to always refer to the official Arduino documentation and the datasheet for the ATMEL ATSAMD21G18A chip for more detailed information on the pinout and usage of the Arduino Nano 33 IoT.

Code Examples

Original Arduino Nano 33 IOT ABX00027 Documentation

The Original Arduino Nano 33 IOT ABX00027 is a compact and powerful microcontroller board designed for IoT applications. It is based on the ATSAMD21G18A microcontroller, which is a 32-bit ARM Cortex-M0+ processor. This board features Wi-Fi and Bluetooth capabilities, making it an ideal choice for IoT projects that require wireless connectivity.

Technical Specifications

Microcontroller: ATSAMD21G18A
 Processing Unit: 32-bit ARM Cortex-M0+
 Clock Speed: 48 MHz
 RAM: 256 KB
 Flash Memory: 512 KB
 Wi-Fi: Yes, onboard Wi-Fi module
 Bluetooth: Yes, onboard Bluetooth module
 Operating Voltage: 3.3V
 Digital I/O Pins: 14
 Analog Input Pins: 8
PWM Output Pins: 4
 UART: 2
 SPI: 1
 I2C: 1
 Analog Output Pins: 1

Code Examples

### Example 1: Wi-Fi Connectivity and Web Server

In this example, we will create a simple web server using the Arduino Nano 33 IOT's Wi-Fi capabilities. The board will connect to a Wi-Fi network and serve a simple HTML page.

```c++
#include <WiFi.h>

const char ssid = "your_ssid"; // replace with your Wi-Fi network SSID
const char password = "your_password"; // replace with your Wi-Fi network password

WiFiServer server(80);

void setup() {
  Serial.begin(9600);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to Wi-Fi...");
  }
  Serial.println("Connected to Wi-Fi");
  Serial.println("Starting web server...");
  server.begin();
  Serial.println("Web server started");
}

void loop() {
  WiFiClient client = server.available();
  if (client) {
    Serial.println("Client connected");
    String request = client.readStringUntil('
');
    client.println("HTTP/1.1 200 OK");
    client.println("Content-Type: text/html");
    client.println("");
    client.println("<!DOCTYPE HTML><html><body><h1>Hello World!</h1></body></html>");
    client.stop();
    Serial.println("Client disconnected");
  }
}
```

### Example 2: Bluetooth Low Energy (BLE) Peripheral

In this example, we will create a BLE peripheral using the Arduino Nano 33 IOT's onboard Bluetooth module. The board will advertise a BLE service and characteristic, and respond to writes to the characteristic.

```c++
#include <ArduinoBLE.h>

BLEService myService("180F"); // define a custom BLE service
BLEIntCharacteristic myCharacteristic("2A19", BLERead | BLEWrite); // define a custom BLE characteristic

void setup() {
  Serial.begin(9600);
  if (!BLE.begin()) {
    Serial.println("Failed to initialize BLE");
    while (1);
  }
  Serial.println("BLE initialized");
  BLE.setLocalName("Arduino Nano 33 IOT"); // set the BLE device name
  myService.addCharacteristic(myCharacteristic); // add the characteristic to the service
  BLE.addService(myService); // add the service
  BLE.advertise(); // start advertising the BLE service
  Serial.println("BLE advertising started");
}

void loop() {
  BLEDevice central = BLE.central(); // wait for a central device to connect
  if (central) {
    Serial.println("Connected to central device");
    while (central.connected()) {
      if (myCharacteristic.written()) {
        int value = myCharacteristic.value(); // get the written value
        Serial.print("Received value: ");
        Serial.println(value);
      }
    }
    Serial.println("Disconnected from central device");
  }
}
```

### Example 3: Read Analog Input and Send to Cloud using Wi-Fi

In this example, we will read an analog input from a sensor connected to the Arduino Nano 33 IOT and send the data to a cloud service using Wi-Fi.

```c++
#include <WiFi.h>
#include <HTTPClient.h>

const char ssid = "your_ssid"; // replace with your Wi-Fi network SSID
const char password = "your_password"; // replace with your Wi-Fi network password
const char apiKey = "your_api_key"; // replace with your cloud service API key
const char cloudUrl = "https://example.com/api/data"; // replace with your cloud service URL

WiFiClient client;
HTTPClient http;

void setup() {
  Serial.begin(9600);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to Wi-Fi...");
  }
  Serial.println("Connected to Wi-Fi");
}

void loop() {
  int sensorValue = analogRead(A0); // read analog input from sensor
  Serial.print("Sensor value: ");
  Serial.println(sensorValue);
  http.begin(client, cloudUrl);
  http.addHeader("Content-Type", "application/json");
  http.addHeader("Authorization", "Bearer " + String(apiKey));
  int httpCode = http.POST("{""value"":" + String(sensorValue) + "}");
  if (httpCode == 200) {
    Serial.println("Data sent to cloud successfully");
  } else {
    Serial.println("Error sending data to cloud");
  }
  http.end();
  delay(1000);
}
```

These examples demonstrate the capabilities of the Original Arduino Nano 33 IOT ABX00027 board in various IoT contexts.