Arduino Nano Pinout Guide: Power Pins, I/O Mapping & Easy Wiring Examples

Introduction

If you have spent even a little time tinkering or working with electronics components, chances you have met with the Arduino Nano and Arduino Nano pinout. It doesn’t scream for attention to look particularly fancy and eye-catching, but that’s the magic of it. This tiny board has earned a quiet reputation as a go-to companion in school projects, weekend experiments, and even some surprisingly advanced prototypes. Small, easy to handle, and ready for anything. 

Over time, the trend has clearly shifted toward these Arduino Nano compact boards. You’re no longer dealing with oversized setups just to read a sensor or push some data over WiFi. Developers want gear that’s lean, efficient, and gets the job done without soaking up power or space. That’s where boards like the Nano shine.

That said, one common trap many fall into? The pins. They’re not all the same, and misusing them can send you into a spiral of weird behaviors and silent errors. Blow a power pin or connect something to the wrong I2C line, and suddenly nothing works and you’re left scratching your head.

This board supports a bunch of features digital I/O, analog reads, UART, SPI, I2C you name it. But using them well isn’t about memorizing acronyms. It’s about knowing when and why to tap into certain lines based on the job at hand. Whether it’s a tiny wearable or a home-brewed smart device, picking the wrong pin can throw everything off.

So, instead of handing you a bland chart of pin numbers, let’s dig into what actually matters in Arduino Nano pinout. You’ll see what each pin does, how it behaves under load, and what quirks you should keep in mind. It’s the kind of info you only pick up after you’ve burnt a few fingers figuratively or literally.

Overview of Arduino Nano 

The Arduino Nano is a small, breadboard-friendly development board built around the ATmega328P microcontroller. Functionally, it’s almost identical to the Arduino Uno but in a much smaller form factor.

Core specifications:

• Microcontroller: ATmega328P
• Clock Speed: 16 MHz
• Operating Voltage: 5V
• Input Voltage: 7–12V (via VIN)
• Digital I/O Pins: 14
• PWM Pins: 6
• Analog Input Pins: 8
• Flash Memory: 32 KB
• SRAM: 2 KB
• EEPROM: 1 KB

Because of its small footprint and USB support, the Nano is a favorite for embedded projects and quick prototyping. Its low power consumption also makes it suitable for battery-operated systems.

Compared to the Arduino Uno, the Nano offers nearly identical functionality in a smaller, breadboard-friendly package, which is why many prefer it for compact or portable projects.

What Is ATmega328P?

You’ve probably heard of the ATmega328P if you’ve ever tinkered with an Arduino board. It’s the little chip doing all the thinking behind classics like the Arduino Uno, Arduino Nano, and Pro Mini. Originally created by Atmel (now part of Microchip Technology), this 8-bit AVR microcontroller has become something of a standard in the DIY and prototyping world. To understand Arduino Nano Pinout we need to know about the ATmega328P.

What makes it so well-loved? It’s a mix of things, really. It doesn’t demand much power, yet it handles most everyday tasks with ease. It’s also packed with built-in features that simplify everything from reading sensors to managing timing and communication. That’s why you’ll find it not only in school projects but also tucked away in real-world electronics be it a hobby robot, a piece of test equipment, or even parts of industrial automation setups.

The ATmega328P strikes that sweet spot between capability and simplicity enough muscle to get serious work done, without overwhelming you with complexity.

The ATmega328P features three essential memory types:

• Flash (32 KB) – Stores your uploaded code. It’s non-volatile, so your program stays saved even after power-off.
• SRAM (2 KB) – Temporary memory used while your code runs (like variables, arrays, etc.). It clears every time the Nano resets or loses power.
• EEPROM (1 KB) – Used to store small amounts of data that you want to keep even after power is off, like settings or calibration values.
  Each type plays a different role. For example, use EEPROM for settings you want to save permanently (like calibration values), and be mindful of SRAM limits if your sketch has large arrays or strings.

