Arduino Uno

O que é

O Arduino Uno é uma pequena placa de desenvolvimento baseada no ATmega328P da Microchip, um microcontrolador de 8 bits. Ele expõe os pinos do chip em conectores rotulados, acrescenta uma porta USB para programação e alimentação e cuida das partes complicadas—o regulador de tensão, o cristal de relógio e o circuito de reinicialização—para que você possa se concentrar no código e nas conexões. Para muita gente que aprende robótica, o Uno é a forma de fazer um motor girar ou um sensor acender pela primeira vez.

Seu atrativo duradouro não é a potência bruta—pelos padrões atuais, ele é lento e tem pouca memória. É a tolerância. Os pinos de 5 V suportam os erros de ligação comuns a iniciantes, a comunidade já respondeu a quase todas as perguntas que você pode fazer e quase todos os sensores e drivers para iniciantes vêm com código de exemplo que pressupõe um Uno.

Como funciona

Você escreve um programa C++ com duas funções. setup() é executada uma vez quando a placa é ligada; loop() é executada indefinidamente depois disso. Dentro delas, você lê entradas e comanda saídas pelos pinos:

• Pinos digitais leem ou escrevem um sinal HIGH/LOW (5 V / 0 V)—o acionamento de um botão, o acender de um LED ou a entrada de direção de um driver de motor.
• Pinos PWM (marcados com ~) produzem uma tensão analógica por chaveamento, ligando e desligando muito rapidamente. É assim que você define a velocidade do motor ou o brilho de um LED.
• Entradas analógicas medem uma tensão de 0–5 V e a reportam como um número de 0–1023. É assim que você lê um potenciômetro ou um sensor de linha analógico.

O Uno não possui sistema operacional. Seu código é a única coisa em execução, o que torna a temporização previsível—algo valioso ao implementar uma malha de controle em um robô real.

Quando usar

Use um Uno quando estiver aprendendo, quando quiser o maior conjunto possível de tutoriais e bibliotecas compatíveis ou quando o trabalho do robô for simples e em tempo real: ler alguns sensores, executar uma malha de controle e acionar dois motores. Um robô seguidor de linha, um robô que desvia de obstáculos ou um pequeno robô com tração diferencial estão totalmente no seu elemento.

Procure outra solução quando precisar de Wi-Fi ou Bluetooth (normalmente, um ESP32 é a opção mais adequada), computação pesada ou visão por câmera (um Raspberry Pi), ou muita memória. Os 2 KB de SRAM do Uno se esgotam antes do que os iniciantes esperam—textos longos e vetores grandes costumam ser os culpados.

Armadilhas comuns

• É uma placa de 5 V. Muitos sensores modernos usam 3,3 V e podem ser danificados por lógica de 5 V. Consulte a folha de dados antes de conectar.
• Não alimente motores pela placa. O regulador do Uno não fornece corrente para os motores; use uma bateria separada e um driver de motor. Alimentar motores diretamente pelo Uno é a causa mais comum de quedas de tensão ou reinicialização da placa.
• delay() bloqueia tudo. Enquanto a placa está em um delay(), ela não consegue ler sensores nem reagir. Para qualquer comportamento responsivo, controle o tempo com millis().
• Acompanhe a memória. Se a placa se comportar de forma errática sem um motivo claro, a SRAM pode estar esgotada.

Pinagem: o que cada pino realmente faz

Há catorze pinos digitais e seis analógicos, mas eles não são intercambiáveis. Seis têm uma segunda função importante.

Esses dois pinos definem a maioria dos projetos de robô. D2 e D3 são os únicos pinos verdadeiros de interrupção, portanto um robô com dois encoders de roda usa ambos e não sobra nenhum pino. E A4/A5 são o barramento I²C, então um MPU-6050 mais uma matriz de sensores analógicos em um Uno disputam os pinos imediatamente.

