Pinagem do Arduino Uno: pinos digitais, PWM, analógicos e de alimentação explicados

A pinagem do Arduino Uno abrange os 32 pontos de conexão alinhados nas barras fêmea pretas ao longo das duas bordas compridas da placa: 14 pinos digitais de entrada/saída (0–13), 6 dos quais fornecem PWM (~3, 5, 6, 9, 10, 11), 6 entradas analógicas (A0–A5) e os pinos de alimentação, que alimentam a placa ou fornecem energia a outras peças (Vin, 5V, 3.3V, GND, IOREF, AREF, RESET). Cada pino tem uma função principal, mas muitos têm também uma segunda: A4 e A5 também são o barramento I2C, 10–13 formam o barramento SPI, 2 e 3 são pinos de interrupção, e 0 e 1 são a linha serial que conversa com o seu computador.

Escolher o pino certo é a diferença entre um projeto que funciona na primeira tentativa e horas de depuração. Com as tabelas deste artigo você vai entender com facilidade por que o PWM nos pinos 9 e 10 para quando você conecta um servo, por que o seu sketch não carrega enquanto um módulo Bluetooth está ligado ou por que um punhado de LEDs pode sobrecarregar a placa. No final você também encontra um sketch de teste que usa todos os tipos de pino de uma vez, um exemplo de plano de pinos e as diferenças de pinos entre o Uno R3 e o R4.

Diagrama de pinos do Arduino Uno: onde fica cada pino?

Coloque a placa à sua frente com o conector USB e o conector de alimentação à esquerda. As duas barras ao longo da borda de cima têm os pinos digitais; os números aumentam da direita para a esquerda, então o pino mais à direita é o 0 (RX) e o pino digital mais à esquerda é o 13. Na borda de baixo, a barra da esquerda tem os pinos de alimentação e a da direita, as entradas analógicas. O ~ (til) ao lado de um número significa que aquele pino fornece PWM. O grupo 2×3 de pinos macho na borda direita da placa é o conector ICSP.

A grande tabela de pinos: D0–D13 e A0–A5

Como funcionam os pinos digitais (0–13)?

Cada pino digital é definido como entrada ou saída com pinMode(). Como saída, digitalWrite(pin, HIGH) leva o pino a cerca de 5 V e LOW o leva a 0 V. Como entrada, digitalRead() compara a tensão com um limite: com o ATmega328P funcionando em 5 V, qualquer valor acima de 3,0 V é HIGH garantido, abaixo de 1,5 V é LOW garantido, e a faixa entre os dois é indefinida. Por isso a saída de um sensor de 3,3 V normalmente é lida como HIGH no Uno; mas a saída de 5 V do Uno não pode ir direto à entrada de um módulo de 3,3 V, você precisa de um conversor de nível lógico no meio.

Um pino de entrada que não está ligado a nada fica flutuando e lê valores HIGH e LOW aleatórios, mesmo quando você só aproxima a mão. A solução é puxar o pino para um nível fixo com um resistor: pinMode(pin, INPUT_PULLUP) ativa o resistor de 20–50 kΩ dentro do chip, e o botão fica entre o pino e o GND. Os detalhes estão em Como ligar um botão ao Arduino. O pino 13 está ligado ao LED L da placa; em um R3 original esse LED é acionado por um buffer com amplificador operacional, então usar o pino como entrada não dá problema, mas em algumas placas clones o LED e o resistor ficam direto no pino e podem atrapalhar a leitura de botões com o pull-up interno.

Pinos PWM (~3, 5, 6, 9, 10, 11) e timers

O Uno não consegue gerar uma saída analógica de verdade; em vez disso, esses seis pinos fornecem PWM, uma onda quadrada que liga e desliga muito rápido. Com analogWrite(pin, valor) você define quanto tempo a onda fica ligada, de 0 a 255: 0 é totalmente desligado, 127 é mais ou menos a metade e 255 é totalmente ligado. O brilho de LEDs, a velocidade de motores e a velocidade de ventoinhas são controlados assim. Os seis pinos PWM estão ligados aos pares a três timers de hardware, e esse é o motivo dos conflitos com algumas bibliotecas. A ideia do PWM e como calcular o ciclo de trabalho estão explicadas em O que é PWM?.