Key Features of ATmega328P

Overview of Arduino Nano Pinout

You wouldn’t know it at a glance, but the Arduino Nano pinout actually packs 30 pins along its sides 15 per row. It’s a tight little board, but every pin has its place.

Here’s how they’re split up:

• Fourteen of them act as digital I/O (D0 through D13),
• Another eight are analog inputs (A0 to A7),
• Then there are six pins for power stuff,
• And finally, a couple related to resetting things.

Sounds simple enough until you wire something wrong. Misplace a ground or overload a digital pin, and weird things start happening. That’s why it’s worth getting familiar with what each pin is supposed to do. It’ll save you from headaches down the line, especially when your circuit refuses to cooperate and you’re not sure why.

Power Pins in Arduino Nano Pinout

The Nano includes several pins for power supply and regulation.

Tip: Do not supply voltage directly to the 5V pin unless it’s regulated. Always use VIN when providing external power.

Digital I/O Pins (D0–D13) Explained

Alright, so digital pins on the Nano… you’ve got a bunch of them, and yeah, you can flip them to either “on” or “off” in the code. That’s basically pinMode() just tells the board what you want that pin to do. HIGH means 5 volts, LOW means none. That’s it.

Now here’s something kinda cool some of those pins do more than just on/off. They can pretend to be analog. Not real analog, but they fake it well enough using something called PWM. You use analogWrite() for that, and it’s great for stuff like dimming LEDs.

Which pins? Uhh, from memory: D3, D5, D6, D9, D10, D11. You’ll probably double-check that anyway I still do sometimes.

Oh, and quick warning D0 and D1, don’t touch ’em if you’re using Serial Monitor. Those are the pins the Nano uses to talk to your computer. I’ve made that mistake before and wondered why uploads weren’t working. Learn from my pain.

Onboard LED

• Pin D13 is connected to the onboard LED. This is useful for testing and debugging.

Example uses:

• D3 for motor speed control
• D10 for servo control
• D12 for reading digital input from a button

Analog Pins (A0–A7) and Their Uses

The Nano has 8 analog input pins, labeled A0 to A7. These use a 10-bit ADC, converting voltages from 0 to 5V into values between 0 and 1023.

These analog input pins are commonly used with sensors and modules such as temperature sensors, LDRs, potentiometers, or humidity sensors in prototyping projects

A6 and A7 are unique to the Nano and are particularly useful when you need more analog inputs than what most Arduino boards provide.

Communication Pins (UART, SPI, I2C)

The Nano supports three primary communication protocols: UART, SPI, and I2C.

UART (Serial Communication)

• D0: RX (receive)
• D1: TX (transmit)

Used for communicating with computers and serial peripherals. Be cautious when using these pins in your project, as they conflict with USB communication during code upload.

Practical Example:

UART (D0: RX, D1: TX) – Serial Communication

• Bluetooth Module (e.g., HC-05 or HC-06)
  Connect the Nano’s TX to the Bluetooth module’s RX and vice versa. This allows you to wirelessly send and receive data, like controlling a robot via a smartphone.
• GPS Module (e.g., NEO-6M)
  Use UART to receive NMEA sentences from the GPS module and extract coordinates for GPS tracking systems.

I2C (Inter-Integrated Circuit)

• A4: SDA (data)
• A5: SCL (clock)

This protocol is great for connecting to:

• OLED displays
• RTC modules
• BME280 or BMP280 environmental sensors
• EEPROM modules

You can connect multiple I2C devices using unique addresses and only two wires.

Practical Example:

I2C (A4: SDA, A5: SCL) – Multi-Device Communication

• OLED Display (e.g., SSD1306)
  Display sensor readings, system status, or graphical animations with just two wires and an I2C library.
• Real-Time Clock (e.g., DS3231)
  Track time and date even when the Nano is powered off. Perfect for data logging or timed automation.
