1) What you bought and why it’s useful

The Arduino Nano V3 (CH340) is essentially “UNO-class” capability in a smaller, breadboard-friendly format. It is popular when you need:

• Compact builds (robot cars, sensor nodes, small enclosures)
• Breadboard prototyping without jumpers spanning a large UNO footprint
• Low cost + familiar Arduino ecosystem (IDE, libraries, examples)

Leobot’s product listing highlights the Nano’s compactness, ATmega328 basis, 16 MHz clock, 32 KB flash (2 KB bootloader), 14 digital I/O (6 PWM), and 8 analog inputs.

2) Core specifications (what matters in projects)

Key specs you should design around:

• MCU: ATmega328P
• Clock: 16 MHz
• Flash: 32 KB (with 2 KB used by bootloader)
• SRAM: 2 KB (important for memory-heavy sensor/display projects)
• Analog inputs: 8 (A0–A7)
• Digital I/O: 14 (D2–D13 listed on the product page), with 6 PWM pins
• External power: supports external DC supply (product page lists 5–12V support)

3) CH340 driver and IDE setup (Windows/macOS/Linux)

3.1 Install the CH340 driver if needed

If the Nano does not appear as a COM port (or upload fails with COM/driver errors), you may need the CH340 driver. Leobot provides a CH340 driver download and explicitly notes it can help when Windows cannot connect through the IDE.

3.2 Install/update the Arduino AVR Boards platform

If you have upload problems, Leobot’s guidance is to update “Arduino AVR Boards” via Tools ? Board ? Boards Manager.

3.3 The “Old Bootloader” setting (common Nano clone fix)

If uploads still fail, Leobot recommends trying Tools ? Processor ? “ATmega328P (Old Bootloader)”.

4) First upload checklist (avoid common mistakes)

1. Connect Nano via USB (data-capable cable, not “charge-only”).
2. In Arduino IDE: select Tools ? Board ? Arduino Nano.
3. Select Tools ? Port and choose the COM port that appears when you plug in the Nano.
4. If upload fails: install CH340 driver and retry.
5. If upload still fails: update “Arduino AVR Boards” and try “Old Bootloader”.

5) Pinout essentials: PWM, ADC, UART, I2C, SPI

The product page highlights the core usable I/O set: digital I/O D2–D13, analog A0–A7, RX/TX UART, and PWM on D3, D5, D6, D9, D10, D11.

5.1 PWM pins (for dimming, motor speed, servo signals)

• PWM capable: D3, D5, D6, D9, D10, D11
• Use cases: LED dimming, DC motor speed (through a driver), buzzer tones, simple analog-ish outputs

5.2 Analog inputs (A0–A7)

• Range: reads analog voltages relative to the ADC reference
• Use cases: potentiometers, light sensors, thermistors, joystick axes, analog pressure sensors

5.3 UART serial (RX/TX)

The Nano provides TTL serial RX/TX, useful for GPS modules, Bluetooth serial modules, and debugging.

5.4 I2C and SPI

The ATmega328P supports standard embedded interfaces (I2C/TWI and SPI), which are commonly used for OLED displays, RTC modules, sensors, SD cards, and radio modules. The official Arduino Nano documentation confirms UART, I2C (TWI), and SPI support.

6) Powering the Nano safely: USB vs VIN vs 5V pin

6.1 USB power (simplest for prototypes)

USB provides stable 5V and easy programming. Use this for bench testing and low-power sensor builds.

6.2 VIN / external DC input (for standalone projects)

The product page explicitly states support for an external 5V…12V DC power supply and mentions 9V battery use. The official Arduino Nano spec recommends an input range around 7–12V for VIN.

6.3 Powering sensors and modules

• 5V sensors/modules: can often be powered from Nano 5V for small loads.
• Motors/relays/LED strips: should be powered from their own supply; share GND with the Nano.

7) Breadboard patterns (clean wiring in tight spaces)

• Place the Nano straddling the breadboard center trench (classic layout) so each pin row lands on separate rails.
• Use short jumpers and label rails (5V, GND, signal).
• Put a 0.1 µF decoupling capacitor near noisy sensors and modules.
• For long wires (to external sensors), add series resistors (e.g., 100–330O) on data lines when appropriate to reduce ringing.