Pinos analógicos (A0–A5) e AREF

Os pinos analógicos medem uma tensão entre 0 e 5 V com resolução de 10 bits, e analogRead() retorna um número de 0 a 1023. Um passo equivale a cerca de 4,9 mV; para converter o número em volts, use tensão = valor × 5.0 / 1023, então uma leitura de 512 significa cerca de 2,5 V. Os seis pinos compartilham um único ADC, em revezamento, e cada leitura leva cerca de 100 µs, o que permite cerca de 10.000 leituras por segundo. Para resultados precisos, a impedância de saída do sensor não deve passar de 10 kΩ; se for maior, leituras de dois pinos feitas em seguida podem vazar uma na outra, e descartar a primeira leitura e usar a segunda resolve isso. Para medir tensões acima de 5 V, escolha os resistores certos com a calculadora de divisor de tensão.

O pino AREF permite mudar o limite superior da medição analógica. analogReference(DEFAULT) usa 5 V, analogReference(INTERNAL) usa a referência interna de 1,1 V do chip e analogReference(EXTERNAL) usa como topo da faixa a tensão que você aplica no pino AREF (0–5 V). Com um sensor que fornece 0–1 V, a referência de 1,1 V reduz um passo para cerca de 1,1 mV e deixa a medição cerca de 4,5 vezes mais fina. Peças como potenciômetros, LDRs e sensores de umidade do solo se ligam nesses pinos; os detalhes da conversão analógico-digital estão no artigo sobre ADC, e um exemplo prático está no artigo sobre potenciômetro.

Pinos de alimentação: Vin, 5V, 3.3V, GND, IOREF e RESET

O Uno pode ser alimentado de três formas. Pelo USB, a placa recebe 5 V direto do computador, e um fusível rearmável de 500 mA protege a porta do computador. Se você fornecer 7–12 V pelo conector DC ou pelo Vin, o regulador da placa baixa a tensão para 5 V; se os dois estiverem ligados, a placa passa sozinha para a fonte externa quando o Vin sobe acima de cerca de 6,6 V. Como o regulador transforma a tensão extra em calor, puxar algumas centenas de mA do pino 5V com uma entrada de 12 V o esquenta rápido. O mais saudável é alimentar cargas como servos, motores e fitas de LED com uma fonte separada e só unir os GNDs. Para escolher a bateria e calcular a autonomia, use a calculadora de duração da bateria, e leia sobre todos os métodos de alimentação em Como alimentar um Arduino.

Por que os pinos 0 e 1 devem ficar livres?

Os pinos 0 (RX) e 1 (TX) são a única porta serial de hardware do ATmega328P e, na placa, estão ligados através de resistores de 1 kΩ ao chip conversor USB-serial (ATmega16U2). O seu computador usa esses dois pinos ao carregar o código e ao enviar texto para o Monitor Serial. Se a linha TX de um módulo Bluetooth ou qualquer outro sinal estiver ligado ao pino 0, as duas fontes brigam pela mesma linha e o carregamento para com avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x00. Além disso, o pino 1 alterna rapidamente toda vez que Serial.print() é executado, então um LED ou relé ligado ali liga e desliga aleatoriamente.

Por isso, deixe o 0 e o 1 livres até acabarem os outros pinos. Se precisar ligar um módulo serial como um HC-05, um GPS ou um MP3 player, a biblioteca SoftwareSerial cria uma segunda porta serial em outros dois pinos. O sketch abaixo liga o módulo aos pinos 8 (RX) e 7 (TX); ele repassa ao módulo o que você digita no Monitor Serial e ao computador o que o módulo envia. Com módulos de lógica de 3,3 V como o módulo Bluetooth HC-05, ligue a saída TX do Uno (pino 7) ao pino RX do módulo através de um divisor de tensão. Todas as soluções para problemas de carregamento estão em Erro ao carregar código no Arduino, e a lógica da comunicação serial em Comunicação serial UART.

