Fundamentos · 12 min de leitura

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.

Placa Arduino Uno e seus pinos
Cada número de pino no código corresponde a uma marcação na placa: a linha const int TRIG_PIN = 9 diz que o fio vai no furo marcado D9.

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ódigoO que fazLinha típicaComo reconhecer
ComentáriosExplicam o código; o compilador os ignora// anotação ou /* ... */Começam com // e aparecem em cinza no IDE
BibliotecasAcrescentam código pronto (servo, display, sensor)#include <Servo.h>Começam com #, bem no topo
Definições de pinos e constantesDão nomes aos números de pinos e aos limiaresconst int LED_PIN = 13;Geralmente nomes em MAIÚSCULAS
Variáveis e objetos globaisDados que você acessa de qualquer lugar do códigoint count = 0; Servo lidServo;Fora de todas as funções
setup()Roda uma vez, ao ligarpinMode(LED_PIN, OUTPUT);void setup() { ... }
loop()Repete sem parar; o trabalho de verdade acontece aquiif (distance < 20) { ... }void loop() { ... }
Suas próprias funçõesEmpacotam uma tarefa que se repetelong readDistanceCm() { ... }Blocos separados, acima ou abaixo do loop

Por onde começar a ler: um método em cinco passos

  1. 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.
  2. 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.
  3. 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).
  4. 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.
  5. 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.

C++ (Arduino IDE)
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}
LinhaO que fazO que acontece se você mudar?
#include <Servo.h>Adiciona a biblioteca Servo ao sketchApague-a e o compilador diz “'Servo' does not name a type”
const int TRIG_PIN = 9;Dá ao pino 9 o nome TRIG_PINSe mudar o fio de pino, você só altera esse número
const int OPEN_DISTANCE = 20;Distância-limite para abrir a tampaMude para 30 e a tampa abre de mais longe
Servo lidServo;Cria um objeto servo chamado lidServoTodas as linhas seguintes precisam usar o mesmo nome
int openCount = 0;Contador global, zero ao ligarLeve-o para dentro do loop() e ele zera a cada volta e sempre imprime 1
lidServo.attach(SERVO_PIN);Conecta o servo ao pino 6Esqueça essa linha e o servo nunca se move
long distance = readDistanceCm();Chama a função e guarda o resultadodistance só existe dentro do loop()
if (distance > 0 && distance < OPEN_DISTANCE)Entra no bloco se as duas condições forem verdadeirasdistance > 0 descarta o 0 retornado quando nenhum eco volta
delay(3000);Faz a placa esperar 3 segundosNesse tempo, o Arduino não verifica mais nada
return duration / 58;Converte o tempo do eco em centímetrosO 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.

