Pinagem do Arduino Nano: diagrama de pinos, A6/A7, alimentação e Old Bootloader

A pinagem do Arduino Nano é formada por 30 pinos enfileirados nas duas bordas longas de uma placa de 45 × 18 mm: 14 pinos digitais de entrada/saída (D0–D13), 6 dos quais podem gerar PWM (~3, 5, 6, 9, 10, 11), 8 entradas analógicas (A0–A7) e os pinos de alimentação e controle: VIN, 5V, 3V3, AREF, dois GND e dois RST. Como o Nano usa o mesmo processador ATmega328P do Arduino Uno, os números e as funções dos pinos também são os mesmos: um sketch escrito para o Uno roda sem nenhuma mudança, além de selecionar o Nano no menu de placas.

Ainda assim, alguns detalhes importantes diferenciam o Nano do Uno, e é justamente neles que os iniciantes empacam: A6 e A7 são só analógicos, não há conector DC, o pino 3V3 fornece pouquíssima corrente, as placas clone cuidam da USB com um chip CH340 e muitas vezes é preciso selecionar ATmega328P (Old Bootloader) para carregar o código. Neste guia você vai conhecer cada pino, aprender a colocar o Nano corretamente na protoboard, ver o mapeamento de pinos do Uno para o Nano e descobrir como o Nano Every e o Nano ESP32 se diferenciam do Nano clássico.

O que é o Arduino Nano e como ele se diferencia do Uno?

O Arduino Nano reúne todos os recursos principais do Uno em uma placa de 45 × 18 mm que pesa cerca de 7 gramas. Os pinos dele apontam para baixo, então ele encaixa direto na protoboard; isso significa menos jumpers e, quando o circuito fica pronto, ele vai fácil para dentro de uma caixa ou de uma placa de circuito permanente. Dentro dele está o mesmo ATmega328P de 16 MHz do Uno, o nível lógico é de 5 V e as mesmas bibliotecas funcionam sem mudanças. No Nano original, a comunicação USB-serial é feita por um chip FT232RL; quase todos os clones baratos do mercado têm, no lugar dele, um CH340G ou CH340C embaixo da placa. Para carrinhos robô, vestíveis, controles remotos e qualquer circuito que precise caber em uma caixa, o Nano é uma escolha mais prática que o Uno.

Diagrama de pinos do Arduino Nano: qual pino fica onde?

Os 30 pinos do Nano ficam em duas fileiras frente a frente de 15, e as fileiras estão a 15,24 mm (0,6 polegada) uma da outra. Coloque a placa à sua frente com o conector mini USB mais perto de você e você verá dois pinos frente a frente logo ao lado do conector: D12 e D13. A fileira do D13 tem 3V3, AREF, A0–A7 e os pinos de alimentação; a fileira do D12 tem os pinos digitais do D11 ao D2, seguidos de GND, RST, RX0 (D0) e TX1 (D1). Na ponta das duas fileiras mais longe da USB, VIN e TX1 ficam frente a frente, e a barra ICSP 2×3 também fica nessa ponta. Em volta do botão de reset, no meio, você encontra o LED de alimentação (POW ou ON), o LED L ligado ao D13 e os LEDs TX e RX, que piscam durante o carregamento.

Pinos digitais (D0–D13), PWM e funções especiais

Cada pino digital é configurado como entrada ou saída com pinMode(); como saída, HIGH dá cerca de 5 V e LOW dá 0 V. Para não deixar uma entrada flutuando, você pode ligar o resistor interno de 20–50 kΩ do chip com INPUT_PULLUP. A corrente segura por pino é de 20 mA; um LED vermelho com resistor de 220 Ω puxa cerca de 13 mA, e você encontra o resistor certo com a calculadora de resistor para LED. Alguns pinos têm funções extras, e conhecê-las antes evita conflitos quando o seu projeto crescer:

Um detalhe pequeno, mas importante, que diferencia o Nano do Uno está no D13. No Uno R3, o LED L é acionado por um amplificador operacional, enquanto no Nano o LED e o resistor dele ficam ligados direto ao pino. Se você usar o D13 como entrada de botão com INPUT_PULLUP, o LED puxa o pino para baixo e você pode ler LOW mesmo com o botão solto; reserve esse pino para saídas ou SPI. Você encontra como o PWM funciona e o que significam os valores do analogWrite() em O que é PWM?, e as interrupções em interrupções no Arduino.

Pinos analógicos A0–A7: por que A6 e A7 são diferentes?

As oito entradas analógicas do Nano medem tensões entre 0 e 5 V com resolução de 10 bits: o analogRead() retorna um número de 0 a 1023, e um passo vale cerca de 4,9 mV. Quando necessário, A0–A5 também funcionam como pinos digitais comuns (A0 = 14 … A5 = 19), e A4 e A5 servem ainda como as linhas SDA e SCL do barramento I2C. A6 e A7, que o Uno não tem, são dois canais extras do ADC presentes no encapsulamento de montagem em superfície (TQFP) do ATmega328P. Esses dois canais estão ligados só ao conversor analógico-digital; não há registrador de porta, driver de saída nem resistor de pull-up por trás deles. Por isso pinMode(), digitalRead(), digitalWrite() e INPUT_PULLUP não funcionam nesses dois pinos.

A6 e A7 serem só analógicos pode parecer uma desvantagem, mas dá para usar isso de forma esperta. Se você ligar vários botões a um pino analógico por meio de resistores de valores diferentes, cada botão gera uma tensão diferente; assim você lê quatro botões com um só pino e deixa os pinos digitais livres para motores e displays. No circuito, ligue o A6 ao 5V por um resistor de 10 kΩ; ligue o primeiro botão direto entre o A6 e o GND, e os outros três botões ao GND por resistores de 2,2 kΩ, 4,7 kΩ e 10 kΩ, respectivamente.

1// A6'da 4 buton: 10 kΩ pull-up + farklı seri dirençler / 4 buttons on A6: 10 kΩ pull-up + different series resistors
2const byte LADDER_PIN = A6;    // yalnız analog pin / analog-only pin
3
4byte readButton() {
5  int v = analogRead(LADDER_PIN);
6  if (v < 92)  return 1;       // 0 Ω      -> yaklaşık 0 / about 0
7  if (v < 256) return 2;       // 2,2 kΩ   -> yaklaşık 184 / about 184
8  if (v < 419) return 3;       // 4,7 kΩ   -> yaklaşık 327 / about 327
9  if (v < 767) return 4;       // 10 kΩ    -> yaklaşık 512 / about 512
10  return 0;                    // basılı değil -> 1023 / not pressed -> 1023
11}
12
13void setup() {
14  Serial.begin(9600);
15}
16
17void loop() {
18  static byte lastButton = 0;
19  byte b = readButton();
20  if (b != lastButton) {
21    delay(20);                 // kontak sıçramasını bekle / wait out contact bounce
22    b = readButton();          // değeri doğrula / confirm the value
23    if (b != lastButton) {
24      lastButton = b;
25      if (b != 0) {
26        Serial.print(F("Buton / Button: "));
27        Serial.println(b);
28      }
29    }
30  }
31}

Os valores vêm da fórmula analogRead = 1023 × R / (10 kΩ + R), e cada limite fica exatamente no meio entre dois valores vizinhos. Como o resistor de pull-up e o ADC são alimentados pelo mesmo barramento de 5 V, as leituras não mudam mesmo que a alimentação caia para 4,7 V; isso se chama medição raciométrica. Se dois botões forem apertados ao mesmo tempo, os resistores deles ficam em paralelo e a leitura cai: o código vê um botão de número menor, e apertar o 3 e o 4 juntos chega a ser lido como 2. Por isso, uma escada de resistores combina com menus em que só uma tecla é apertada por vez. Você pode testar as contas do divisor com a calculadora de divisor de tensão e ler mais sobre leituras analógicas no artigo sobre ADC.

