Arduino Uno R4 WiFi ou Minima: diferenças para o R3 e primeiro projeto

O Arduino Uno R4 é a quarta revisão do Uno, a placa de desenvolvimento mais usada do mundo, e o primeiro Uno a usar um processador de 32 bits no lugar de um AVR de 8 bits. Ele existe em dois modelos: o Uno R4 Minima, mais simples e barato, e o Uno R4 WiFi, com Wi-Fi, Bluetooth e uma matriz de LED de 12x8. Os dois mantêm o tamanho, a disposição dos pinos e a tensão de funcionamento de 5 V do R3, então a maioria dos shields e circuitos encaixa do jeito que está. Por outro lado, a memória de programa é 8 vezes maior, o processador é 3 vezes mais rápido, e ele acrescenta uma saída analógica de verdade (DAC), um barramento CAN, um relógio integrado (RTC) e suporte a teclado e mouse USB.

Neste guia você vai aprender exatamente onde o R4 difere do R3, como escolher entre o Minima e o WiFi, quais sketches e bibliotecas antigas funcionam sem problema e quais não compilam, e por que você precisa respeitar o limite de 8 mA por pino. No fim, vamos montar o seu primeiro projeto, usando juntos a matriz de LED e o Wi-Fi do R4 WiFi e controlando tudo pelo celular.

O que é o Arduino Uno R4? Os modelos Minima e WiFi

No coração dos dois modelos está o microcontrolador RA4M1 (R7FA4M1AB3CFM) da Renesas: um núcleo Arm Cortex-M4 a 48 MHz com unidade de ponto flutuante (FPU). Diferente da maioria das placas de 32 bits, esse chip funciona com 5 V, e esse é o principal motivo de a Arduino ter escolhido o RA4M1 para o R4. O Minima traz só esse chip. O modelo WiFi acrescenta um módulo ESP32-S3-MINI-1, que fornece Wi-Fi e Bluetooth e também funciona como a ponte que fala com o computador pelo USB. Como o ESP32-S3 funciona com 3,3 V, há um conversor de nível entre os dois chips.

Diferenças entre o Uno R3 e o Uno R4

As linhas mais importantes da tabela são memória e velocidade. Os 2 KB de SRAM do R3 enchem com algumas variáveis String e um buffer de display; em projetos com display OLED, arrays longos ou leitura de JSON, a placa começa a travar ou a reiniciar aleatoriamente. Os 32 KB do R4 praticamente eliminam esse problema. Graças à FPU, as contas com float (calibração de sensores, PID, trigonometria) rodam no hardware e ficam muitas vezes mais rápidas que no R3. A alimentação também mudou bastante: o regulador linear do R3 esquenta com 12 V, enquanto o R4 usa um conversor buck chaveado, então a placa aceita até 24 V e funciona bem mais fria.

O hardware novo que vem com o R4

• DAC de 12 bits (A0): diferente do PWM, ele gera uma tensão analógica de verdade; é usado para áudio, ondas senoidais e um gerador de sinais simples. A biblioteca analogWave do pacote de placas gera ondas senoidais, quadradas e dente de serra em uma única linha.
• ADC de 14 bits: com analogReadResolution(14) você lê valores de 0 a 16383; com uma referência de 5 V, um passo vale cerca de 0,3 mV, contra 4,9 mV no R3. Para não quebrar sketches antigos, a resolução padrão continua em 10 bits.
• Amplificador operacional integrado: nos pinos A1 (+), A2 (–) e A3 (saída); você pode amplificar sinais pequenos de sensores sem um chip extra. Para o básico, veja O que é um amplificador operacional?
• Barramento CAN: o barramento de comunicação robusto usado em carros e na indústria; você o usa com um módulo transceptor como o SN65HVD230 ou o TJA1050 e com a biblioteca Arduino_CAN do pacote de placas.
• RTC: guarda a data e a hora sem módulo extra (biblioteca RTC.h). No R4 WiFi, se você ligar uma bateria entre 1,6 e 3,6 V ao pino VRTC, o relógio continua funcionando mesmo com a alimentação da placa cortada.
• USB HID: a placa pode aparecer no computador como teclado ou mouse; antes, isso exigia um Leonardo (teclado USB com o Arduino Leonardo).
• Toque capacitivo: alguns pinos podem funcionar como botões de toque sem módulo extra, com a biblioteca Arduino_CapacitiveTouch.