• BME280 Environmental Sensor
  Measure temperature, humidity, and barometric pressure using minimal pins and wiring.

SPI (Serial Peripheral Interface)

• D10: SS (Slave Select)
• D11: MOSI (Master Out, Slave In)
• D12: MISO (Master In, Slave Out)
• D13: SCK (Serial Clock)

Used for high-speed communication with:

• SD card readers
• RF modules (NRF24L01)
• Ethernet modules (ENC28J60 or W5500)

These pins are fixed for SPI and should not be reassigned.

Practical Example:

SPI (D10–D13) – High-Speed Synchronous Communication

• SD Card Reader (e.g., MicroSD breakout)
  Store sensor data logs (e.g., temperature, humidity) on an SD card using SPI communication for long-term data collection.
• Ethernet Module (e.g., ENC28J60 or W5500)
  Use D10–D13 to connect an Ethernet module to bring your Nano online, serving simple webpages or sending sensor data to cloud services.
• RF Modules (e.g., NRF24L01)
  Establish wireless communication between two Arduinos in an IoT setup using SPI.

Special Function Pins in Arduino Nano Pinout

AREF

You know what threw me off early on? That AREF pin. I didn’t even notice it the first few projects. I just figured the analog readings were close enough. But then I had this temp sensor running at 3.3V, and the values were all over the place. Nothing lined up. Later on, someone told me, “You’re using the wrong reference voltage.” Turns out if you hook that 3.3V to AREF, your analog reads get way more accurate. Since then, anytime I use something that’s not exactly 5V, I double-check that pin.

RESET

Now the RESET pin   that one saved me once. I had this glitchy build where the Nano would freeze on startup like one out of ten times. I got tired of hitting the onboard button, so I ran a jumper to the RESET pin and tied it to a transistor. Now I could reset it with code or a quick pulse. Not elegant, but it worked.

External Interrupt Pins (D2 & D3)
The Nano supports hardware interrupts on D2 (INT0) and D3 (INT1). These are extremely useful in applications where the microcontroller needs to react immediately to a signal change like reading data from an encoder, IR sensor, or counting external pulses. You can trigger them on rising, falling, or change edges using the attachInterrupt() function in Arduino.

ICSP (In-Circuit Serial Programming)

And those six pins in the middle? The ICSP header. Honestly, I ignored them for months. Thought they were extra I/O or something. One day my board just stopped accepting sketches. IDE kept throwing errors. I looked it up and realized I could use those pins to burn the bootloader back on. Took a bit of effort, but I got it working again. Haven’t used that header since, but man glad I knew it existed.

How to Test Your Arduino Nano Pinout (LED blinking Method)

Before I ever use a new Arduino Nano pinout in a real project, I like to make sure it’s actually alive and talking to my computer. Easiest way to do that? Just run the blink test. It’s quick, basic, and tells you right away if the board, USB, and IDE are all working together like they should.

So what I usually do is plug in the Nano using one of those old-school Mini-B cables. Yeah, not micro-USB. Mini. Once it’s connected, I check the Arduino IDE settings. You have to pick the right board under Tools > Board   just choose “Arduino Nano”. Sometimes the upload fails with the regular bootloader, so I switch to ATmega328P (Old Bootloader) under Processor. And yeah, don’t forget the COM port   if you see more than one, it’s usually the one that shows up when you plug the board in.

Once that’s all good, I go to File > Examples > 01.Basics > Blink. That’ll open the sketch that makes the onboard LED (pin 13) flash on and off. It’s dead simple. You can even glance at the code:

Code :

void setup() {

  pinMode(13, OUTPUT); // Set digital pin 13 as an output

}

void loop() {

  digitalWrite(13, HIGH); // Turn the LED on

  delay(1000);            // Wait for 1 second

  digitalWrite(13, LOW);  // Turn the LED off

  delay(1000);            // Wait for 1 second

}