Pinos de alimentação: VIN, 5V, 3V3 e GND

Você pode alimentar o Nano de três jeitos. Pela USB, os 5 V vêm do computador através de um diodo Schottky; o diodo tem queda de cerca de 0,3 V, então normalmente você mede 4,6–4,8 V no pino 5V, e o diodo MBR0520 da placa original aguenta no máximo 500 mA. Se você colocar 7–12 V no pino VIN, o regulador embaixo da placa (um LM1117 no original, normalmente um AMS1117 nos clones) reduz para 5 V. O regulador transforma o excesso de tensão em calor: a potência que ele dissipa é (VIN − 5 V) × corrente, então puxar 150 mA de uma entrada de 12 V faz o pequeno regulador queimar cerca de 1 W e ficar quente demais para tocar. Por isso 7–9 V é o ideal para o VIN. O terceiro jeito é colocar 5 V regulados de fora no pino 5V; aí o regulador fica de fora, e o diodo do lado da USB impede que a corrente volte para o seu computador. Se você está usando uma fonte de 12 V, usar um conversor buck LM2596 para gerar 5 V e colocá-los no pino 5V é uma solução muito mais fria; todas as opções de alimentação estão em Como alimentar um Arduino.

O pino 3V3 é o pino mais mal compreendido do Nano. No Uno, esse pino vem de um regulador separado, mas o Nano clássico não tem regulador de 3,3 V separado. No Nano original, os 3,3 V vêm de um pequeno regulador dentro do chip FT232RL (no máximo 50 mA) e, segundo a documentação antiga do Arduino, essa saída não fica disponível quando a placa não está alimentada pela USB. Na maioria dos clones, o pino está ligado ao regulador interno do próprio CH340 e só é seguro para cargas de alguns mA. Então não alimente módulos de 3,3 V como o nRF24L01, o ESP-01 ou o RC522 por esse pino; use um regulador AMS1117-3.3 separado, alimentado pelo pino 5V. E, ao ligar uma saída de 5 V do Nano à entrada de um módulo de 3,3 V, coloque no meio um conversor de nível lógico ou um divisor de tensão.

O pino 5V ficar em torno de 4,7 V na USB também afeta as medições analógicas: o analogRead() usa a tensão de alimentação como limite superior, então, se você colocar 5,0 V no cálculo, o resultado erra em 4–6 por cento. Você pode descobrir a tensão de alimentação real medindo a referência fixa interna de cerca de 1,1 V do ATmega328P. O primeiro sketch de teste abaixo faz exatamente isso, converte as oito entradas analógicas em volts usando a tensão de alimentação real e pisca o LED L do D13:

1// Arduino Nano: A0-A7'yi ve gerçek besleme gerilimini oku / read A0-A7 and the real supply voltage
2const byte ANALOG_PINS[8] = {A0, A1, A2, A3, A4, A5, A6, A7};
3
4long readVccMillivolts() {
5  // Referans AVcc, ölçülen kanal dahili 1,1 V / reference AVcc, measured channel internal 1.1 V
6  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
7  delay(2);                                // referansın oturmasını bekle / let the reference settle
8  ADCSRA |= _BV(ADSC);                     // dönüşümü başlat / start the conversion
9  while (bit_is_set(ADCSRA, ADSC)) {}      // bitmesini bekle / wait until it finishes
10  unsigned int raw = ADC;                  // 10 bit sonuç / 10-bit result
11  return 1125300L / raw;                   // 1,1 V x 1023 x 1000 / 1.1 V x 1023 x 1000
12}
13
14void setup() {
15  Serial.begin(9600);
16  pinMode(LED_BUILTIN, OUTPUT);            // D13'teki L LED'i / L LED on D13
17}
18
19void loop() {
20  long vcc = readVccMillivolts();
21  analogRead(A0);                          // kanal değişti, ilk okumayı at / channel changed, discard the first reading
22  Serial.print(F("Vcc: "));
23  Serial.print(vcc);
24  Serial.print(F(" mV |"));
25  for (byte i = 0; i < 8; i++) {
26    int raw = analogRead(ANALOG_PINS[i]);  // A6 ve A7 de okunur / A6 and A7 are read too
27    Serial.print(F(" A"));
28    Serial.print(i);
29    Serial.print(F("="));
30    Serial.print(raw * (vcc / 1000.0) / 1023.0, 2);   // gerçek Vcc ile volta çevir / convert to volts using the real Vcc
31  }
32  Serial.println();
33  digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));   // L LED'ini çevir / toggle the L LED
34  delay(1000);
35}