Essa pressão sobre os pinos é o motivo mais comum para um projeto ultrapassar a capacidade de um Uno — não a velocidade nem a memória. Catorze pinos digitais e seis analógicos desaparecem rapidamente quando você tem um driver de motor (6 pinos), um par de encoders (4 pinos, 2 deles para interrupções) e uma matriz de sensores (6 analógicos).

Alimentação e as três formas de errar

O regulador é linear, o que significa que dissipa a diferença entre a entrada e 5 V como calor. Com entrada de 12 V e corrente de 200 mA, isso representa (12 − 5) × 0.2 = 1.4 W em um encapsulamento pequeno, e ele fica realmente quente. Alimente a placa com 9 V, em vez de 12 V, se tiver a escolha.

Vale destacar três erros específicos:

Alimentar motores pelo pino de 5 V. O regulador não fornece corrente para os motores, portanto a trilha cai, a placa reinicia e o sintoma parece uma falha de programa. Os motores devem ter alimentação própria e compartilhar apenas a massa.

Alimentar o pino de 5 V por uma fonte sem regulação. Esse pino está diretamente na trilha, portanto qualquer valor acima de aproximadamente 5,5 V chega direto ao ATmega328P.

Alimentar por USB e pelo conector ao mesmo tempo. A placa tem uma solução para isso (há um comparador que seleciona a fonte mais alta), mas uma bateria no conector não será carregada e pode injetar tensão de volta em um clone com projeto marginal.

O que os pinos realmente conseguem fornecer

O pino de 3,3 V engana as pessoas com frequência. Ele não é uma trilha de uso geral, mas uma saída auxiliar de 50 mA. Um módulo ESP-01 tentando transmitir fará queda de tensão imediatamente nele.

O problema dos 2 KB de memória

O Uno tem 32 KB de flash para seu programa e 2 KB de SRAM para as variáveis durante a execução. A flash raramente é o fator limitante. A SRAM é, constantemente, o fator limitante.

Cada literal de texto em um Serial.print é copiado para a SRAM na inicialização:

Serial.println("Calibration complete, entering drive mode");   // 43 bytes of SRAM, forever

Vinte mensagens assim ocupam 800 bytes — 40% do total. A solução é F(), que mantém o texto na flash e o lê quando necessário:

Serial.println(F("Calibration complete, entering drive mode"));  // 0 bytes of SRAM

Vetores são o outro consumidor. Um float ocupa 4 bytes, portanto um buffer de registro com 200 amostras tem 800 bytes, sem qualquer aviso — o compilador informa tranquilamente o uso da flash e nada útil sobre a SRAM em execução.

O sintoma de esgotamento não é um erro claro. A pilha cresce para baixo, a memória dinâmica cresce para cima e, quando se encontram, as variáveis corrompem umas às outras silenciosamente. A placa se comporta de forma errática: leituras sem sentido, um laço que pula, um reinício sem causa. Se um Uno começar a se comportar de modo irracional depois que você adicionou um recurso, suspeite da SRAM antes de qualquer outra coisa.

// Drop this in and watch it while you develop.
int freeRam() {
  extern int __heap_start, *__brkval;
  int v;
  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
}

Com menos de aproximadamente 200 bytes livres, espere problemas.

Solução de problemas

Uno ou outra opção?

O Nano merece destaque especial em robôs: é o mesmo ATmega328P com o mesmo código, mas expõe A6 e A7 como entradas analógicas adicionais. Para uma matriz de sensores de refletância infravermelha de 8 canais, isso é a diferença entre caber ou não caber, e é exatamente por isso que projetos de robôs seguidores de linha frequentemente especificam um Nano.

O resumo honesto: o valor do Uno está em tudo funcionar na primeira tentativa. Toda biblioteca, todo tutorial e todo diagrama de conexão pressupõe essa placa. Isso vale mais durante o aprendizado que qualquer especificação e, quando você a ultrapassar, aquilo que ficou pequeno será quase sempre a quantidade de pinos.