1#include <SoftwareSerial.h>
2
3SoftwareSerial moduleSerial(8, 7);   // RX = 8, TX = 7; 0 ve 1 boş kalır / 0 and 1 stay free
4
5void setup() {
6  Serial.begin(9600);                // USB üzerinden bilgisayar / computer over USB
7  moduleSerial.begin(9600);          // HC-05 veri modu hızı / HC-05 data mode baud rate
8  Serial.println(F("Seri kopru hazir / Serial bridge ready"));
9}
10
11void loop() {
12  if (moduleSerial.available()) {
13    Serial.write(moduleSerial.read());   // modülden bilgisayara / module to computer
14  }
15  if (Serial.available()) {
16    moduleSerial.write(Serial.read());   // bilgisayardan modüle / computer to module
17  }
18}

Pinos de comunicação: I2C (A4/A5), SPI (10–13) e pinos de interrupção (2, 3)

O I2C permite ligar dezenas de dispositivos ao mesmo barramento com só dois fios (SDA e SCL); displays LCD, OLEDs, módulos de relógio RTC e sensores como o BME280 usam esse barramento. No Uno, SDA = A4 e SCL = A5. Nas placas R3, os pinos SDA e SCL ao lado do AREF não são um barramento separado, eles são ligados internamente ao A4 e ao A5, então você não pode usar A4 e A5 para leituras analógicas enquanto o I2C estiver em uso. A biblioteca Wire funciona a 100 kHz por padrão e pode chegar a 400 kHz com Wire.setClock(400000). Endereços, resistores de pull-up e um sketch scanner I2C são explicados em O que é I2C?, e um exemplo prático em Como usar um display LCD I2C.

O SPI é mais rápido, mas precisa de mais fios: MOSI = 11, MISO = 12, SCK = 13 e SS (CS) = 10. Módulos de cartão SD, leitores RFID e displays TFT usam SPI. Vários dispositivos podem compartilhar o barramento: MOSI, MISO e SCK são comuns, e cada dispositivo recebe o seu próprio pino CS. Um detalhe importante: enquanto o SPI está no modo mestre, o pino 10 precisa continuar como saída; se você transformar o pino 10 em entrada e ele for puxado para LOW, o ATmega328P passa sozinho para o modo escravo e o SPI para. MISO, MOSI e SCK também estão no conector ICSP, e alguns shields acessam o SPI por ali. Para os detalhes, veja O que é SPI? e leitor RFID RC522.

Uma interrupção permite captar na hora uma mudança em um pino, não importa o que o loop() esteja fazendo naquele momento. No Uno, as interrupções externas só existem nos pinos 2 (INT0) e 3 (INT1): você escreve attachInterrupt(digitalPinToInterrupt(2), function, FALLING), e o modo de disparo pode ser LOW, CHANGE, RISING ou FALLING. Encoders, sensores de RPM, sensores de fluxo de água e botões que nunca podem ser perdidos vão nesses pinos. Os outros pinos também têm “interrupções por mudança de pino” (PCINT), mas os pinos da mesma porta compartilham uma função de interrupção e o seu código precisa descobrir qual pino mudou. Regras e exemplos estão em Interrupções no Arduino.

Quando você passa para o ESP32 ou o Pico, a maior diferença é a tensão: as duas placas trabalham em 3,3 V e os pinos delas não toleram 5 V, então módulos de 5 V que você liga direto no Uno podem precisar de um conversor de nível. Por outro lado, essas placas oferecem interrupções e PWM em quase todos os pinos, e os barramentos I2C e SPI podem ser movidos para outros pinos. Para comparar as placas, leia Arduino Uno ou ESP32, e para ver os mapas de pinos use a ferramenta de pinagem; as placas em si são explicadas em O que é o ESP32? e O que é o Raspberry Pi Pico?.

Para que serve o conector ICSP?