Depois de carregar, abra o Monitor Serial em 9600 baud. O valor de Vcc deve ficar em torno de 4600–4800 mV na USB e em torno de 5000 mV quando alimentado pelo VIN. Pinos analógicos desconectados mostram valores aleatórios; se você ligar um potenciômetro no A0 e girá-lo, verá o valor mudar suavemente entre 0 e Vcc. A referência interna pode variar ±10% de um chip para outro; para um resultado mais preciso, meça o pino 5V com um multímetro e multiplique a constante 1125300 do código pela razão seu valor medido / o valor que o código mostra. Como este sketch usa diretamente registradores do ATmega328P, ele não funciona no Nano Every nem no Nano ESP32.

Mini USB, CH340 e instalação do driver

O Nano clássico tem um conector USB Mini-B; os cabos Micro-USB ou USB-C usados em celulares não encaixam nele. Alguns clones mais novos têm conectores Micro-USB ou USB-C, mas a maioria ainda é mini USB. O motivo mais comum de a placa nem aparecer na lista de portas é um cabo só de carga, sem os fios de dados: o LED de alimentação acende, mas o computador não vê a placa. Se o cabo estiver bom, vire a placa e olhe o chip perto do conector USB. Se estiver escrito FT232RL, você tem um Nano original e o driver dele normalmente já está no sistema operacional; se estiver escrito CH340G ou CH340C, você tem um clone.

O Windows 10 e o 11 muitas vezes instalam sozinhos o driver do CH340 pelo Windows Update, e a placa aparece no Gerenciador de Dispositivos com um nome como USB-SERIAL CH340 (COM3). Se aparecer um USB2.0-Serial com um ponto de exclamação amarelo em Outros dispositivos, instale o driver CH341SER da WCH, a fabricante do chip, depois desconecte a placa e conecte de novo. As versões atuais do macOS já trazem o driver; a porta aparece como /dev/cu.usbserial-…, e instalar drivers antigos por cima pode causar conflitos. No Linux, o driver já vem no kernel; se a porta sumir assim que você conecta a placa no Ubuntu 22.04 ou posterior, o pacote de leitor de tela brltty está tomando o CH340 e, se você não o usa, pode removê-lo com sudo apt remove brltty. Todos os problemas de porta e de driver estão em Arduino não carrega o código, e as diferenças entre chips USB-serial em conversores USB-TTL.

Carregando o código: ATmega328P ou Old Bootloader?

1. No Arduino IDE, selecione Ferramentas > Placa > Arduino AVR Boards > Arduino Nano.
2. Conecte a placa e escolha a porta que acabou de aparecer em Ferramentas > Porta (como COM3 no Windows ou /dev/cu.usbserial-… no macOS).
3. Em Ferramentas > Processador, tente primeiro carregar o exemplo Blink com a opção ATmega328P.
4. Se a saída repetir programmer is not responding ou not in sync por dez tentativas, coloque o Processador em ATmega328P (Old Bootloader) e carregue de novo.
5. Se ainda falhar, tente outra porta USB, tire qualquer fio do D0 e do D1 e confira se o LED L pisca rápido quando você aperta o botão de reset.
6. Anote qual opção funcionou; outros Nanos do mesmo vendedor provavelmente vão precisar da mesma configuração.