Then I hit Upload the right arrow icon in the IDE. You’ll probably see the RX and TX LEDs blink on the board during upload. If all’s good, the onboard LED starts blinking: one second on, one second off, looping endlessly.

Why do this at all? Well, if the LED blinks, it means a bunch of stuff is working:

• The board is alive
• USB communication is fine
• The bootloader’s intact
• Code is uploading
• And pin D13 isn’t fried

Basically, it’s the best low-effort check before you dive into wiring up sensors or motors. I always do this first   saves time later if something’s off.

Why This Version Works:

D0 and D1? If you’re using Serial Monitor, just don’t mess with them. I made that mistake once, and uploads kept failing. Took forever to figure out it was just a dumb conflict.

Wiring-wise, I’ve started keeping I2C and SPI stuff separate not because it’s required, but it helps a lot when things get tight on the breadboard. Less chance of crossing wires or pulling the wrong jumper mid-test.

Best Practices for Using Arduino Nano Pinout

One thing I’ve also started doing: labeling pins. Not just in code, but sometimes I stick tape near the wires or jot down a quick pin map on paper. Saves you when something stops working and you’ve already forgotten what’s plugged into where.

Oh and for inputs like buttons, always use INPUT_PULLUP. Floating pins cause the weirdest behavior, especially when everything seems fine but the input just flips randomly.

And yeah, don’t overload pins. I’ve done that too ran too much current through one and it never worked again. Now I keep everything under 40 mA, just in case.

Safe Current Limits for Arduino Nano Pins:

Each I/O pin on the Nano can safely source or sink up to 40 mA max, but ideally you should stay under 20–25 mA per pin for long-term use. The total current across all pins should not exceed 200 mA. Going beyond these limits can permanently damage the microcontroller.

Final Thoughts

Getting to know the Arduino Nano’s pinout is probably the first real step toward building anything with it. Each pin has its own job some give power, others handle input or communication and using them properly can save you from a lot of headaches later.

For power, you’ve got VIN for external voltage, 5V and 3.3V outputs for other parts, and of course GND. AREF helps with analog accuracy (if you need it), and RESET is there if the board locks up.

In the Arduino Nano Pinout, the Digital pins D0–D13 are for simple things like turning LEDs on or reading switches. Some of them (like D3, D5, D6, etc.) also support PWM, which is great for fading lights or controlling motors.

The analog pins (A0–A7) are perfect for sensors that send varying signals like a temperature sensor or a light sensor.

As for communication, the Nano handles serial on D0 and D1, I2C on A4 and A5, and SPI on D10 through D13. Once you get used to what each of these pins does, working with the Nano becomes way easier and a lot more fun.

Frequently Asked Questions (FAQ)

Q1: My Arduino Nano isn’t uploading code. What should I do?

Check if you’re using the correct board and processor in the Arduino IDE. Go to Tools > Board and select “Arduino Nano”, then under Tools > Processor, try “ATmega328P (Old Bootloader)” if the upload fails.

Q2: Can I power the Nano with a 3.7V battery directly?

Not safely. It’s better to power the Nano through the VIN pin using a 7–12V source, or use a regulated 5V supplied directly to the 5V pin (only if you know it’s safe and steady).

Q3: What happens if I exceed 40 mA on a pin?

Exceeding the recommended current can permanently damage the microcontroller. Always use current-limiting resistors, and for higher loads, control them through transistors or MOSFETs because it driving directly from the pin.

Q4: Why is my analog sensor reading unstable?

Unstable readings often come from using an incorrect or noisy reference voltage. Make sure to connect a stable voltage to the AREF pin because your sensor operates below 5V. Also, ensure good wiring and consider averaging multiple readings in your code.

Q5: What’s the safest way to reset the Nano remotely?

Use the RESET pin. Connect it to a push button or transistor that pulls the pin LOW briefly. This will reset the microcontroller just like the onboard reset button.