O ICSP (In-Circuit Serial Programming) é um conector 2×3 usado para programar o microcontrolador diretamente pelas linhas SPI, sem USB nem bootloader. O ICSP na borda direita da placa pertence ao ATmega328P, enquanto o pequeno ICSP1 ao lado do conector USB pertence ao chip USB-serial (ATmega16U2). No uso do dia a dia você não mexe nele, mas o ICSP entra em cena quando o bootloader está corrompido, quando você grava um bootloader em um ATmega328P novo ou quando carrega código com um programador como o USBasp. Se você transformar um segundo Uno em programador com o exemplo ArduinoISP, os pinos 10, 11, 12 e 13 do programador vão às linhas RESET, MOSI, MISO e SCK da placa alvo, e um capacitor de 10 µF entre RESET e GND no Uno programador impede o auto-reset dele. Para descobrir se a sua placa foi danificada, dê uma olhada em Meu Arduino queimou?.

20 mA por pino, 200 mA no total: limites de corrente

Um pino do Uno trabalha com segurança com no máximo 20 mA. Os 40 mA do datasheet do ATmega328P são o máximo absoluto, o valor além do qual o chip pode ser danificado de forma permanente, não um valor de operação. A corrente total pelos pinos VCC e GND do chip não pode passar de 200 mA. O datasheet também divide os pinos em grupos: ao fornecer corrente (HIGH), D0–D4 junto com A0–A5, e D5–D13 entre si, devem ficar cada um abaixo de 150 mA; ao absorver corrente (LOW), os grupos D0–D4, D5–D13 e A0–A5 devem ficar cada um abaixo de 100 mA. Quando você aciona um LED vermelho com 5 V através de um resistor de 220 Ω, a corrente é (5 − 2) / 220 ≈ 13,6 mA. Dez LEDs acesos ao mesmo tempo somam 136 mA; isso fica abaixo de 200 mA, mas, se estiverem todos no mesmo grupo, chega muito perto do limite de grupo de 150 mA. Se os LEDs estiverem ligados para acender com o pino em LOW (resistor do 5V ao pino) e a maioria estiver no mesmo grupo, o limite de 100 mA é ultrapassado. Distribua os LEDs entre os grupos ou aumente o resistor para 330–470 Ω. Encontre o resistor certo com a calculadora de resistor para LED ou a calculadora da lei de Ohm.

• Motores: mesmo um motor CC pequeno puxa centenas de mA e gera picos de tensão; use um driver de motor como o L298N ou um transistor.
• Bobinas de relé: a bobina de um relé de 5 V puxa cerca de 70–90 mA; use um módulo relé com transistor e diodo.
• Servo motores: o fio de sinal pode ir a um pino, mas a alimentação do servo deve vir de uma fonte separada, não do pino 5V; detalhes no artigo sobre servo motor.
• Fitas de LED e LEDs de alta potência: fitas de 12 V e LEDs de 1 W precisam de um MOSFET de nível lógico.
• Curtos-circuitos: ligar uma saída em HIGH direto no GND puxa muito mais que 40 mA do pino e o estraga para sempre.

Sketch de teste: experimente pinos digitais, PWM, analógicos e de interrupção juntos

1. Ligue um LED ao pino 9 através de um resistor de 220 Ω: perna longa no resistor, perna curta no GND.
2. Ligue os dois terminais externos de um potenciômetro ao 5V e ao GND e o terminal do meio ao A0.
3. Ligue um botão entre o pino 2 e o GND; não é preciso resistor separado porque o pull-up interno é usado.
4. Carregue o sketch, abra o Monitor Serial e ajuste para 9600 baud.
5. Gire o potenciômetro: o brilho do LED no pino 9 muda, o LED L da placa (pino 13) acende quando a tensão passa de 2,5 V, e o contador sobe um a cada toque no botão.