O motivo dessa confusão é uma mudança feita em 2018. O Arduino trocou o antigo bootloader de 2 KB do Nano (ATmegaBOOT) pelo Optiboot de 512 bytes usado no Uno. O Optiboot recebe o código a 115200 baud, enquanto o bootloader antigo espera 57600 baud; quando as velocidades não batem, a placa parece não responder de jeito nenhum. Como os fabricantes de clones continuaram enviando placas com o bootloader antigo por anos, o IDE oferece as duas opções, e escolher a errada não faz mal nenhum à placa. Se quiser, você pode usar um segundo Arduino como ArduinoISP para gravar o bootloader novo no Nano: os carregamentos ficam mais rápidos e o loop infinito de reset do bootloader antigo depois de um reset do watchdog também desaparece.

Colocação na protoboard e solda

Quando encaixar o Nano em uma protoboard, coloque-o de modo que as duas fileiras de pinos fiquem uma de cada lado do canal central. Assim, cada pino cai em uma tira própria, e você pode ligar fios a esse pino pelos furos livres da tira. Como a placa cobre o canal e os furos entre os pinos, sobram só alguns furos ao lado de cada pino; nas protoboards comuns de 830 pontos, se você centralizar a placa sobre o canal, ficam 2 furos livres de um lado e 3 do outro. Virar o conector USB para a borda curta da protoboard facilita encaixar o cabo. Depois, ligue os pinos 5V e GND do Nano aos barramentos de alimentação vermelho e azul da protoboard para alimentar os sensores por ali. Para relembrar como a protoboard é ligada por dentro, veja O que é uma protoboard?.

• Soldando as barras de pinos: nos clones que vêm com os pinos soltos, encaixe primeiro as barras macho na protoboard, apoie o Nano por cima e solde assim; a protoboard mantém as barras retas e a exatamente 0,6 polegada uma da outra. A técnica está em Como soldar.
• Para tirar: levantar a placa por uma ponta entorta os pinos; levante as duas pontas um pouco de cada vez, ou passe uma chave de fenda plana por baixo e puxe por igual.
• Mau contato: em protoboards velhas ou baratas, as molas se desgastam; o Nano reinicia de vez em quando ou um sensor some de vez em quando. Tente mudar a placa para outra área da protoboard.
• Placa de expansão para Nano: em um projeto permanente, um shield de E/S para Nano com bornes de parafuso ou barras de 3 pinos que dão sinal, 5V e GND para cada pino reduz muito a bagunça de fios.
• Mini protoboard: as protoboards pequenas de 170 pontos não têm barramentos de alimentação; leve o 5V e o GND para tiras separadas e marque-as com as cores dos fios.

Tabela de mapeamento de pinos do Arduino Uno para o Nano

Como mostra a tabela, levar para o Nano um circuito montado para o Uno só exige ligar os fios nos pinos com os mesmos números: um servo no D9 do Uno vai no D9 do Nano, e um display I2C em A4/A5 continua indo em A4/A5. A única mudança no código é selecionar Arduino Nano em Ferramentas > Placa. Já os shields que encaixam direto no Uno não servem no Nano; para isso, existem placas adaptadoras que convertem o Nano para a disposição de pinos do Uno. Você encontra o papel detalhado de cada pino do Uno em pinagem do Arduino Uno e ajuda para escolher uma placa em Qual Arduino comprar?.

Nano Every e Nano ESP32: como se diferenciam do Nano clássico