8) Starter examples: Blink, Button, Analog, PWM

8.1 Blink (sanity check)

/*
  Nano Blink
  If your Nano has a built-in LED, it's usually on D13.
*/

void setup() {
  pinMode(13, OUTPUT);
}

void loop() {
  digitalWrite(13, HIGH);
  delay(300);
  digitalWrite(13, LOW);
  delay(300);
}
    

8.2 Button + LED (proper pull-up)

/*
  Button on D2 to GND, LED on D9 (PWM-capable)
*/
const int PIN_BTN = 2;
const int PIN_LED = 9;

void setup() {
  pinMode(PIN_BTN, INPUT_PULLUP);
  pinMode(PIN_LED, OUTPUT);
}

void loop() {
  bool pressed = (digitalRead(PIN_BTN) == LOW);
  digitalWrite(PIN_LED, pressed ? HIGH : LOW);
}
    

8.3 Analog read + PWM dimming

/*
  Potentiometer wiper to A0, ends to 5V and GND.
  PWM LED on D5 through a resistor.
*/
const int PIN_POT = A0;
const int PIN_PWM = 5;

void setup() {
  pinMode(PIN_PWM, OUTPUT);
  Serial.begin(115200);
}

void loop() {
  int v = analogRead(PIN_POT);          // 0..1023
  int pwm = map(v, 0, 1023, 0, 255);    // 0..255
  analogWrite(PIN_PWM, pwm);

  Serial.println(v);
  delay(20);
}
    

9) Project patterns: sensors, relays, servos, displays, comms

9.1 I2C sensor + OLED display (clean wiring, minimal pins)

I2C lets you run multiple devices over two wires (SDA/SCL). This is ideal on a Nano where pin budget is limited. The official Arduino Nano documentation confirms I2C (TWI) support.

9.2 Servo control (single pin, but needs stable power)

• Servo signal: one PWM-capable digital pin (e.g., D9)
• Servo power: external 5V supply recommended; share GND with Nano

9.3 Relay / solenoid control (always via a driver)

• Use a transistor/MOSFET driver or a relay module with proper input stage
• Use flyback diodes for inductive loads (solenoids, relays without built-in protection)
• Keep high-voltage wiring physically separated

9.4 Serial modules (Bluetooth serial, GPS)

The Nano provides RX/TX TTL serial. When using modules that also rely on serial, consider SoftwareSerial (with limitations) or structure your debug logs so uploads and runtime logging don’t conflict.

9.5 “Nano as the brain” + external power domain

A common robust architecture:

• One regulated 5V rail for Nano + sensors (low noise)
• Separate rail for motors/LED strips/heaters
• Common ground reference between domains
• MOSFET/driver stage between Nano pins and high-current loads

10) Troubleshooting uploads and stability issues

10.1 Board not showing up in Tools ? Port

• Try another USB cable (many are charge-only).
• Install CH340 driver (Leobot provides a download).
• Try another USB port (avoid unpowered hubs for first setup).

10.2 Upload fails (sync / not in sync / programmer errors)

• Update Arduino AVR Boards in Boards Manager.
• Try Tools ? Processor ? ATmega328P (Old Bootloader).
• Confirm you selected the correct COM port.

10.3 Random resets or unstable sensor readings

• Power issue (voltage sag) is the #1 cause: separate supplies for motors/relays.
• Add decoupling capacitors near sensors and near the Nano 5V/GND pins.
• Reduce wiring length on analog lines; add filtering/averaging in code if needed.

11) Quick checklist (copy/paste)

Arduino Nano V3 (CH340) Checklist
---------------------------------
? Install CH340 driver if the COM port does not appear (Windows often needs it) 
? In Arduino IDE: Tools ? Board ? Arduino Nano
? Select the correct COM port under Tools ? Port
? If upload fails: update "Arduino AVR Boards" in Boards Manager
? If still fails: Tools ? Processor ? ATmega328P (Old Bootloader)
? Use USB power for prototyping; use external power carefully for standalone builds
? Do not power motors/relays from the Nano 5V pin; use a separate supply + driver, share GND
? Watch SRAM usage (2 KB): keep libraries/strings lean if you see random crashes