Você pode testar dois desses recursos agora mesmo. O sketch abaixo gera tensões crescentes no DAC e lê de volta a mesma tensão com o ADC de 14 bits. Basta ligar os pinos A0 e A1 com um jumper e abrir o Monitor Serial em 115200 baud:

1// A0 (DAC) ile A1'i bir jumper kabloyla bağla / connect A0 (DAC) to A1 with a jumper wire
2
3void setup() {
4  Serial.begin(115200);
5  while (!Serial) {}            // USB seri port açılana kadar bekle / wait for the USB serial port
6  analogWriteResolution(12);    // DAC: 0–4095
7  analogReadResolution(14);     // ADC: 0–16383
8}
9
10void loop() {
11  for (int value = 0; value < 4096; value += 512) {
12    analogWrite(DAC, value);              // A0'dan gerçek analog gerilim / true analog voltage on A0
13    delay(10);
14    int raw = analogRead(A1);             // 14 bit okuma / 14-bit reading
15    float volts = raw * 5.0 / 16383.0;    // 5 V referans / 5 V reference
16    Serial.print("DAC: ");
17    Serial.print(value);
18    Serial.print("  ADC: ");
19    Serial.print(raw);
20    Serial.print("  V: ");
21    Serial.println(volts, 3);
22    delay(500);
23  }
24}

Na saída, você vai ver a leitura subir cerca de 2048 toda vez que o valor do DAC aumenta 512: um passo da saída de 12 bits equivale a 4 passos da entrada de 14 bits. Usamos 5,0 V na conta, mas quando a placa é alimentada pelo USB a linha de 5 V cai para cerca de 4,7 V por causa do diodo de proteção. Se você precisa de medições precisas, meça o pino 5V com um multímetro e use esse valor no lugar do 5.0 da fórmula. A linha while (!Serial) evita que as primeiras linhas se percam antes de o Monitor Serial abrir; se a placa vai funcionar sem um computador ligado, apague essa linha, senão o programa fica esperando ali para sempre. O básico da leitura analógica está no artigo sobre ADC e conversão analógico-digital.

O limite de corrente por pino: por que 8 mA no R4?

Essa é a diferença que quem passa para o R4 mais ignora. O ATmega328P do R3 fornece com folga 20 mA por pino (40 mA de máximo absoluto), e é por isso que a maioria dos exemplos da internet liga um LED direto em um pino com um resistor de 220 Ω. Para o R4, porém, a Arduino recomenda não puxar mais de 8 mA por pino. Vamos fazer a conta com a lei de Ohm: acionar um LED vermelho (cerca de 2 V) a partir de um pino de 5 V por 220 Ω dá (5 − 2) / 220 ≈ 13,6 mA, quase o dobro do limite do R4. O LED provavelmente vai acender, mas o pino pode se danificar com o tempo, e esse dano costuma se acumular sem que você perceba.

Sketches e bibliotecas antigas funcionam no R4?

Resposta curta: a maioria, sim. Sketches escritos com comandos padrão do Arduino, como digitalWrite, analogRead, millis, Serial, Wire (I2C), SPI, EEPROM, Servo e tone, compilam no R4 sem mudanças. Os problemas aparecem em código que fala direto com o hardware do ATmega328P: operações rápidas de pino com registradores como PORTB e DDRD, ajustes do Timer1, arquivos de cabeçalho que começam com avr/ e as bibliotecas que os usam não compilam no R4. Por exemplo, um sketch que usa PORTB falha com 'PORTB' was not declared in this scope.

