Como entender código Arduino: leia um sketch linha por linha
Como entender código Arduino: bibliotecas, definições de pinos, setup e loop, funções e condições if, um sketch de exemplo explicado linha por linha, ESP32 e Pico.
Saber como entender código Arduino é a diferença entre copiar um projeto torcendo para que funcione e torná-lo seu de verdade. Quase todo sketch que você encontra na internet, em livros ou com um amigo segue o mesmo esqueleto: bibliotecas e definições de pinos no topo, um setup() que roda uma vez no meio, um loop() que roda para sempre logo abaixo e, se for preciso, algumas funções próprias. Depois que você reconhece esse esqueleto, consegue olhar para um código que nunca viu e dizer “esta linha lê aquele pino e, neste caso, liga aquele motor”.
Neste guia você vai aprender um método passo a passo para ler código Arduino. Primeiro você vai conhecer as partes de um sketch e o que cada uma faz; depois vamos desmontar, linha por linha, o código de uma pequena lixeira cuja tampa abre quando uma mão se aproxima. Em seguida, vamos ver como ler variáveis, condições e funções, como adaptar o código de outra pessoa ao seu circuito e como levar o mesmo código para um ESP32 e um Raspberry Pi Pico. Por fim, você vai ver como praticar com a aba “Entenda o código” do BlueGrays.

