Preparar a IDE
Do computador vazio até as duas placas gravando e falando de volta. Esta aula não ensina eletrônica: ela tira do caminho tudo o que faz alguém desistir antes da primeira aula — instalador, driver, porta que não aparece, monitor que só mostra símbolos.
Ao terminar, você tem
- O Arduino IDE 2 instalado e abrindo.
- O Uno piscando o LED da própria placa.
- O Monitor Serial mostrando uma frase sua, uma vez por segundo.
- O ESP32-S3 N16R8 fazendo as duas coisas, com os quatro ajustes certos e o motivo de cada um.
Na mesa
- Um computador com Windows, macOS ou Linux, e internet.
- Arduino Uno e o cabo USB-B dele.
- ESP32-S3 N16R8 e o cabo USB-C dele.
- Os dois cabos precisam ser de dados. Cabo de carga não serve, e por fora ele é idêntico.
- Sem placa nenhuma? Dá para ler a aula inteira e responder tudo; o que fica de fora é só a gravação.
Como estudar esta página
- Siga a ordem. Cada etapa prova que a anterior deu certo.
- Marque as caixas. Elas ficam salvas neste navegador.
- Preveja antes de responder cada quiz. Errar a previsão ajuda.
- Travou? Pule para as cinco travas comuns e volte depois.
- Revise nas datas da agenda do fim. Instalar uma vez não é aprender.
Onde esta aula se encaixa
Ela é o degrau zero: a única da trilha que não supõe nada. Toda aula depois desta começa com a placa já gravando.
De onde você vem
- Antes daqui não é preciso nada: nem eletrônica, nem programação, nem ter aberto a caixa da placa.
- Aqui você instala a ferramenta, grava o primeiro programa e faz a placa escrever de volta no computador.
- Depois daqui vem a primeira aula de eletrônica de verdade: o Arduino lendo um botão e acionando um LED ou um relé.
Esta página é autoral e não reproduz material de curso nenhum. Ela existe porque a trilha de eletrônica começa supondo que você já grava um sketch — e alguém precisa ensinar esse passo.
O que é a IDE, em uma frase
É o programa que você instala no computador para escrever, traduzir e enviar programas para a placa. A placa não escreve nem traduz nada: ela recebe pronto e executa. Guarde essa divisão de trabalho, porque metade das travas desta página vem de esquecê-la.
O nome longo é Arduino IDE 2. Ele serve tanto para o Arduino Uno quanto, depois de um endereço extra, para o ESP32-S3 — que é de outro fabricante.
Baixar e instalar o Arduino IDE 2
Um programa só, o mesmo nos três sistemas. Escolha abaixo o seu e siga o cartão correspondente.
O que a sua máquina precisa ter
O guia oficial lista os requisitos do Arduino IDE 2 assim: Windows 10 ou mais novo, de 64 bits; Linux de 64 bits, sem exigir distribuição nenhuma em particular; e macOS 10.15 “Catalina” ou mais novo, de 64 bits.
Um detalhe honesto sobre o macOS, conferido em 7 de setembro de 2026: os requisitos do guia dizem “Catalina ou mais novo”, mas a página de download não oferece nenhum arquivo abaixo de macOS 12 “Monterey”. Onde as duas fontes oficiais divergem, mande na prática a que entrega o arquivo: se o seu Mac é anterior ao Monterey, conte com dificuldade.
Baixar: escolha o seu sistema
Os três cartões apontam para a mesma página de download oficial, que é onde os arquivos de verdade ficam, e para a seção do guia de instalação daquele sistema. Não há aqui nenhum endereço com número de versão dentro: endereço assim quebra a cada lançamento novo, e esta página precisa continuar certa sem manutenção.
Windows
Na página de download, o botão do Windows é o instalador .exe; a mesma lista oferece um .msi e um .zip, para quem precisa deles. Execute o arquivo baixado e siga a janela; pode levar alguns minutos. Não há passo escondido: quando termina, a ferramenta está pronta.
macOS
A lista de download traz dois arquivos diferentes: um para Mac com processador Intel e outro para Mac com Apple Silicon. Descubra qual é o seu no menu da maçã, em “Sobre este Mac”. Baixado, o guia oficial resume a instalação em uma frase: copie o arquivo baixado para a pasta de aplicativos.
Linux
O download é um AppImage de 64 bits: um arquivo único que roda sem instalar. Antes de abrir, marque-o como executável — clique com o botão direito, Propriedades, aba Permissões, e marque a opção de permitir execução como programa. Se ele não abrir mesmo assim, falta o FUSE no seu sistema, e o guia mostra como instalá-lo.
A ferramenta abre e mostra uma janela com um sketch vazio, com void setup() e void loop() já escritos. Nada precisa estar ligado ainda.
A janela por dentro, em seis pontos
Dois minutos aqui economizam meia hora depois. Tudo o que esta aula pede daqui para a frente está em um destes seis lugares.
- Verificar e Carregar. O visto traduz o programa e aponta erros sem tocar na placa. A seta traduz e envia. É assim que a documentação da Arduino descreve os dois botões.
- Seletor de placa e porta. Duas escolhas, não uma. Ele costuma reconhecer sozinho o que está ligado; quando não reconhece, o caminho manual é
Tools > BoardeTools > Port. - Monitor Serial. O botão que abre o caminho de volta, por onde a placa escreve para você. Na IDE 2 ele não abre em janela separada: aparece embaixo.
- Coluna de ícones. Pasta de sketches, Gerenciador de Placas, gerenciador de bibliotecas, depurador e busca. O segundo ícone é o que você usa para instalar o suporte ao ESP32-S3.
- Área do sketch. Onde o programa é escrito. É o caderno.
- Área de saída. A faixa escura embaixo. É onde a tradução conta o que fez, onde os erros aparecem e onde o Monitor Serial se instala quando é aberto.
O Uno primeiro: do cabo ao LED piscando
A primeira coisa que você grava não precisa ser escrita por você. Ela já vem dentro da ferramenta, e existe justamente para provar que o caminho inteiro funciona.
O Uno usa um conector USB-B, o quadradão de impressora — é o mesmo conector que a documentação da Arduino lista para o UNO Rev3. E ele precisa de um cabo de dados. A própria Arduino é direta sobre isso: um cabo só de carga não vai funcionar.
- Ligue a placa direto no computador.
Sem hub USB no meio. Um LED da placa acende assim que ela recebe energia; se nenhum acende, o problema é cabo ou porta, e não adianta seguir.
- Abra um programa que já vem pronto.
No menu,
File > Examples > 01.Basics > Blink. É o programa mais simples que existe: acende e apaga o LED da própria placa. Ninguém precisa digitar nada aqui. - Diga qual placa e qual porta.
O seletor no alto da janela costuma reconhecer sozinho o que está ligado. Se não reconhecer, o caminho manual é
Tools > BoardeTools > Port. - Confira antes de enviar.
Clique no visto. Ele traduz o programa e aponta erros sem tocar na placa. É o teste barato.
- Envie.
Clique na seta. A tradução aparece na área escura embaixo e, no fim, o aviso de que terminou.
Bancada: placa e porta
Escolha as duasTools > Board
Tools > Port
O que a área de saída diria:
As mensagens acima estão escritas em português e descrevem a reclamação; o texto exato na sua tela sai em inglês e muda de versão para versão. O que não muda é a causa.
O programa que você acabou de enviar
Vale abrir e ler, porque é a estrutura de todo sketch: uma parte que roda uma vez e outra que roda para sempre. Clique numa linha para ver a explicação.
blink.inovoid setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
Este é o exemplo que a própria ferramenta traz. Você não precisa digitá-lo; a versão comentada desta aula, com as constantes nomeadas, está em codigo/blink.ino.
Drivers: o que é verdade e o que depende da sua placa
O Uno original tem dois chips: o ATmega328P, que roda o seu programa, e um segundo, o ATmega16U2, cujo trabalho é ser a ponte entre o USB do computador e o primeiro chip. Sobre esse caminho, a Arduino é explícita: o pacote da placa, que a própria ferramenta instala, é tudo de que o computador precisa — nenhum driver adicional precisa ser baixado ou instalado.
Placa clonada é outra história, e não porque seja pior: ela troca aquele segundo chip por um CH340 ou por um CP2102, de outros fabricantes, e o driver desses chips vem de quem os fabrica, não da Arduino. Como saber qual é o seu caso, sem adivinhar:
- Olhe a placa. Perto do conector USB há um chip com o nome impresso. Se você ler
CH340ouCP2102, é clone; se lerATMEGA16U2, é o caminho original. - Olhe o sistema. No Windows, o Gerenciador de Dispositivos, na seção de portas (COM e LPT). Um triângulo amarelo ao lado do aparelho significa, nas palavras da própria Arduino, que o driver está faltando e a placa não foi instalada direito — e a porta correspondente não vai aparecer na ferramenta.
Se for clone e a porta não aparecer, o driver que falta é o do fabricante daquele chip. Esta página não indica um endereço de download porque não conferiu nenhum: baixar driver de origem errada é problema pior que o problema original. Procure pelo nome exato que você leu na placa, no site do fabricante do chip.
O LED marcado com L na plaquinha, perto do conector USB, acende por um segundo e apaga por um segundo, sem parar. Ele não depende de nenhum fio: já vem ligado a um pino por dentro da placa.
A placa fala: a Serial e o Monitor Serial
Até aqui a conversa foi de mão única. A Serial é o caminho de volta — e é com ela que você descobre, em toda aula daqui para a frente, o que a placa está pensando.
Duas linhas bastam para abrir esse caminho. Serial.begin combina a velocidade da conversa e Serial.println escreve uma linha. Digite o programa abaixo numa janela nova e envie para o Uno.
serial_uno.inovoid setup() {
Serial.begin(9600);
}
void loop() {
Serial.println("A placa fala");
delay(1000);
}
Depois de enviar, abra o Monitor Serial pelo botão no canto superior direito da janela. Na IDE 2 ele não abre em janela separada: aparece embaixo, no lugar da área de mensagens, com os próprios controles ao lado — entre eles a velocidade.
Serial.begin do seu sketch — 9600 aqui, 115200 no sketch do ESP32-S3 mais adiante.Bancada: a velocidade da Serial
Desencontre os dois númerosSerial.begin(…)
O que aparece no Monitor Serial:
A frase A placa fala aparece na área escura, uma linha nova por segundo, sem símbolos estranhos no meio.
Acrescentar o ESP32-S3 N16R8
O Uno já vinha de fábrica dentro da ferramenta. O ESP32-S3 não: ele é de outro fabricante, e a IDE precisa primeiro saber onde buscar o pacote de suporte dele.
São dois movimentos, e eles acontecem em telas diferentes: primeiro você dá o endereço do catálogo nas preferências; depois instala o pacote que está nesse catálogo, pelo Gerenciador de Placas.
- Abra as preferências.
No Windows e no Linux,
File > Preferences. No macOS,Arduino IDE > Settings. - Cole o endereço do Espressif.
É este, o da versão estável, tal como o próprio Espressif publica:
https://espressif.github.io/arduino-esp32/package_esp32_index.json. Confirme comOK. - Abra o Gerenciador de Placas.
Na IDE 2, o ícone da plaquinha na coluna da esquerda — o segundo de cima para baixo —, ou
Tools > Board > Boards Manager. - Instale o pacote
esp32.Procure por
esp32e instale o que aparece comoesp32 by Espressif Systems. É um download grande; deixe terminar sem fechar a janela. - Reinicie a ferramenta
e volte em
Tools > Board: agora existe um grupoesp32na lista.
Os quatro ajustes, e por que cada um importa
Escolhida a placa, o menu Tools ganha uma fileira de opções que descrevem o pedaço de silício que você tem na mão. Quatro delas decidem se a sua placa vai funcionar ou vai dar defeito difícil de entender. Os nomes abaixo são os que aparecem na tela, em inglês, e saem do arquivo de definição de placas do próprio Espressif.
| Onde | O que marcar | Por quê |
|---|---|---|
Board |
ESP32S3 Dev Module |
É a entrada genérica do ESP32-S3, a que aceita configurar memória e USB à mão. Placas N16R8 de vários fabricantes usam esta entrada; as entradas com nome de produto vêm com a memória fixada e não servem. |
Flash Size |
16MB (128Mb) |
O N16 do nome é isto: 16 MB de memória de programa. Marcar menos faz a ferramenta acreditar num espaço menor do que existe, e o esquema de partições sai errado. |
PSRAM |
OPI PSRAM |
O R8 do nome são 8 MB de RAM extra, e nesse módulo ela é octal — oito trilhas de dados, não quatro. OPI quer dizer octal; QSPI, quádrupla. Marcar a errada é o mesmo que falar por oito fios com quem só escuta por quatro: a memória extra simplesmente não aparece. |
USB CDC On Boot |
Enabled |
Com esta opção ligada, assim que a placa é conectada surge uma porta serial nova na lista, e é por ela que o Monitor Serial escuta. Desligada, o texto do Serial.println sai por outro caminho e o monitor fica mudo na porta USB-C nativa — o defeito que mais parece placa queimada e não é. |
Bancada: os quatro ajustes do N16R8
Erre de propósitoBoard
Flash Size
PSRAM
USB CDC On Boot
O que você observa com esta configuração:
Nenhuma destas escolhas quebra a placa. O que elas quebram é a sua tarde: o sintoma aparece longe da causa.
Fazer o S3 falar
Com os quatro ajustes marcados e a placa ligada, grave o sketch abaixo. Ele é o mesmo da etapa anterior com um número diferente: 115200 é a velocidade usual das placas ESP32, e é o número que o seletor do Monitor Serial precisa mostrar.
serial_esp32s3.inovoid setup() {
Serial.begin(115200);
}
void loop() {
Serial.println("O S3 fala");
delay(1000);
}
Quando o upload falha: BOOT e RESET
No ESP32-S3, gravar exige que o chip esteja em modo de gravação. Quase sempre ele entra sozinho; quando não entra, o envio falha com erro de conexão. O procedimento oficial do Espressif é segurar um botão e apertar o outro.
O envio termina sem erro e a frase O S3 fala aparece no Monitor Serial, com o seletor em 115200, uma linha por segundo.
As cinco travas comuns
Todas se parecem com placa quebrada e nenhuma é. Ache o seu sintoma no título de cada caixa.
A porta não aparece em Tools > Port.
Causa mais provável: conexão, e não a placa.
O que fazer: desconecte e reconecte; ligue direto no computador, sem hub; troque de porta USB; tire os jumpers ligados aos pinos, que às vezes atrapalham a detecção; feche e reabra o menu Tools > Port para a lista se refazer. No Linux, confira também se o seu usuário está no grupo da porta serial.
A placa acende, mas nada é detectado.
Causa mais provável: cabo só de carga.
O que fazer: energia e dados são pares de fios diferentes dentro do mesmo cabo, e um cabo de carga tem só o primeiro par. Teste o cabo com outro aparelho que transfira arquivos, ou troque por um que você saiba ser de dados.
Compila, mas o upload falha.
Causa mais provável: placa errada selecionada.
O que fazer: confira Tools > Board antes de qualquer outra coisa. É o erro mais comum de quem tem duas placas na mesa: enviar para o Uno o que foi escolhido como ESP32-S3, ou o contrário.
O Monitor Serial mostra símbolos sem sentido.
Causa mais provável: velocidade diferente dos dois lados.
O que fazer: iguale o número do seletor do Monitor Serial ao número que está dentro do Serial.begin. Não é defeito, e a placa não precisa ser reiniciada.
O upload trava no ESP32-S3, com Failed to connect.
Causa mais provável: chip fora do modo de gravação.
O que fazer: segure o BOOT, aperte o RESET, solte o BOOT e tente de novo. Se o Monitor Serial estiver aberto na mesma porta, feche antes.
Código completo
Três arquivos, comentados linha a linha. São os mesmos que aparecem no meio da aula, aqui reunidos para você baixar de uma vez.
Os arquivos desta aula
blink.ino— o LED da própria placa acende e apaga a cada segundo. Grave este primeiro, no Uno.serial_uno.ino— o Uno escreve uma frase por segundo no Monitor Serial, a 9600.serial_esp32s3.ino— o mesmo no ESP32-S3 N16R8, a 115200, com os quatro ajustes anotados no cabeçalho do arquivo.
Os três são de domínio da aula: comentários em português, sem acento dentro do código (o Monitor Serial embaralha acentos) e com as constantes em MAIÚSCULAS, para você reconhecer de longe o que é ajuste e o que é lógica.
O esqueleto que se repete em todo sketch
Se você entender estas seis linhas, entendeu a forma de todo programa de Arduino — inclusive os das próximas aulas.
// aqui em cima: constantes e variáveis do programa inteiro
void setup() {
// prepara: pinMode, Serial.begin…
}
void loop() {
// trabalha: ler, decidir, escrever, esperar…
}
Não existe terceira parte obrigatória. Tudo o que um sketch faz cabe nessas duas funções ou em funções suas, chamadas por elas.
O que muda de uma placa para a outra
Você fez o mesmo trabalho duas vezes, e não por acaso: comparar os dois caminhos é o que mostra o que é essencial e o que é detalhe daquela placa.
| Nesta aula | Arduino Uno | ESP32-S3 DevKitC-1 N16R8 |
|---|---|---|
| Conector | Um só, USB-B (o quadradão de impressora) | Dois, USB-C: o UART, com ponte USB-serial, e o USB nativo do chip. Os dois alimentam e gravam |
| Suporte na IDE | Já vem instalado: é o catálogo da própria Arduino | Pede o endereço do Espressif em Additional boards manager URLs e a instalação do pacote esp32 |
Entrada em Tools > Board | Arduino Uno | ESP32S3 Dev Module, a entrada genérica que deixa configurar memória e USB |
| Ajustes de memória | Nenhum: o Uno tem uma configuração só | Flash Size em 16MB (128Mb) e PSRAM em OPI PSRAM — o N16 e o R8 do nome |
| Porta do Monitor Serial | A porta que a ponte ATmega16U2 cria | Depende: pela porta UART ou pela porta que o USB nativo cria quando USB CDC On Boot está em Enabled |
| Velocidade usual da Serial | 9600 nos exemplos | 115200 nos exemplos do fabricante |
| Quando o upload não entra | Costuma resolver trocando cabo, porta ou Tools > Board | Além disso, existe o gesto do modo de gravação: segurar BOOT, apertar e soltar RESET, soltar BOOT |
| LED da placa | LED simples marcado L, ligado a um pino por dentro | LED RGB endereçável; acender pede neopixelWrite, e não digitalWrite |
| Drivers | Original: nenhum driver extra. Clone com CH340 ou CP2102: driver do fabricante do chip | Pela porta USB nativa não há ponte no meio; pela porta UART vale a mesma conversa de chip e driver |
O mesmo programa, lado a lado
O que muda entre as duas placas, no código desta aula, é um número. Tudo o mais que muda está no menu Tools, não no sketch — e é exatamente por isso que os quatro ajustes merecem ser entendidos e não decorados.
Arduino Uno
serial_uno.inovoid setup() {
Serial.begin(9600);
}
void loop() {
Serial.println("A placa fala");
delay(1000);
}
Menu Tools: escolher Arduino Uno e a porta. Só isso.
ESP32-S3 N16R8
serial_esp32s3.inovoid setup() {
Serial.begin(115200);
}
void loop() {
Serial.println("O S3 fala");
delay(1000);
}
Menu Tools: ESP32S3 Dev Module, 16MB (128Mb), OPI PSRAM, USB CDC On Boot: Enabled — e a porta.
Onde este degrau aparece em IoT e robótica
Parece só instalação. Mas as três coisas que você fez aqui — escolher o alvo, gravar e escutar — são o ciclo de trabalho de qualquer projeto embarcado, para sempre.
A Serial é o instrumento de medida do software
Num robô, quando a roda não gira, a pergunta é sempre a mesma: o sensor leu errado ou a decisão foi errada? Serial.println no meio do loop responde, porque mostra o número que o programa realmente viu. É o equivalente, no software, de encostar a ponta do multímetro no fio — e é por isso que esta aula gasta uma seção inteira com ela.
Escolher a placa certa é escolher o mundo certo
O mesmo sketch compilado para o Uno e para o ESP32-S3 vira dois programas diferentes: pinos com outra numeração, memória de outro tamanho, periféricos que um tem e o outro não. Em IoT você troca de placa com frequência — do protótipo na bancada ao módulo dentro da caixa —, e o menu Tools é onde essa troca acontece.
Declarar a memória é o que separa um brinquedo de um projeto
Os 8 MB de PSRAM do N16R8 são o que permite guardar uma imagem de câmera, um buffer de rede grande ou uma tela colorida inteira. Se o PSRAM estiver no modo errado, essa memória não existe para o seu programa — e o projeto trava sem explicação quando cresce. Marcar OPI PSRAM hoje é evitar um mistério daqui a três meses.
A primeira gravação é sempre pelo cabo
Mais adiante, um ESP32 na parede pode receber programa novo pela rede. Mas a primeira vez é sempre pelo cabo, na sua mesa, com este mesmo procedimento — e é para o cabo que você volta quando a atualização pela rede falha. Saber gravar à mão é o plano de recuperação de todo dispositivo conectado.
Pratique até marcar tudo
Instalar uma vez não é aprender. Só passe adiante quando todos os “Eu consigo” estiverem marcados com honestidade. Tudo aqui fica salvo neste navegador.
Eu consigo…
Caixa Feynman
Explique, para alguém que nunca viu uma placa, o que a IDE faz e o que a placa faz. Se travar numa palavra, é ali que está a lacuna: volte à seção e tente de novo.
Salva sozinho enquanto você digitaAgora a Serial: explique por que o número do Serial.begin e o do seletor precisam ser iguais, e por que errar não gera mensagem de erro.
Flashcards
Clique para virar. Tente responder em voz alta antes.
Agenda de revisão espaçada
As datas contam a partir do dia em que você abriu esta página pela primeira vez. Revisar em intervalos crescentes é a técnica com mais evidência científica que existe para não esquecer — e sim, isto vale para instalar uma ferramenta: quem só faz uma vez esquece, e da próxima vez começa do zero de novo.
Exercício de revisão: a placa diz quem é e há quanto tempo acordou
Modifique o sketch da Serial para escrever, a cada segundo, o seu nome e o número de milissegundos desde que a placa ligou. Depois responda: por que o número reinicia quando você aperta o RESET, mas não reinicia quando você fecha e reabre o Monitor Serial no ESP32-S3 pela porta UART?
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.print("Fabricio, ligado ha ");
Serial.print(millis());
Serial.println(" ms");
delay(1000);
}
millis() conta desde o instante em que o programa começou a rodar. O RESET reinicia o programa, então a contagem volta a zero. Abrir e fechar o monitor é coisa do computador: no caminho pela ponte USB-serial do Uno, abrir a porta reinicia a placa — no ESP32-S3, pela porta UART, esse comportamento depende da placa e do circuito de reset dela. Se o seu número reiniciar, é isso; se não reiniciar, também é isso. Confira na sua placa e anote qual dos dois casos é o seu.
O seu roteiro de uma página
Escreva, com as suas palavras, o roteiro que você seguiria para instalar tudo de novo do zero: numa página, sem imagens, na ordem em que você travaria. Depois teste o roteiro do jeito mais honesto que existe: entregue a alguém que nunca abriu a IDE e fique calado enquanto a pessoa executa.
O que vale como pronto: a outra pessoa chegou ao LED piscando sem você falar. Cada vez que você precisou abrir a boca é uma linha que faltava no roteiro.
Ainda não: copiar esta página. O valor está em descobrir o que você considera óbvio e não é.
Se não tiver ninguém por perto, o substituto razoável é instalar num computador diferente — outra máquina, outro sistema operacional, outra conta de usuário — seguindo só o seu roteiro.
Sem placa na mão, e de onde saiu cada afirmação
Dois simuladores para quem ainda não tem o kit, e a lista completa das fontes oficiais desta aula.
Enquanto o kit não chega
Wokwi
Arduino Uno e ESP32-S3 no navegador, rodando o código de verdade. Monte: escolha um Arduino Uno, cole o Blink e rode; depois cole o sketch da Serial e abra o monitor do próprio simulador. Não substitui a instalação — mas deixa você aprender a estrutura do sketch antes de o cabo chegar.
Tinkercad Circuits
Protoboard virtual com Arduino e um Monitor Serial próprio. Útil para treinar o ciclo “escrever, rodar, ler a saída” sem nenhum hardware, e para a próxima aula, em que aparecem fios de verdade.
Fontes
Todo nome de menu, rótulo de opção, valor e procedimento desta aula foi conferido na documentação oficial da Arduino e do Espressif, em 6 e 7 de setembro de 2026. Onde a fonte oficial não afirma, esta aula também não afirma. Cada cartão diz o que aquela fonte prova.
Arduino — Downloading and installing the Arduino IDE 2
Prova os requisitos de sistema (Windows 10+, macOS 10.15+, Linux, todos de 64 bits), a instalação nos três sistemas, o AppImage marcado como executável, o FUSE e a regra udev da porta serial. As âncoras #windows, #macos e #linux desta aula são os id reais dos cabeçalhos dela.
Arduino — Software
É a origem dos arquivos de instalação, com entradas separadas para Windows (.exe, .msi, .zip), macOS Intel, macOS Apple Silicon e Linux (AppImage e ZIP) — e é onde se vê que os arquivos de macOS pedem versão 12 ou mais nova.
Arduino Help Center — Fix port access on Linux
Prova o que fazer no Linux quando a porta existe mas o usuário não tem permissão para usá-la, incluindo o grupo do sistema a que ele precisa pertencer.
Arduino Help Center — Fix udev rules on Linux
Prova o caminho completo das regras udev no Linux, com o script oficial que a Arduino distribui para isso.
Arduino Help Center — Change the language in Arduino IDE
Prova que o idioma original da interface é o inglês, onde fica o seletor de idioma, e que as traduções vêm da comunidade e nem todas estão completas.
Arduino — How to upload a sketch with the Arduino IDE 2
Prova que o visto é o verify e a seta é o upload, e que a seleção manual se faz por Tools > Board e Tools > Port.
Arduino — Using the Serial Monitor tool
Prova que o monitor é integrado à janela e que a velocidade é combinada por Serial.begin(9600).
Arduino — Blink
Prova o caminho File/Examples/01.Basics/Blink e o uso do LED da própria placa, sem nenhum fio.
Arduino Help Center — If your board is not detected by Arduino IDE
Prova que o cabo precisa ser de dados e não de carga, e a lista de verificações quando a porta não aparece.
Arduino Help Center — Windows Device Manager shows a warning sign
Prova que o pacote da placa basta e que nenhum driver adicional precisa ser instalado — e o que significa o triângulo amarelo.
Arduino Help Center — Add third-party platforms to the Boards Manager
Prova onde ficam as preferências e que o campo Additional boards manager URLs fica perto do fim da janela.
Arduino Help Center — Upload a sketch in Arduino IDE
Prova que o cabo precisa ser de dados (“a charge-only cable will not work”) e que o conector do UNO Rev3 é o USB-B.
Arduino — UNO R3, fonte oficial do datasheet
Prova o par ATmega328P e ATmega16U2, este último a ponte USB da placa, e o cabo USB-B para ligá-la ao computador.
Espressif — Arduino-ESP32, Installing
Prova o endereço estável do pacote e a instalação pelo Gerenciador de Placas, a partir de Tools > Board.
Espressif — Arduino-ESP32, Tools Menu
Prova o que USB CDC On Boot faz quando está em Enabled, que OPI PSRAM é PSRAM octal, que o sufixo R8 são 8 MB de PSRAM em modo OPI, e que errar o Flash Size estraga o esquema de partições.
Espressif — arduino-esp32, boards.txt
Prova os nomes exatos dos quatro itens de menu e dos valores marcados nesta aula. É a fonte única deles, aqui e na aula de entrada e saída digital.
Espressif — ESP32-S3-DevKitC-1, guia do usuário
Prova que segurar BOOT e apertar RESET inicia o modo de gravação, que os dois conectores USB alimentam e gravam, e que OT quer dizer SPI octal.
Os artigos do Arduino Help Center recusam requisição automatizada e respondem 403 para robôs; no navegador eles abrem normalmente. É um aviso conhecido do gate de links desta casa, não um link quebrado.
Glossário
- IDE
- Integrated Development Environment, ambiente integrado de desenvolvimento: o programa que reúne, numa janela só, o editor de texto, o tradutor, o gravador e o monitor. O desta aula é o Arduino IDE 2.
- Sketch
- O nome que o Arduino dá a um programa: o arquivo
.inocomsetup()eloop(). - Compilar
- Traduzir o texto do sketch para a linguagem de máquina do chip. Acontece no seu computador, antes de qualquer envio; é o que o botão do visto faz.
- Upload (carregar)
- Enviar o programa já traduzido para dentro da placa pelo cabo. É o que o botão da seta faz — e ela compila antes de enviar.
- Porta serial (COM)
- O canal de comunicação que o sistema cria quando a placa é reconhecida. No Windows tem nome
COM3,COM7; no Linux,/dev/ttyUSB0ou/dev/ttyACM0; no macOS,/dev/cu.…. É por ela que o programa entra e o texto volta. - Serial
- A conversa em uma via de cada vez entre a placa e o computador, feita ligando e desligando a tensão de um fio numa cadência combinada.
Serial.beginabre a conversa;Serial.printlnescreve uma linha nela. - Baud
- A cadência dessa conversa, em símbolos por segundo — nos casos desta aula, bits por segundo. É o número do
Serial.begine o do seletor do Monitor Serial. Diferentes, o texto vira lixo sem nenhuma mensagem de erro. - Monitor Serial
- A janela (na IDE 2, um painel embaixo) que mostra o que a placa escreve e permite mandar texto para ela.
- Bootloader
- Um programa pequeno que já vive dentro da placa e que, na hora certa, escuta a porta serial esperando um programa novo para gravar no lugar do antigo. É ele que faz o upload funcionar sem gravador externo.
- Modo de gravação
- O estado em que o chip espera firmware em vez de rodar o programa que já tem. No ESP32-S3 quase sempre ele entra sozinho; quando não entra, o gesto é segurar BOOT, apertar e soltar RESET e soltar BOOT.
- Driver
- O pedaço de software do sistema operacional que sabe conversar com um chip de hardware. Aqui interessa o driver do chip que faz a ponte USB da placa: sem ele, a porta não aparece na lista.
- Ponte USB-serial
- O chip que traduz o USB do computador na serial que o microcontrolador entende. No Uno original é o
ATmega16U2; em clones, umCH340ou umCP2102. - USB CDC
- Communications Device Class: a parte do padrão USB que faz um aparelho se apresentar ao computador como porta serial. O ESP32-S3 sabe fazer isso sozinho, sem ponte; é o que a opção
USB CDC On Bootliga. - Core (pacote de placas)
- O conjunto de arquivos que ensina a IDE a compilar e gravar para uma família de placas: compilador, bibliotecas básicas e a lista de opções do menu
Tools. O do Uno já vem instalado; o do ESP32-S3 é o pacoteesp32, do Espressif. - Gerenciador de Placas
- O catálogo de cores dentro da IDE: lista, instala e atualiza pacotes de placas. Só enxerga catálogos que ele conhece — daí o campo de endereços adicionais.
- Flash
- A memória onde o programa fica guardado, e que não se apaga quando a placa desliga. O
N16do N16R8 são 16 MB dela. - PSRAM
- Memória RAM extra, fora do núcleo e dentro do módulo, para dados grandes: imagens, buffers de rede, telas. O
R8do N16R8 são 8 MB dela, em modo octal (OPI). - AppImage
- Formato de aplicativo do Linux em arquivo único, que roda sem instalação. É como o Arduino IDE 2 é distribuído para Linux; precisa ser marcado como executável e depende do
FUSEno sistema. - udev / dialout
- No Linux,
udevé o subsistema que dá nome e permissão aos dispositivos ligados;dialouté, na maioria das configurações, o grupo de usuários com acesso direto às portas seriais. - LED_BUILTIN
- Apelido que o pacote da placa define para o pino do LED que já vem soldado nela. Escrever
LED_BUILTINem vez do número faz o mesmo sketch funcionar em placas diferentes.
Página autoral de Fabrício Ferreira, escrita do zero a partir da documentação oficial da Arduino e do Espressif. Nenhum material de curso é reproduzido aqui. Site independente, sem vínculo com fabricante nenhum.
Metodologia: prática de recuperação, revisão espaçada, previsão antes do teste, simuladores do mecanismo central e desmontagem de equívocos.