1const byte BUTTON_PIN = 2;    // kesme pini INT0 / interrupt pin INT0
2const byte PWM_LED    = 9;    // ~9: PWM çıkışı / PWM output
3const byte STATUS_LED = 13;   // kart üzerindeki L LED'i / onboard L LED
4const byte POT_PIN    = A0;   // analog giriş / analog input
5
6volatile unsigned int pressCount = 0;   // ISR içinde değişir / changed inside the ISR
7
8void onButton() {
9  static unsigned long lastPressMs = 0;
10  unsigned long now = millis();
11  if (now - lastPressMs > 50) {         // 50 ms sıçrama filtresi / 50 ms debounce
12    pressCount++;
13    lastPressMs = now;
14  }
15}
16
17void setup() {
18  Serial.begin(9600);                   // 0 ve 1 numaralı pinleri kullanır / uses pins 0 and 1
19  pinMode(STATUS_LED, OUTPUT);
20  pinMode(PWM_LED, OUTPUT);
21  pinMode(BUTTON_PIN, INPUT_PULLUP);    // dahili pull-up direnci / internal pull-up resistor
22  attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), onButton, FALLING);
23}
24
25void loop() {
26  int raw = analogRead(POT_PIN);        // 0-1023 arası ham değer / raw value 0-1023
27  float volts = raw * 5.0 / 1023.0;     // volta çevir / convert to volts
28  analogWrite(PWM_LED, raw / 4);        // 0-255 arası PWM / PWM from 0 to 255
29  digitalWrite(STATUS_LED, volts > 2.5 ? HIGH : LOW);   // 2,5 V eşiği / 2.5 V threshold
30
31  noInterrupts();                       // sayacı güvenle kopyala / copy the counter safely
32  unsigned int presses = pressCount;
33  interrupts();
34
35  Serial.print(F("A0: "));
36  Serial.print(raw);
37  Serial.print(F("  V: "));
38  Serial.print(volts, 2);
39  Serial.print(F("  Buton / Button: "));
40  Serial.println(presses);
41  delay(200);
42}

O sketch usa quatro tipos de pino do Uno ao mesmo tempo. analogRead(A0) lê um valor de 0 a 1023, e raw / 4 o reduz à faixa de 0–255 que o analogWrite() espera. Para não contar o repique dos contatos, a função de interrupção ignora sinais que chegam menos de 50 ms depois do último toque. O contador alterado dentro da interrupção é declarado como volatile, e o loop() o copia com as interrupções pausadas por um instante, porque o Uno de 8 bits lê um número de 16 bits em duas etapas e uma interrupção no meio poderia gerar um valor errado. Os pinos 0 e 1 só são usados pela Serial, então nada mais está ligado neles.

Exemplo de plano de pinos: qual peça vai em qual pino?

Espalhar pinos ao acaso em um projeto com várias peças leva a conflitos. Primeiro coloque nos seus pinos as peças com funções especiais (I2C, SPI, interrupções, PWM) e depois distribua as tarefas digitais simples pelos pinos livres. Abaixo está um exemplo de plano para uma fechadura de porta com cartão RFID: um leitor RC522, um LCD I2C, um servo, um buzzer, um botão e dois LEDs. Como o servo e o tone() são usados juntos, o PWM em 3, 9, 10 e 11 já está fora de questão, e o plano leva isso em conta.

Diferenças de pinos entre o Arduino Uno R3 e o R4

Resumindo, os números e as funções dos pinos continuam os mesmos no R4 (PWM ~3, 5, 6, 9, 10, 11; I2C A4/A5; SPI 10–13; interrupções 2, 3), mas a corrente por pino cai para 8 mA. Um LED que você acionava direto de um pino no R3 precisa de um resistor maior no R4 (por exemplo 1 kΩ para cerca de 3 mA) ou de um transistor. A comparação detalhada está em Arduino Uno R4. Se estiver procurando uma placa menor, Pinagem do Arduino Nano e Qual Arduino comprar? vão ajudar.

Erros comuns e como corrigi-los

Quando você conhece os pinos do Arduino Uno, não precisa decorar onde cada peça vai; você olha o que a peça precisa e escolhe o pino certo sozinho. Se quiser rever o básico, comece por O que é Arduino?. No app BlueGrays você encontra projetos como acender um LED, ler um botão, medir luz com um LDR, LED RGB com PWM, LCD I2C, RFID e dois Arduinos conversando por uma linha serial, cada um passo a passo, com esquemas do circuito que mostram por que cada pino foi escolhido e código pronto para usar.