A anatomia de um sketch Arduino
Os sketches Arduino seguem sempre a mesma ordem, de cima para baixo. O compilador lê o arquivo do começo ao fim, mas a placa o executa em outra ordem: primeiro as declarações globais são preparadas, depois o setup() roda uma vez e, então, o loop() se repete enquanto a placa tiver alimentação. A tabela resume as partes que você vai ver ao abrir um sketch e como reconhecê-las:
| Parte do código | O que faz | Linha típica | Como reconhecer |
|---|---|---|---|
| Comentários | Explicam o código; o compilador os ignora | // anotação ou /* ... */ | Começam com // e aparecem em cinza no IDE |
| Bibliotecas | Acrescentam código pronto (servo, display, sensor) | #include <Servo.h> | Começam com #, bem no topo |
| Definições de pinos e constantes | Dão nomes aos números de pinos e aos limiares | const int LED_PIN = 13; | Geralmente nomes em MAIÚSCULAS |
| Variáveis e objetos globais | Dados que você acessa de qualquer lugar do código | int count = 0; Servo lidServo; | Fora de todas as funções |
| setup() | Roda uma vez, ao ligar | pinMode(LED_PIN, OUTPUT); | void setup() { ... } |
| loop() | Repete sem parar; o trabalho de verdade acontece aqui | if (distance < 20) { ... } | void loop() { ... } |
| Suas próprias funções | Empacotam uma tarefa que se repete | long readDistanceCm() { ... } | Blocos separados, acima ou abaixo do loop |
Por onde começar a ler: um método em cinco passos
- Leia os comentários e as bibliotecas. As linhas #include entregam o hardware: Servo.h quer dizer um servo; LiquidCrystal_I2C.h, um LCD I2C; DHT.h, um sensor de temperatura.
- Anote as definições de pinos no papel. Transforme cada linha const int ou #define em uma lista de ligações como “TRIG = D9, ECHO = D10” e compare-a com o seu circuito.
- Leia o setup(). É aqui que você vê quais pinos são entradas e saídas, a velocidade serial e como a placa começa (servo fechado, LED apagado e assim por diante).
- Rode o loop() uma vez à mão. Escolha um valor para o sensor (digamos, 45 cm) e acompanhe o código linha por linha com ele; anote em qual bloco if você entra e quais variáveis mudam.
- Mergulhe nas funções quando precisar. Quando vir uma chamada como readDistanceCm() dentro do loop(), primeiro tente adivinhar pelo nome o que ela faz e depois abra a função para conferir o palpite.
Sketch de exemplo: uma análise linha por linha
Para praticar, escolhemos o código de um projeto real: um sensor de distância HC-SR04 percebe uma mão se aproximando, um servo abre a tampa e a fecha três segundos depois, um LED fica aceso nesse meio-tempo e o número de aberturas é impresso no Monitor Serial. O sketch tem uma biblioteca, constantes, uma variável global, um objeto, setup, loop, uma condição e uma função própria. Dê uma olhada no conjunto primeiro; depois vamos percorrê-lo linha por linha com a tabela.
1// Akıllı çöp kutusu: el yaklaşınca kapak açılır / Smart bin: the lid opens when a hand comes close
2#include <Servo.h> // servo kütüphanesi / servo library
3
4const int TRIG_PIN = 9; // HC-SR04 TRIG
5const int ECHO_PIN = 10; // HC-SR04 ECHO
6const int SERVO_PIN = 6; // servo sinyal kablosu / servo signal wire
7const int LED_PIN = 13; // durum LED'i / status LED
8const int OPEN_DISTANCE = 20; // bundan yakınsa aç (cm) / open if closer than this (cm)
9const int OPEN_ANGLE = 90; // açık kapak açısı / open lid angle
10const int CLOSED_ANGLE = 0; // kapalı kapak açısı / closed lid angle
11
12Servo lidServo; // servo nesnesi / servo object
13int openCount = 0; // kaç kez açıldı / how many times it opened
14
15void setup() {
16 Serial.begin(9600);
17 pinMode(TRIG_PIN, OUTPUT);
18 pinMode(ECHO_PIN, INPUT);
19 pinMode(LED_PIN, OUTPUT);
20 lidServo.attach(SERVO_PIN);
21 lidServo.write(CLOSED_ANGLE); // açılışta kapalı / closed at power-up
22}
23
24void loop() {
25 long distance = readDistanceCm(); // mesafeyi ölç / measure the distance
26 Serial.print("Mesafe / Distance: ");
27 Serial.println(distance);
28
29 if (distance > 0 && distance < OPEN_DISTANCE) {
30 openCount++; // sayacı bir artır / add one to the counter
31 digitalWrite(LED_PIN, HIGH);
32 lidServo.write(OPEN_ANGLE); // kapağı aç / open the lid
33 delay(3000); // 3 sn açık kal / stay open for 3 s
34 lidServo.write(CLOSED_ANGLE); // kapağı kapat / close the lid
35 digitalWrite(LED_PIN, LOW);
36 Serial.print("Acilma sayisi / Times opened: ");
37 Serial.println(openCount);
38 }
39 delay(100); // saniyede yaklaşık 10 ölçüm / about 10 readings per second
40}
41
42// Mesafeyi santimetre olarak döndürür / returns the distance in centimetres
43long readDistanceCm() {
44 digitalWrite(TRIG_PIN, LOW);
45 delayMicroseconds(2);
46 digitalWrite(TRIG_PIN, HIGH); // 10 µs tetik darbesi / 10 µs trigger pulse
47 delayMicroseconds(10);
48 digitalWrite(TRIG_PIN, LOW);
49 long duration = pulseIn(ECHO_PIN, HIGH, 30000); // en fazla 30 ms bekle / wait at most 30 ms
50 return duration / 58; // µs'yi cm'ye çevir / convert µs to cm
51}| Linha | O que faz | O que acontece se você mudar? |
|---|---|---|
| #include <Servo.h> | Adiciona a biblioteca Servo ao sketch | Apague-a e o compilador diz “'Servo' does not name a type” |
| const int TRIG_PIN = 9; | Dá ao pino 9 o nome TRIG_PIN | Se mudar o fio de pino, você só altera esse número |
| const int OPEN_DISTANCE = 20; | Distância-limite para abrir a tampa | Mude para 30 e a tampa abre de mais longe |
| Servo lidServo; | Cria um objeto servo chamado lidServo | Todas as linhas seguintes precisam usar o mesmo nome |
| int openCount = 0; | Contador global, zero ao ligar | Leve-o para dentro do loop() e ele zera a cada volta e sempre imprime 1 |
| lidServo.attach(SERVO_PIN); | Conecta o servo ao pino 6 | Esqueça essa linha e o servo nunca se move |
| long distance = readDistanceCm(); | Chama a função e guarda o resultado | distance só existe dentro do loop() |
| if (distance > 0 && distance < OPEN_DISTANCE) | Entra no bloco se as duas condições forem verdadeiras | distance > 0 descarta o 0 retornado quando nenhum eco volta |
| delay(3000); | Faz a placa esperar 3 segundos | Nesse tempo, o Arduino não verifica mais nada |
| return duration / 58; | Converte o tempo do eco em centímetros | O som vai e volta, então 1 cm equivale a cerca de 58 µs |
Agora vamos rodar o loop() à mão em duas situações diferentes. Sem ninguém na frente, o sensor mede 45 cm: distance passa a valer 45, o Monitor Serial mostra “Mesafe / Distance: 45”, a condição 45 < 20 é falsa e o bloco é pulado, a placa espera 100 ms e o loop() recomeça. Isso se repete umas dez vezes por segundo. Aproxime a mão até 12 cm e as duas condições são verdadeiras: openCount vai de 0 para 1, o LED acende, o servo gira até 90 graus, a placa espera três segundos, a tampa fecha, o LED apaga e o Monitor Serial imprime “Acilma sayisi / Times opened: 1”. Acompanhar o código com números reais, desse jeito, é a forma mais confiável de lê-lo.
Repare em mais um detalhe: se pulseIn() não receber nenhum eco em 30 ms, ela retorna 0. Sem a verificação distance > 0, o 0 medido quando o sensor aponta para o vazio contaria como “menor que 20” e a tampa abriria sem motivo. Um código bem escrito é cheio de pequenas verificações como essa; se você não entende por que uma linha está ali, apague-a temporariamente e veja o que acontece. Você encontra o funcionamento do sensor no nosso guia do sensor de distância HC-SR04 e a versão completa do projeto, com dois sensores, no guia da lixeira inteligente.
Variáveis e tipos de dados: etiquetas em caixas
Uma variável é uma caixa etiquetada em que você guarda um número ou um texto. A palavra no início da linha diz o tipo da caixa, ou seja, o que cabe dentro dela. No Arduino Uno, o tipo errado causa bugs silenciosos: guarde millis() em um int, por exemplo, e o número fica negativo depois de uns 32 segundos.
| Tipo | Faixa (Arduino Uno) | Uso típico |
|---|---|---|
| int | -32.768 a 32.767 | Números de pinos, valores de analogRead, contadores |
| long | cerca de ±2,1 bilhões | Durações do pulseIn, números grandes |
| unsigned long | 0 a cerca de 4,29 bilhões | Tempos de millis() e micros() |
| float | Números decimais, 6–7 dígitos de precisão | Contas de temperatura, tensão e distância |
| bool | true ou false | Algo está ligado ou desligado? |
| byte | 0 a 255 | Valores de PWM, números pequenos |
| char / String | Um caractere / texto | Comandos vindos da porta serial, texto para displays |
O lugar em que uma variável é declarada também importa; isso se chama escopo. No exemplo, openCount é declarada fora de todas as funções, então é global: o valor dela é mantido a cada vez que o loop() roda. Já distance é declarada dentro do loop(), então é local: é criada a cada volta e desaparece quando a volta termina. Uma variável com const na frente é uma constante e não pode mudar enquanto o programa roda. Para uma introdução mais aprofundada, veja nosso guia de fundamentos de programação Arduino e, para guardar vários valores em uma única variável, o guia de arrays no Arduino.
Como ler condições, laços e funções
- if / else if / else: leia como “se ..., faça isto; senão, faça aquilo”. As chaves { } mostram quais linhas dependem da condição.
- Comparações: == significa “igual a”, != “diferente de”, < “menor que”, >= “maior ou igual a”. && significa “e”, || “ou”, ! “não”.
- Laço for: leia for (int i = 0; i < 5; i++) como “comece com i em 0, repita enquanto i for menor que 5, some um a cada vez”; o bloco roda 5 vezes.
- Laço while: while (digitalRead(BUTTON_PIN) == HIGH) se lê como “espere enquanto o botão não for pressionado”; se a condição nunca mudar, o código fica preso ali.
- switch / case: o programa segue um caminho diferente conforme o valor de uma variável; esqueça o break no fim de um case e o case seguinte roda também.
- Definição de função: em long readDistanceCm(), long é o tipo do valor que ela retorna, readDistanceCm é o nome e os parênteses vazios indicam que ela não recebe parâmetros. Funções que começam com void não retornam nada; só executam uma tarefa.
Reconhecendo funções de biblioteca
Em uma linha como lidServo.write(90), o ponto indica que a função write pertence ao objeto lidServo: “lidServo, vá para 90 graus”. Há três jeitos fáceis de descobrir o que uma função de biblioteca faz: no Arduino IDE 2, passe o mouse sobre ela para ler a descrição ou clique com o botão direito e escolha Go to Definition (ir para a definição); abra os exemplos da própria biblioteca em Arquivo > Exemplos; ou consulte a lista de funções no arquivo .h da biblioteca. Explicamos como instalar bibliotecas no nosso guia como adicionar uma biblioteca no Arduino. Estas são as funções básicas que você vai encontrar em quase todo sketch:
| Função | O que faz | Exemplo |
|---|---|---|
| pinMode(pino, modo) | Define um pino como entrada ou saída | pinMode(13, OUTPUT); |
| digitalWrite(pino, valor) | Coloca uma saída em 5 V (HIGH) ou 0 V (LOW) | digitalWrite(13, HIGH); |
| digitalRead(pino) | Lê se uma entrada está em HIGH ou LOW | digitalRead(2) |
| analogRead(pino) | Transforma 0–5 V em um número de 0 a 1023 | analogRead(A0) |
| analogWrite(pino, 0–255) | Ajusta o brilho de um LED ou a velocidade de um motor com PWM | analogWrite(9, 128); |
| delay(ms) | Pausa a placa pelo tempo indicado | delay(1000); |
| millis() | Milissegundos desde que a placa foi ligada | if (millis() - last > 500) |
| Serial.begin / print / println | Envia texto para o Monitor Serial | Serial.println(distance); |
| map(x, a, b, c, d) | Converte uma faixa de valores em outra | map(value, 0, 1023, 0, 180) |
| pulseIn(pino, HIGH) | Mede a duração de um pulso em µs | pulseIn(10, HIGH, 30000) |
Para a lista completa, com exemplos detalhados, veja nosso guia de comandos do Arduino. Entender a diferença entre delay() e millis() é uma das coisas mais úteis para ler sketches; o guia millis ou delay explica isso com exemplos.
Adaptando o código de outra pessoa ao seu circuito
- Tire uma tabela de ligações do código. Escreva todas as constantes de pinos uma embaixo da outra; essa lista é o circuito de quem escreveu o código.
- Compare com o seu circuito. Se você usou pinos diferentes, não mexa nos fios: altere só os números nas linhas const e deixe o resto do código como está.
- Verifique diferenças entre bibliotecas. Duas bibliotecas com o mesmo nome podem usar funções diferentes; nos LCDs I2C, a diferença de endereço entre 0x27 e 0x3F também é a incompatibilidade mais comum.
- Fique de olho em ativo em LOW e ativo em HIGH. A maioria dos módulos relé liga com LOW; se o código liga as coisas com HIGH, seu relé vai fazer exatamente o contrário.
- Iguale a velocidade serial. Se o código tem Serial.begin(115200), selecione 115200 também no Monitor Serial, senão você vai ver caracteres sem sentido.
- Teste por partes. Rode primeiro só a parte que lê o sensor; depois acrescente o motor e o display, quando os valores estiverem fazendo sentido.
Levando o mesmo código para um ESP32
O ESP32 também é programado pelo Arduino IDE, então a maior parte do código roda do jeito que está; o que muda são os números dos pinos, o nível de tensão e algumas bibliotecas. A tabela lista o que conferir ao levar um código do Arduino Uno para um ESP32:
| Tema | Arduino Uno | ESP32 | O que fazer |
|---|---|---|---|
| Nomes dos pinos | D2–D13, A0–A5 | Números de GPIO | Troque as constantes por números de GPIO; cuidado com os 6–11 e os 34–39 |
| Tensão de operação | 5 V | 3,3 V | Coloque um divisor de tensão nos sensores com saída de 5 V (ECHO do HC-SR04) |
| analogRead | 10 bits, 0–1023 | 12 bits, 0–4095 | Recalcule os limiares e as faixas do map() para uma faixa quatro vezes maior |
| Biblioteca de servo | Servo.h | ESP32Servo.h | Troque a biblioteca e informe a faixa de pulso no attach |
| Velocidade serial | Geralmente 9600 | Geralmente 115200 | Iguale o Serial.begin e o Monitor Serial |
| Memória | 2 KB de RAM | Cerca de 320 KB de RAM | Arrays grandes e Strings deixam de ser problema |
1// ESP32 sürümü: değişen satırlar işaretli / ESP32 version: changed lines are marked
2#include <ESP32Servo.h> // DEĞİŞTİ: Servo.h yerine / CHANGED: instead of Servo.h
3
4const int TRIG_PIN = 26; // DEĞİŞTİ / CHANGED
5const int ECHO_PIN = 27; // DEĞİŞTİ: 1k/2k bölücüyle / CHANGED: through a 1k/2k divider
6const int SERVO_PIN = 18; // DEĞİŞTİ / CHANGED
7const int LED_PIN = 2; // DEĞİŞTİ: çoğu DevKit'te dahili LED / CHANGED: onboard LED on most DevKits
8const int OPEN_DISTANCE = 20;
9const int OPEN_ANGLE = 90;
10const int CLOSED_ANGLE = 0;
11
12Servo lidServo;
13int openCount = 0;
14
15void setup() {
16 Serial.begin(115200); // DEĞİŞTİ: ESP32'de yaygın hız / CHANGED: common ESP32 speed
17 pinMode(TRIG_PIN, OUTPUT);
18 pinMode(ECHO_PIN, INPUT);
19 pinMode(LED_PIN, OUTPUT);
20 lidServo.setPeriodHertz(50); // EKLENDİ: standart servo 50 Hz / ADDED: standard servo 50 Hz
21 lidServo.attach(SERVO_PIN, 500, 2400); // DEĞİŞTİ: darbe aralığı µs / CHANGED: pulse range in µs
22 lidServo.write(CLOSED_ANGLE);
23}
24
25void loop() {
26 long distance = readDistanceCm();
27 Serial.print("Mesafe / Distance: ");
28 Serial.println(distance);
29
30 if (distance > 0 && distance < OPEN_DISTANCE) {
31 openCount++;
32 digitalWrite(LED_PIN, HIGH);
33 lidServo.write(OPEN_ANGLE);
34 delay(3000);
35 lidServo.write(CLOSED_ANGLE);
36 digitalWrite(LED_PIN, LOW);
37 Serial.print("Acilma sayisi / Times opened: ");
38 Serial.println(openCount);
39 }
40 delay(100);
41}
42
43long readDistanceCm() {
44 digitalWrite(TRIG_PIN, LOW);
45 delayMicroseconds(2);
46 digitalWrite(TRIG_PIN, HIGH);
47 delayMicroseconds(10);
48 digitalWrite(TRIG_PIN, LOW);
49 long duration = pulseIn(ECHO_PIN, HIGH, 30000);
50 return duration / 58;
51}Como você vê, loop() e readDistanceCm() passaram para o outro lado sem mudar uma letra; tudo o que mudou está no topo do arquivo e no setup(). Isso é sinal de código bem escrito: os detalhes de hardware ficam reunidos no topo e a lógica, embaixo, continua limpa. Como o pino ECHO do HC-SR04 fornece 5 V, ele precisa chegar ao ESP32 por um divisor de tensão de 1 kΩ e 2 kΩ; o servo deve ser alimentado pelos 5 V do pino VIN, não por 3,3 V. Comparamos as outras diferenças entre as placas no nosso guia Arduino ou ESP32.
A mesma lógica em um Raspberry Pi Pico: MicroPython
Quando você programa o Pico em MicroPython, o código tem outra cara, mas a lógica é a mesma. Você escreve import no lugar de #include, e a indentação substitui as chaves. Não existem as palavras-chave setup() e loop(): as linhas do topo do arquivo rodam uma vez (a parte do setup) e o bloco while True: roda para sempre (a parte do loop). As funções começam com def em vez de void ou long. Coloque este código ao lado do sketch Arduino acima e você vai achar o equivalente de cada linha:
1from machine import Pin, PWM, time_pulse_us # #include karşılığı / the #include part
2import time
3
4TRIG = Pin(14, Pin.OUT) # HC-SR04 TRIG
5ECHO = Pin(15, Pin.IN) # HC-SR04 ECHO, bölücüyle / through a divider
6LED = Pin(25, Pin.OUT) # Pico dahili LED; Pico W'de Pin("LED") / onboard LED; Pin("LED") on Pico W
7servo = PWM(Pin(16))
8servo.freq(50) # servo 50 Hz ister / servos need 50 Hz
9
10OPEN_DISTANCE = 20 # cm
11
12
13def set_angle(angle):
14 pulse_us = 500 + angle * 2000 // 180 # 0 derece 0,5 ms, 180 derece 2,5 ms / 0 deg 0.5 ms, 180 deg 2.5 ms
15 servo.duty_u16(pulse_us * 65535 // 20000) # 20 ms periyodun oranı / share of the 20 ms period
16
17
18def read_distance_cm():
19 TRIG.low()
20 time.sleep_us(2)
21 TRIG.high() # 10 µs tetik darbesi / 10 µs trigger pulse
22 time.sleep_us(10)
23 TRIG.low()
24 duration = time_pulse_us(ECHO, 1, 30000) # zaman aşımında negatif / negative on timeout
25 if duration < 0:
26 return 0
27 return duration // 58
28
29
30set_angle(0) # setup() karşılığı / the setup() part
31open_count = 0
32
33while True: # loop() karşılığı / the loop() part
34 distance = read_distance_cm()
35 print("Mesafe / Distance:", distance)
36 if 0 < distance < OPEN_DISTANCE:
37 open_count += 1
38 LED.on()
39 set_angle(90)
40 time.sleep(3)
41 set_angle(0)
42 LED.off()
43 print("Acilma sayisi / Times opened:", open_count)
44 time.sleep_ms(100)Como o Python não tem uma biblioteca Servo aqui, a função set_angle() converte ela mesma o ângulo em uma largura de pulso: um servo define sua posição a partir de um pulso de 0,5–2,5 ms que chega a cada 20 ms. Escrever 0 < distance < OPEN_DISTANCE é a forma curta, em Python, da condição distance > 0 && distance < OPEN_DISTANCE do C++. Se você está começando no MicroPython, nosso guia de fundamentos de MicroPython cobre as regras de indentação, variáveis e funções.
Praticando com o “Entenda o código” no BlueGrays
No app BlueGrays, a tela de código de cada projeto também tem uma aba “Entenda o código”. A seção “O que este código faz?” primeiro resume o trabalho do programa em poucas frases. Depois, “Passo a passo” divide o código em pequenos trechos e explica, embaixo de cada um, para que servem aquelas linhas e o que acontece se você mudá-las. “Se precisar de ajuda” lista os problemas mais comuns como sintoma e solução, e “Experimente você mesmo” traz uma pequena tarefa com dica e solução, como mudar o limiar de uma luz noturna para o LED acender mais cedo. Você também pode usar ali o método de cinco passos deste guia: leia o resumo, relacione cada trecho com o seu circuito e depois resolva a tarefa alterando o código por conta própria.
Exercícios para ler código
- Preveja, depois teste: antes de mudar uma constante, escreva o que você espera que aconteça; depois carregue o código e confira a previsão.
- Comente uma linha: coloque // na frente de uma linha e carregue de novo; o que deixar de funcionar mostra para que servia aquela linha.
- Explique com suas palavras: transforme cada linha do loop() em uma frase simples; uma linha que você não consegue pôr em palavras é uma linha que você ainda não entendeu.
- Desenhe um fluxograma: rabisque o setup, o loop, os if e as chamadas de função como caixas e setas; ajuda muito em códigos que usam uma máquina de estados.
- Erre de propósito: apague um ponto e vírgula e leia a mensagem do compilador; nosso guia de erros de compilação do Arduino explica os mais comuns.
Erros comuns ao ler código
| Erro | Por que é um problema | O jeito certo |
|---|---|---|
| Tratar o código como uma lista que roda uma vez, de cima para baixo | O loop() se repete para sempre e as variáveis mudam entre uma volta e outra | Acompanhe o loop() por várias voltas, com valores diferentes |
| Confundir = com == | if (x = 5) é sempre verdadeiro | Use sempre == para comparar |
| Não perceber a divisão inteira | 5 / 2 dá 2; a parte decimal é descartada | Se precisar de decimais, escreva 5.0 / 2 ou use um float |
| Esquecer que o delay() para tudo | Botões e sensores não são lidos enquanto ele espera | Use temporização com millis() quando várias tarefas rodam juntas |
| Ignorar diferenças entre versões de biblioteca | A mesma função pode ter outro nome em uma versão mais nova | Procure nos comentários com qual biblioteca o código foi escrito |
| Mudar uma constante de pino, mas não o fio | O código lê o pino certo, mas o fio está em outro lugar | Atualize sua tabela de ligações depois de cada mudança |
Ler código, assim como ler um esquema do circuito, fica mais rápido a cada exemplo que você vê. Para começar, abra projetos curtos no app BlueGrays, como acender um LED, o semáforo, o LED controlado por botão ou a luz noturna com LDR, e acompanhe a aba “Entenda o código” linha por linha; cada um vem com o esquema do circuito, uma explicação do código trecho por trecho e uma pequena tarefa para você.
Perguntas frequentes
Em que linguagem o código Arduino é escrito?
O código Arduino é baseado em C e C++. O Arduino acrescenta funções prontas, como pinMode e digitalWrite, para facilitar as coisas, mas as regras para condições if, laços for, variáveis e funções são C++ puro. Por isso, um pouco de conhecimento de C++ deixa o código Arduino bem mais fácil de ler.
Qual é a diferença entre setup e loop?
O setup() roda uma única vez, quando a placa liga ou reinicia, e serve para preparativos como configurar os pinos e a comunicação serial. Depois, o loop() se repete sem parar enquanto a placa tiver alimentação; é ali que o trabalho de verdade acontece, como ler sensores, tomar decisões e acionar motores.
O que significa void no Arduino?
void quer dizer que uma função não retorna nenhum valor. void setup() e void loop() fazem coisas, mas não devolvem um resultado. Já uma função como long readDistanceCm() retorna, usando return, um valor do tipo escrito antes do nome dela.
Por que meu código compila, mas o circuito não funciona?
O compilador só verifica a sintaxe; um número de pino errado, um módulo ligado ao contrário ou um limiar ruim não causam erro de compilação. Compare as constantes de pinos do código com o seu circuito e acompanhe os valores com Serial.println no Monitor Serial; o problema costuma estar na ligação ou em um limiar.
Posso usar código Arduino em um ESP32?
Na maioria das vezes, sim: o ESP32 também é programado pelo Arduino IDE e as funções básicas são as mesmas. Você vai precisar trocar os números dos pinos por números de GPIO, baixar os sinais de 5 V para 3,3 V e substituir algumas bibliotecas, como a Servo, pelas versões para ESP32. Lembre-se também de que o analogRead retorna valores de 0 a 4095.
Onde encontro exemplos de código Arduino?
O menu Arquivo > Exemplos do Arduino IDE é um ótimo ponto de partida, junto com os exemplos que vêm com cada biblioteca que você instala. Os projetos do app BlueGrays também vêm com esquema do circuito e código explicado linha por linha. Venha o código de onde vier, lê-lo uma vez com o método deste guia antes de carregar ajuda você a pegar os erros logo de cara.
Projetos para montar depois desta leitura
Ver todos os projetos
LED piscante
O primeiro contato com a eletrônica: acender e apagar um único LED. O Arduino acende e apaga o LED em intervalos curtos, fazendo a luz piscar rapidamente.

Semáforo
Uma pequena versão do semáforo que você vê na rua todos os dias. O vermelho fica aceso por dois segundos, o amarelo acende por um instante, o verde fica aceso por dois segundos e depois volta ao…

Controle de LED com botão (momentâneo)
É como uma campainha: a luz fica acesa enquanto você pressiona o botão e apaga quando você solta.

Luz noturna com LDR
Uma pequena luz noturna que acende sozinha quando escurece e apaga ao amanhecer.

Medição de distância com HC-SR04 (Monitor Serial)
O sensor HC-SR04 funciona como um morcego que se orienta no escuro: emite um som que você não consegue ouvir, escuta o eco e mede a distância até o objeto à sua frente.

Temperatura e umidade com DHT11
Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

Sensor de estacionamento com HC-SR04
Uma versão em miniatura do sensor de estacionamento de um carro: quanto mais perto um objeto chega, mais rápidos ficam os bipes.

Uso de servo motor com potenciômetro
Conforme você gira o botão do potenciômetro, o braço do servo motor gira junto: uma extremidade do botão corresponde a zero grau, e a outra, a meia volta.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

