Primeiro programa no Arduino Uno R3

Um microcontrolador é um circuito integrado que reúne, no mesmo chip, um processador, memórias e periféricos. Ele executa um programa e interage com sinais do mundo externo.

No Uno R3, o microcontrolador principal é o ATmega328P. Pense nele como a parte que efetivamente recebe e executa o firmware. A placa ao redor dele oferece recursos para usar esse chip com mais facilidade.

Quando você gravar seu primeiro sketch, o firmware ficará na Flash. Durante a execução, o processador usa a SRAM como área temporária de trabalho. A EEPROM pode conservar dados mesmo após desligar a placa, mas você ainda não vai programá-la neste tutorial.

O microcontrolador é o chip. A placa de desenvolvimento é o conjunto que torna o chip prático para estudar e prototipar.

No Arduino Uno R3, a placa inclui o ATmega328P e acrescenta alimentação, conector USB, botão de reset, conectores para sinais e uma interface para conexão com o computador. Portanto, “Uno R3” não é apenas o microcontrolador: é a placa inteira.

Associe cada bloco à sua função principal.

Nesta prática, a referência é o Arduino Uno R3, baseado no microcontrolador ATmega328P e em um clock de 16 MHz. É essa combinação que será usada nos exemplos e nas seleções da ferramenta.

Não trate um Uno R4 ou outra placa como substituição automática: modelos podem usar outro microcontrolador, outra arquitetura e outro modo de conexão. Se sua placa não for um Uno R3, acompanhe a explicação, mas confira a documentação específica dela antes de gravar programas.

Legenda dos marcadores da imagem

• Vermelho — ATmega328P: chip preto maior, geralmente retangular e com duas fileiras de terminais, na região central da placa. É o microcontrolador principal.
• Azul — conector USB: conector metálico grande em uma extremidade da placa. É onde entra o cabo para comunicação com o computador e alimentação nesta prática.
• Amarelo — botão RESET: botão pequeno próximo ao conector USB. Ele reinicia a execução; você não precisa pressioná-lo agora.
• Verde — conectores de pinos: fileiras de furos ou pinos nas bordas. Eles servem para conexões futuras; permaneça sem nada conectado neles neste tutorial.

Faça as associações entre cada marcador da imagem e o elemento indicado.

Antes de conectar, separe:

• um computador com internet e permissão para instalar programas;
• um Uno R3 próprio;
• um cabo USB compatível com o conector da placa e capaz de transmitir dados.

Alguns cabos USB servem apenas para carregar. Eles podem alimentar a placa, mas não permitem que o computador reconheça a conexão para gravar o programa. Use um cabo de dados conhecido ou teste outro cabo se a placa não aparecer mais adiante.

Coloque a placa sobre uma superfície não condutora e deixe-a sem shields, jumpers, sensores ou qualquer carga externa.

Escolha a preparação adequada para instalar a IDE e, depois, reconhecer o Uno R3.

Para esta prática, instale no seu computador uma versão estável da IDE Arduino compatível com seu sistema operacional, obtida no site oficial do Arduino. O download e a instalação podem levar alguns minutos, conforme sua conexão e computador.

Abra a IDE após concluir a instalação. Se houver a opção de idioma nas preferências, você pode selecionar Português (Brasil); os nomes de alguns menus podem variar um pouco entre versões.

A IDE precisa conhecer a família de microcontroladores da placa. Abra o Gerenciador de Placas, procure por Arduino AVR Boards e instale o pacote se ele ainda não estiver instalado. Se aparecer como instalado, mantenha-o confirmado.

Para o Uno R3 desta prática, esse é o pacote correto. Não instale pacotes de outras arquiteturas nem bibliotecas adicionais agora.

Com o Uno R3 conectado somente pelo cabo USB de dados, abra o seletor de placa e porta da IDE. Escolha Arduino Uno entre as opções associadas ao pacote Arduino AVR Boards.

Em seguida, observe a lista de portas. A porta correta costuma aparecer quando você conecta a placa e desaparecer quando a desconecta. O nome varia conforme o sistema: não dependa de um número ou rótulo fixo, nem suponha que a IDE reconhecerá o modelo automaticamente.

Um sketch é o programa que você escreve para a placa no ambiente Arduino. Ele usa C++ com a estrutura adotada pelo Arduino.

Neste primeiro sketch, você vai reconhecer apenas duas partes obrigatórias: setup e loop. Por enquanto, elas não comandarão pinos, LEDs nem outros componentes.

Na IDE Arduino do seu computador, crie um sketch novo. Apague qualquer conteúdo inicial do editor e digite ou cole o código completo abaixo. Não use um exemplo pré-instalado: este é o seu ponto de partida.

Digite este programa completo no editor da IDE.

Agora salve no seu computador:

1. Use Arquivo > Salvar (ou o atalho mostrado pela sua IDE).
2. Escolha uma pasta que você consiga localizar depois.
3. Dê um nome simples, sem espaços nem acentos, por exemplo: primeiro_sketch.
4. Confirme que o arquivo salvo tem a extensão .ino — por exemplo, primeiro_sketch.ino.

Antes de seguir, confira no editor se os dois blocos, setup e loop, continuam presentes.

Complete os símbolos que faltam para formar a estrutura válida de um sketch mínimo. Considere cada chave de abertura e fechamento como parte do bloco correspondente.

Ao ligar a placa — e também depois de um reset — o ambiente Arduino executa primeiro setup() uma vez. Quando esse bloco termina, o ambiente passa a chamar loop() repetidamente.

Você não precisa, nem deve, escrever uma chamada de loop() dentro deste sketch. A repetição é fornecida pelo ambiente Arduino.

Abra mentalmente o sketch mínimo salvo como primeiro_sketch.ino. Os dois blocos existem mesmo que tenham apenas comentários. Comentários não são executados; portanto, este programa ainda não define uma ação visível na placa.

Quando um loop() vazio é chamado, ele termina imediatamente. Isso não para o ciclo: o ambiente volta a chamá-lo.

Sketch mínimo salvo anteriormente. Por enquanto, os comentários apenas descrevem os blocos.

Organize o que ocorre ao ligar a placa ou ao reiniciá-la pelo botão RESET. Considere que, depois da última etapa, o ambiente continua chamando loop() novamente.

O botão RESET reinicia a execução da placa. Ele não apaga o firmware gravado na Flash: essa memória mantém o sketch sem alimentação. Após o reset, a placa volta a executar setup() uma vez e depois retoma as chamadas repetidas de loop().

Como os dois blocos do sketch atual não definem uma saída, o reset não oferece, por si só, um efeito funcional programado para observar.

Seu arquivo .ino contém o código-fonte: texto que você pode ler e editar. Antes de gravá-lo no Uno, a IDE precisa compilá-lo, isto é, preparar um firmware executável compatível com a placa selecionada.

Na IDE Arduino, use o comando Verificar (ícone de marca de seleção). Confira antes se o alvo continua como Arduino Uno. Para esta etapa, a placa não precisa estar conectada: a compilação prepara o programa, mas não o transfere para nenhum dispositivo.

Uma chave { abre um bloco e a chave } correspondente o fecha. Um desencontro entre elas pode impedir a compilação. Compare o sketch abaixo com a estrutura que você salvou e complete a única chave ausente.

A confirmação de compilação responde apenas que a IDE conseguiu preparar o firmware a partir do código e do alvo selecionado.

Ela não mostra que o firmware foi enviado ao Uno e também não prova que o programa está produzindo o comportamento esperado. No sketch atual, setup e loop não definem nenhuma ação observável pelo aluno.

A compilação anterior preparou o firmware para o alvo selecionado. Agora, gravar/carregar transfere esse firmware para a memória Flash do ATmega328P no seu Uno R3.

A gravação substitui o sketch que já estava na Flash. Depois dela, a placa reinicia e passa a iniciar o novo sketch. Como este sketch mínimo tem setup() e loop() vazios, ele não foi programado para produzir uma indicação visual.

Com a placa conectada, confira uma última vez se o alvo é Arduino Uno e se a porta exibida é a da sua placa. Em seguida, na IDE, use o comando Carregar (ícone de seta para a direita; em algumas versões pode aparecer como “Upload”).

Esse comando primeiro prepara/compila o firmware e, se não houver erro, inicia a transferência. Durante o processo, mantenha o cabo conectado e não pressione RESET.

Aguarde a mensagem final da área de resultados. Procure uma confirmação de carregamento, como “Carregamento concluído” ou mensagem equivalente da sua versão da IDE. A mensagem de compilação bem-sucedida que aparece antes não confirma, sozinha, que a transferência terminou.

Coloque as etapas abaixo na ordem em que ocorrem em uma gravação bem-sucedida.

Se o carregamento falhar, não avance para procedimentos de recuperação do bootloader. Confira uma condição por vez:

1. A seleção está em Arduino Uno?
2. A porta selecionada é a que aparece quando a placa é conectada?
3. O cabo USB transmite dados e está bem conectado?
4. Outro programa pode estar usando a mesma porta?

Depois de alterar uma condição, tente carregar novamente. Isso ajuda a relacionar a mudança ao resultado, em vez de mudar tudo ao mesmo tempo.

Do arquivo salvo à execução

Nem toda mensagem ou luz é uma prova funcional

Se sua placa ainda estiver conectada e sem circuito externo, você pode pressionar e soltar uma vez o botão RESET. Pelo modelo estudado, preveja: a execução reinicia, setup() é chamado uma vez e, depois, loop() volta a ser chamado repetidamente.

Como o sketch atual não define uma saída observável, separe essa previsão do que você realmente conseguiu observar. Não altere o código nem conecte componentes nesta revisão.