O Nano Every é uma versão mais potente do Nano clássico, com o mesmo tamanho e a mesma disposição de pinos. Ele tem um ATmega4809 dentro, funciona em 5 V e oferece 48 KB de flash e 6 KB de SRAM, então projetos com OLED e fita de LED que sofrem com a RAM do Nano clássico ganham um respiro. No lado da USB, um chip SAMD11 faz a ponte e o código é carregado pela interface UPDI, então não há a dor de cabeça do Old Bootloader. Para usar a placa, instale o pacote Arduino megaAVR Boards pelo Gerenciador de Placas. As diferenças a observar: o PWM só existe em D3, D5, D6, D9 e D10 (o D11 não tem PWM), A6 e A7 também funcionam como pinos digitais, todo pino digital pode ser usado como interrupção externa, e D0 e D1 são uma porta Serial1 independente da USB. A opção Ferramentas > Registers emulation > ATMEGA328 emula registradores de porta como o PORTB, mas código antigo que escreve diretamente em registradores de timer ou de ADC continua sem funcionar. O sketch abaixo mostra juntas duas diferenças do Every: ele conversa com um módulo em D0/D1 enquanto o Monitor Serial está aberto e usa o A7 como entrada de botão com o pull-up interno.

1// Nano Every: Serial = USB, Serial1 = D0 (RX) ve D1 (TX) / Serial = USB, Serial1 = D0 (RX) and D1 (TX)
2const byte BUTTON_PIN = A7;            // Every'de A7 dijital de çalışır / A7 also works as digital on the Every
3
4bool lastState = HIGH;
5
6void setup() {
7  Serial.begin(9600);                  // Seri Monitör / Serial Monitor
8  Serial1.begin(9600);                 // D0/D1'deki modül, ör. HC-05 / module on D0/D1, e.g. HC-05
9  pinMode(BUTTON_PIN, INPUT_PULLUP);   // klasik Nano'nun A7'sinde çalışmaz / does not work on the classic Nano's A7
10}
11
12void loop() {
13  if (Serial1.available()) {
14    Serial.write(Serial1.read());      // modülden bilgisayara / module to computer
15  }
16  if (Serial.available()) {
17    Serial1.write(Serial.read());      // bilgisayardan modüle / computer to module
18  }
19  bool state = digitalRead(BUTTON_PIN);
20  if (state != lastState) {            // durum değişince bildir / report when the state changes
21    lastState = state;
22    Serial1.println(state == LOW ? "Buton basildi / Button pressed" : "Buton birakildi / Button released");
23    delay(20);                         // kontak sıçraması / contact bounce
24  }
25}

O Nano ESP32, por outro lado, é um mundo completamente diferente no mesmo tamanho de placa: o processador ESP32-S3 do módulo u-blox NORA-W106 funciona a 240 MHz e oferece Wi-Fi e Bluetooth LE. A diferença mais importante é a tensão: todos os pinos trabalham em 3,3 V e não toleram 5 V, então um sensor com saída de 5 V que você ligaria direto em um Nano clássico pode danificar o Nano ESP32. Onde o Nano clássico tem o pino 5V, há um pino VBUS, que só fornece 5 V enquanto a placa está alimentada pela USB; alimentada pelo VIN, esse pino fica morto. No lugar do AREF e do pino RST do lado analógico, você encontra BOOT0 e BOOT1. A placa é programada com o pacote Arduino ESP32 Boards, e o menu Ferramentas > Pin Numbering tem duas opções: na configuração padrão By Arduino pin, valem os nomes D e A impressos na placa, enquanto em By GPIO number os números são os números de GPIO do ESP32. Por exemplo, o D2 na verdade é o GPIO5; no modo GPIO, escrever pinMode(2, OUTPUT) configura o pino A1. Se você sempre escrever os pinos pelo nome, como D2 e A0, o seu código funciona corretamente nos dois modos.