TipoFaixa (Arduino Uno)Uso típico
int-32.768 a 32.767Números de pinos, valores de analogRead, contadores
longcerca de ±2,1 bilhõesDurações do pulseIn, números grandes
unsigned long0 a cerca de 4,29 bilhõesTempos de millis() e micros()
floatNúmeros decimais, 6–7 dígitos de precisãoContas de temperatura, tensão e distância
booltrue ou falseAlgo está ligado ou desligado?
byte0 a 255Valores de PWM, números pequenos
char / StringUm caractere / textoComandos 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.
Duas armadilhas passam fácil despercebidas na leitura de código. if (x = 5) não é uma comparação, e sim uma atribuição de 5 a x, então a condição é sempre verdadeira; a forma correta é if (x == 5). A segunda: o ponto e vírgula no fim de if (distance < 20); anula a condição, e o bloco de baixo roda em todas as voltas. O compilador não acusa erro em nenhum dos dois casos, então leia essas linhas com atenção redobrada.

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çãoO que fazExemplo
pinMode(pino, modo)Define um pino como entrada ou saídapinMode(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 LOWdigitalRead(2)
analogRead(pino)Transforma 0–5 V em um número de 0 a 1023analogRead(A0)
analogWrite(pino, 0–255)Ajusta o brilho de um LED ou a velocidade de um motor com PWManalogWrite(9, 128);
delay(ms)Pausa a placa pelo tempo indicadodelay(1000);
millis()Milissegundos desde que a placa foi ligadaif (millis() - last > 500)
Serial.begin / print / printlnEnvia texto para o Monitor SerialSerial.println(distance);
map(x, a, b, c, d)Converte uma faixa de valores em outramap(value, 0, 1023, 0, 180)
pulseIn(pino, HIGH)Mede a duração de um pulso em µspulseIn(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

  1. 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.
  2. 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á.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
O Monitor Serial é uma lanterna que você aponta para dentro do código. Se não consegue ver por que uma condição não dispara, coloque uma linha como Serial.println(distance) logo antes do if e veja qual valor está realmente sendo comparado. Há mais no nosso guia do Monitor Serial do Arduino.

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:

TemaArduino UnoESP32O que fazer
Nomes dos pinosD2–D13, A0–A5Números de GPIOTroque as constantes por números de GPIO; cuidado com os 6–11 e os 34–39
Tensão de operação5 V3,3 VColoque um divisor de tensão nos sensores com saída de 5 V (ECHO do HC-SR04)
analogRead10 bits, 0–102312 bits, 0–4095Recalcule os limiares e as faixas do map() para uma faixa quatro vezes maior
Biblioteca de servoServo.hESP32Servo.hTroque a biblioteca e informe a faixa de pulso no attach
Velocidade serialGeralmente 9600Geralmente 115200Iguale o Serial.begin e o Monitor Serial
Memória2 KB de RAMCerca de 320 KB de RAMArrays grandes e Strings deixam de ser problema
C++ (Arduino IDE)
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:

MicroPython
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

ErroPor que é um problemaO jeito certo
Tratar o código como uma lista que roda uma vez, de cima para baixoO loop() se repete para sempre e as variáveis mudam entre uma volta e outraAcompanhe o loop() por várias voltas, com valores diferentes
Confundir = com ==if (x = 5) é sempre verdadeiroUse sempre == para comparar
Não perceber a divisão inteira5 / 2 dá 2; a parte decimal é descartadaSe precisar de decimais, escreva 5.0 / 2 ou use um float
Esquecer que o delay() para tudoBotões e sensores não são lidos enquanto ele esperaUse temporização com millis() quando várias tarefas rodam juntas
Ignorar diferenças entre versões de bibliotecaA mesma função pode ter outro nome em uma versão mais novaProcure nos comentários com qual biblioteca o código foi escrito
Mudar uma constante de pino, mas não o fioO código lê o pino certo, mas o fio está em outro lugarAtualize sua tabela de ligações depois de cada mudança
Quando um sketch parecer difícil, comece reescrevendo-o em palavras simples: “Meça a distância. Se for maior que 0 e menor que 20, some um ao contador, acenda o LED, abra a tampa, espere 3 segundos, feche a tampa, apague o LED. Espere 100 ms e comece de novo.” Isso se chama pseudocódigo, e é o jeito mais rápido de captar o raciocínio de quem escreveu o programa.

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.

Ver todos os projetos
LED piscante
AR-1Iniciante

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.

4.6(200)
1246
Semáforo
AR-3Iniciante

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…

4.8(137)
440
Controle de LED com botão (momentâneo)
AR-9Iniciante

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.

4.8(114)
253
Luz noturna com LDR
AR-12Iniciante

Luz noturna com LDR

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

4.7(105)
224
Medição de distância com HC-SR04 (Monitor Serial)
AR-27Iniciante

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.

4.6(50)
82
Temperatura e umidade com DHT11
AR-55Intermediário

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…

4.7(47)
83
Sensor de estacionamento com HC-SR04
AR-28Intermediário
Premium

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.

4.8(64)
86
Uso de servo motor com potenciômetro
AR-36Iniciante
Premium

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.

4.6(37)
53