Durante a compilação, você pode ver um aviso como WARNING: library LiquidCrystal I2C claims to run on avr architecture(s) and may be incompatible with your current board which runs on renesas_uno architecture(s). Isso não é um erro; o autor da biblioteca só listou o AVR como arquitetura suportada. Se o sketch carregar e funcionar, está tudo bem. Se aparecer um erro de verdade, primeiro instale a versão mais recente da biblioteca (como instalar uma biblioteca no Arduino); se não resolver, procure uma alternativa com suporte ao R4.

Há mais uma diferença a observar: o R3 tem uma única porta serial, ligada ao USB e aos pinos D0/D1. No R4, a Serial é só o USB, e os pinos D0 e D1 funcionam separadamente como Serial1. Um sketch antigo que lê pela Serial um módulo como um Bluetooth HC-05 ou um GPS ligado ao D0/D1 não vai receber nada no R4. O sketch-ponte abaixo passa os dados do módulo para o Monitor Serial e o que você digita no Monitor Serial para o módulo:

1// R4'te Serial = USB, Serial1 = D0 (RX) ve D1 (TX) / on the R4, Serial = USB, Serial1 = D0 (RX) and D1 (TX)
2
3void setup() {
4  Serial.begin(115200);   // bilgisayar (Seri Monitör) / computer (Serial Monitor)
5  Serial1.begin(9600);    // D0/D1'e bağlı modül, örn. HC-05 / module on D0/D1, e.g. HC-05
6}
7
8void loop() {
9  if (Serial1.available()) {
10    Serial.write(Serial1.read());   // modülden bilgisayara / module to computer
11  }
12  if (Serial.available()) {
13    Serial1.write(Serial.read());   // bilgisayardan modüle / computer to module
14  }
15}

Configurando o Uno R4 no Arduino IDE

1. Instale ou atualize o Arduino IDE 2 (como instalar o Arduino IDE).
2. Abra o Gerenciador de Placas à esquerda, digite UNO R4 e instale o pacote Arduino UNO R4 Boards. É um pacote oficial, então você não precisa acrescentar nenhuma URL extra.
3. Ligue a placa com um cabo USB-C que transmita dados e escolha Arduino UNO R4 Minima ou Arduino UNO R4 WiFi em Ferramentas > Placa.
4. Escolha a porta da placa em Ferramentas > Porta, abra Arquivo > Exemplos > 01.Basics > Blink e carregue. O LED integrado no D13 começa a piscar.
5. Se nenhuma porta aparecer ou o carregamento parar no meio, aperte rápido o botão RESET duas vezes: a placa entra no modo bootloader e a porta aparece de novo. Para todos os problemas de carregamento, veja o guia erro ao carregar código no Arduino.

Uno R4 WiFi: o ESP32-S3 e a matriz de LED de 12x8

Por padrão, o ESP32-S3 do R4 WiFi roda um firmware instalado pela Arduino que transforma os comandos do RA4M1 em operações de Wi-Fi e Bluetooth. Você continua escrevendo o sketch para o RA4M1: usa a biblioteca WiFiS3, que vem com o pacote de placas, para o Wi-Fi e a biblioteca ArduinoBLE para o Bluetooth. Há dois limites importantes: o módulo só entra em redes de 2,4 GHz e, como o Wi-Fi e o Bluetooth dividem a antena, não dá para usar os dois ao mesmo tempo. Alguns recursos mais novos precisam do firmware atualizado do ESP32-S3; você pode atualizá-lo em Ferramentas > Firmware Updater no IDE.

A matriz na frente da placa tem 96 LEDs vermelhos em 8 linhas e 12 colunas. Quando sai da caixa, ela roda uma animação de Tetris. Os LEDs são ligados a 11 pinos internos do RA4M1 por uma técnica chamada charlieplexing; esses pinos não saem nos conectores, então usar a matriz não custa nenhum dos pinos D0–D13 ou A0–A5. A biblioteca Arduino_LED_Matrix do pacote de placas aceita um quadro em dois formatos: um array de bytes de 8x12 ou três números de 32 bits. O método do array é mais fácil de ler, porque você vê no próprio código a forma desenhada pelos 1s:

1#include "Arduino_LED_Matrix.h"   // kart paketiyle gelir / ships with the board package
2
3ArduinoLEDMatrix matrix;
4
5// 8 satır x 12 sütun: 1 = LED yanar / 8 rows x 12 columns: 1 = LED on
6uint8_t kalp[8][12] = {
7  { 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0 },
8  { 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0 },
9  { 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0 },
10  { 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
11  { 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0 },
12  { 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
13  { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
14  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
15};
16
17void setup() {
18  matrix.begin();
19}
20
21void loop() {
22  matrix.renderBitmap(kalp, 8, 12);          // kendi çizimin / your own drawing
23  delay(1000);
24  matrix.loadFrame(LEDMATRIX_EMOJI_HAPPY);   // kütüphanedeki hazır kare / ready-made frame from the library
25  delay(1000);
26  kalp[7][11] = 1;                           // tek bir LED'i yak: satır 7, sütun 11 / turn on one LED: row 7, column 11
27}

renderBitmap() mostra o array que você mesmo desenhou, enquanto loadFrame() carrega quadros prontos da biblioteca: LEDMATRIX_HEART_BIG, LEDMATRIX_EMOJI_HAPPY, LEDMATRIX_EMOJI_SAD e LEDMATRIX_DANGER são alguns deles. Com loadSequence() e play() você roda animações prontas como LEDMATRIX_ANIMATION_TETRIS ou LEDMATRIX_ANIMATION_WIFI_SEARCH. Para escrever e rolar texto na matriz, você precisa instalar a biblioteca ArduinoGraphics pelo Gerenciador de Bibliotecas. Se quiser um display maior, dê uma olhada nos artigos sobre a matriz de LED MAX7219 e a WS2812B NeoPixel.

Primeiro projeto: controlando a matriz de LED pelo celular

Agora vamos juntar os dois recursos. Enquanto a placa se conecta à sua rede de casa, a matriz roda uma animação de busca de Wi-Fi; quando conecta, ela mostra o endereço IP como texto rolando. Ao abrir esse endereço no navegador de um celular na mesma rede, botões permitem mostrar um coração, uma carinha feliz ou triste, rolar o endereço IP de novo ou apagar a matriz. Você não precisa de nenhuma peça além da placa.

1. Instale a biblioteca ArduinoGraphics pelo Gerenciador de Bibliotecas; a WiFiS3 e a Arduino_LED_Matrix vêm com o pacote de placas.
2. Troque o nome e a senha da rede no sketch pelos seus; cuidado com maiúsculas e minúsculas.
3. Selecione Arduino UNO R4 WiFi como placa, carregue o sketch e abra o Monitor Serial em 115200 baud.
4. Digite no navegador do celular o endereço IP que está rolando na matriz ou que aparece no Monitor Serial.
5. Toque nos botões da página; a matriz muda na hora.

1#include "ArduinoGraphics.h"      // Arduino_LED_Matrix'ten ÖNCE eklenmeli / must come BEFORE Arduino_LED_Matrix
2#include "Arduino_LED_Matrix.h"
3#include "WiFiS3.h"
4
5char ssid[] = "AgAdi";            // Wi-Fi adın / your Wi-Fi name
6char pass[] = "Sifre123";         // Wi-Fi şifren / your Wi-Fi password
7
8ArduinoLEDMatrix matrix;
9WiFiServer server(80);
10
11void scrollText(String text) {
12  matrix.beginDraw();
13  matrix.stroke(0xFFFFFFFF);
14  matrix.textScrollSpeed(60);             // her adım 60 ms / 60 ms per step
15  matrix.textFont(Font_5x7);
16  matrix.beginText(0, 1, 0xFFFFFF);
17  matrix.print("   " + text + "   ");
18  matrix.endText(SCROLL_LEFT);            // yazıyı sola kaydır / scroll the text to the left
19  matrix.endDraw();
20}
21
22void sendPage(WiFiClient &client) {
23  client.println("HTTP/1.1 200 OK");
24  client.println("Content-Type: text/html; charset=utf-8");
25  client.println("Connection: close");
26  client.println();
27  client.println("<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width'></head><body>");
28  client.println("<h2>UNO R4 WiFi</h2>");
29  client.println("<p><a href='/kalp'><button>Kalp / Heart</button></a></p>");
30  client.println("<p><a href='/mutlu'><button>Mutlu / Happy</button></a></p>");
31  client.println("<p><a href='/uzgun'><button>Uzgun / Sad</button></a></p>");
32  client.println("<p><a href='/ip'><button>IP</button></a></p>");
33  client.println("<p><a href='/kapat'><button>Kapat / Off</button></a></p>");
34  client.println("</body></html>");
35}
36
37void setup() {
38  Serial.begin(115200);
39  matrix.begin();
40
41  if (WiFi.status() == WL_NO_MODULE) {               // ESP32-S3 yanıt vermiyor / ESP32-S3 not responding
42    Serial.println("WiFi modulu bulunamadi / WiFi module not found");
43    matrix.loadFrame(LEDMATRIX_DANGER);
44    while (true) {}
45  }
46
47  matrix.loadSequence(LEDMATRIX_ANIMATION_WIFI_SEARCH);   // bağlanırken animasyon / animation while connecting
48  matrix.play(true);
49
50  while (WiFi.begin(ssid, pass) != WL_CONNECTED) {
51    Serial.println("Baglaniyor / connecting...");
52    delay(5000);
53  }
54  while (WiFi.localIP() == IPAddress(0, 0, 0, 0)) {   // DHCP adresini bekle / wait for the DHCP address
55    delay(100);
56  }
57
58  server.begin();
59  Serial.print("IP: ");
60  Serial.println(WiFi.localIP());
61  scrollText(WiFi.localIP().toString());     // IP adresini matriste göster / show the IP on the matrix
62  matrix.loadFrame(LEDMATRIX_EMOJI_HAPPY);
63}
64
65void loop() {
66  WiFiClient client = server.available();
67  if (!client) {
68    return;
69  }
70
71  String request = client.readStringUntil('\n');   // ör. "GET /kalp HTTP/1.1" / e.g. "GET /kalp HTTP/1.1"
72  while (client.available()) {
73    client.read();                                 // kalan başlıkları at / discard the remaining headers
74  }
75
76  bool showIp = false;
77  if (request.indexOf("GET /kalp") >= 0) {
78    matrix.loadFrame(LEDMATRIX_HEART_BIG);
79  } else if (request.indexOf("GET /mutlu") >= 0) {
80    matrix.loadFrame(LEDMATRIX_EMOJI_HAPPY);
81  } else if (request.indexOf("GET /uzgun") >= 0) {
82    matrix.loadFrame(LEDMATRIX_EMOJI_SAD);
83  } else if (request.indexOf("GET /kapat") >= 0) {
84    matrix.clear();
85  } else if (request.indexOf("GET /ip") >= 0) {
86    showIp = true;
87  }
88
89  sendPage(client);
90  delay(10);
91  client.stop();                                   // bağlantıyı kapat / close the connection
92
93  if (showIp) {
94    scrollText(WiFi.localIP().toString());         // sayfa gittikten sonra kaydır / scroll after the page is sent
95  }
96}

A lógica é simples: o WiFi.begin() é repetido até a conexão subir, depois o sketch espera o DHCP entregar um endereço IP e inicia um servidor web na porta 80. Ele lê a primeira linha da requisição do celular (por exemplo “GET /kalp HTTP/1.1”, em que kalp é coração em turco), usa indexOf() para descobrir qual botão foi apertado e carrega na matriz o quadro correspondente. O endText(SCROLL_LEFT) bloqueia o programa enquanto o texto rola, e é por isso que só rolamos o endereço IP de novo depois de mandar a página e fechar a conexão. Se a matriz mostrar o símbolo de perigo e parar, o ESP32-S3 não está respondendo; tire e ponha de novo o cabo USB da placa e atualize o firmware. Se a conexão nunca subir, as verificações de 2,4 GHz e de senha do artigo ESP32 não conecta ao Wi-Fi também valem aqui.

Alimentação: pinos VIN, 5V e 3,3 V

O R4 aceita 6–24 V no conector DC ou no pino VIN; o conversor buck da placa baixa para 5 V. Segundo a documentação do R4 WiFi da Arduino, dá para puxar cerca de 1,2 A do pino 5V quando a placa é alimentada pelo VIN; na alimentação por USB, a própria placa aguenta até 2 A, mas o limite real é definido pela porta USB do computador. Essa corrente é para sensores e módulos pequenos, não para motores e servos. O pino de 3,3 V do Minima é alimentado pelo regulador interno do RA4M1, então só serve para sensores pequenos; não alimente por ele módulos de corrente alta como um ESP-01 ou um nRF24L01 com antena PA+LNA. O R4 WiFi também tem um pino OFF (ligá-lo ao GND corta a alimentação de 5 V da placa) e um pino VRTC para a bateria do RTC. Para todas as opções de alimentação, veja Como alimentar o Arduino.

Ideias de projetos com o Uno R4

• Estação meteorológica Wi-Fi: mostre a temperatura medida com um DHT11 como texto rolando na matriz e em uma página que você abre no celular.
• Jogos na matriz: cobrinha, Tetris ou uma bolinha quicando na matriz de 12x8; para mais ideias, veja o artigo sobre projetos de jogos com Arduino.
• Relógio pela internet: pegue a hora na internet (NTP), grave no RTC integrado e mantenha durante quedas de energia com uma bateria no pino VRTC.
• Teclado de macros USB: monte um teclado de quatro botões que dispara atalhos no computador; graças ao suporte HID do R4, você não precisa de um Leonardo.
• Som com o DAC: gere uma onda senoidal no A0 com a biblioteca analogWave e monte um sintetizador simples com um amplificador de áudio e um alto-falante.
• Controle de lâmpada pelo celular: junte o servidor web deste artigo a um módulo relé e acenda uma lâmpada a distância.

Erros comuns e como corrigir

Qual comprar: R3, R4 Minima ou R4 WiFi?

• Uno R4 WiFi: a melhor escolha se os seus projetos vão se conectar à internet, a um celular ou ao Bluetooth e você quer um display pronto na placa. Também é divertido para iniciantes, porque você vê na hora o seu código funcionando na matriz.
• Uno R4 Minima: serve bem se você não precisa de conexão sem fio e quer mais memória, velocidade, um DAC e USB-C. Graças ao conector SWD, também é uma boa opção se você quer ligar um depurador externo e executar o código passo a passo.
• Uno R3 ou um clone compatível: ainda faz sentido se você tem projetos antigos que usam bibliotecas específicas do AVR, quer seguir à risca os exemplos dos livros ou procura o menor custo; os pinos dele aguentam 20 mA com folga.
• ESP32: se você quer Wi-Fi com mais pinos e por um preço menor, uma placa ESP32 também vale a pena; só lembre que ela funciona com 3,3 V (Arduino ou ESP32?).

Resumindo, o Uno R4 é uma atualização que mantém a facilidade de uso conhecida do Uno e acrescenta memória, velocidade e hardware novo; só lembre do limite de 8 mA e da diferença da Serial1. Para conhecer os pinos da placa em detalhes, dê uma olhada no artigo sobre a pinagem do Arduino Uno. No app BlueGrays você encontra projetos de LED, botão, sensor, LCD e matriz de LED para o Arduino Uno com esquemas de circuito e código passo a passo; esses projetos são escritos com comandos padrão, então também rodam no R4, e você só precisa subir os resistores dos LEDs para 470 Ω.