1// Nano ESP32: Araçlar > Pin Numbering > By Arduino pin (default)
2// Nano ESP32: Tools > Pin Numbering > By Arduino pin (default)
3bool ledOn = false;
4
5void setup() {
6  Serial.begin(115200);                // USB-C üzerinden / over USB-C
7  pinMode(LED_BUILTIN, OUTPUT);        // D13 = GPIO48
8  pinMode(LED_RED, OUTPUT);
9  pinMode(LED_GREEN, OUTPUT);
10  pinMode(LED_BLUE, OUTPUT);
11  digitalWrite(LED_RED, HIGH);         // RGB LED ters mantık: HIGH = sönük / active low: HIGH = off
12  digitalWrite(LED_GREEN, HIGH);
13  digitalWrite(LED_BLUE, HIGH);
14  analogReadResolution(12);            // 0-4095 arası / range 0-4095
15}
16
17void loop() {
18  int raw = analogRead(A0);            // 12 bit ham değer / 12-bit raw value
19  int mv = analogReadMilliVolts(A0);   // kalibre edilmiş milivolt / calibrated millivolts
20  Serial.printf("A0: %d  (%d mV)\n", raw, mv);
21  digitalWrite(LED_GREEN, mv > 1650 ? LOW : HIGH);   // 1,65 V üstünde yeşil / green above 1.65 V
22  digitalWrite(LED_RED, mv > 1650 ? HIGH : LOW);     // altında kırmızı / red below
23  ledOn = !ledOn;
24  digitalWrite(LED_BUILTIN, ledOn ? HIGH : LOW);     // D13 LED'ini yakıp söndür / blink the D13 LED
25  delay(500);
26}

As entradas analógicas do Nano ESP32 fazem leituras de 12 bits e retornam valores de 0 a 4095, enquanto o analogReadMilliVolts() usa os dados de calibração do chip para dar o resultado direto em milivolts. O LED RGB da placa funciona com lógica invertida, então acende quando você escreve LOW. Se o código não carregar e a placa sumir da lista de portas, você pode colocá-la no modo bootloader apertando o botão de reset duas vezes seguidas, rápido. Para conhecer o lado Wi-Fi do ESP32, veja O que é o ESP32? e, para decidir por uma placa, leia Arduino ou ESP32?. Entre os outros membros da família, o Nano R4 traz o mesmo processador Renesas RA4M1 de 48 MHz do Uno R4 para o formato Nano de 5 V, mas fornece só 8 mA por pino, enquanto o Nano 33 IoT e o Nano 33 BLE são placas de 3,3 V como o Nano ESP32.

Ideias de projetos com Arduino Nano

• Termômetro de bolso: mostre a temperatura medida com um DHT11 em um pequeno display OLED de 0,96 polegada; o Nano e o display cabem em uma caixa de fósforos.
• Mini carrinho robô: o tamanho pequeno do Nano economiza espaço no chassi; acione os motores com um L298N e siga os passos de Como fazer um carrinho robô.
• Robô seguidor de linha: oito entradas analógicas são mais que suficientes para ler uma barra de cinco sensores; os detalhes estão em Robô seguidor de linha.
• Controle por Bluetooth: ligue um módulo HC-05 no D8 e no D7 com SoftwareSerial e controle um LED ou um relé pelo celular; D0 e D1 ficam livres para carregar o código.
• Luz vestível: faça uma luz para crachá ou mochila com um Nano alimentado por bateria e alguns LEDs WS2812B.
• Um teclado em um pino: monte a escada de resistores acima tanto no A6 quanto no A7 para um menu de oito botões e guarde os pinos digitais para o display e os motores.
• Quer um teclado USB? O ATmega328P do Nano clássico não tem USB embutida, então não consegue aparecer para um computador como teclado ou mouse; para isso, você precisa de placas com ATmega32U4, como o Leonardo e o Pro Micro.

Erros comuns e como resolvê-los

O Arduino Nano é o jeito mais fácil de levar tudo o que você aprendeu no Uno para projetos pequenos e permanentes; desde que você conheça as diferenças em torno de A6/A7, do 3V3 e do bootloader, não vai haver surpresas. Se quiser voltar ao básico, comece por O que é Arduino?. No app BlueGrays você encontra projetos passo a passo, com esquemas do circuito e código pronto, para piscar um LED, LED com botão, medir luz com LDR, distância com HC-SR04, temperatura e umidade com DHT11, LED RGB, servo com potenciômetro e comunicação serial entre dois Arduinos; todos funcionam no Nano com os mesmos números de pino.