Projetos Arduino para as férias de inverno: plano de 14 dias passo a passo
Projetos Arduino para as férias de inverno em um plano de 14 dias: um projeto por dia com um kit iniciante, três caminhos para Uno, ESP32 e Pico, lista de materiais e projeto final.
A melhor forma de encarar projetos Arduino nas férias de inverno é passar duas semanas com pequenos projetos que se apoiam no anterior, em vez de fazer experimentos aleatórios. Neste guia você encontra um plano pronto: trabalhando 1–2 horas por dia com um kit iniciante, em 14 dias você vai de acender um LED a ler sensores, de escrever em um display a controlar um motor. O projeto de cada dia, os componentes necessários e o link para um post aprofundado sobre o tema estão listados um a um; no fim das férias você terá um projeto final que junta tudo o que aprendeu.
O plano pode ser adaptado a três caminhos: o Arduino Uno para quem não tem experiência, o ESP32 para quem já sabe o básico e quer conectar o projeto à internet, e o Raspberry Pi Pico para quem quer aprender Python. Os temas dos dias são os mesmos nos três caminhos; só mudam a placa, os números dos pinos e a linguagem de programação. Se você ainda não tem uma placa, pode fazer os primeiros dias em uma simulação no Wokwi ou no Tinkercad e passar para o circuito real quando os componentes chegarem.
Antes de começar: quais componentes você precisa?
Quase tudo da lista abaixo vem nos kits iniciantes comuns. Se faltar alguma coisa no seu kit, basta mudar a ordem dos dias; por exemplo, se você não tiver servo, pode trocar o dia 13 por um projeto de melodia com buzzer. Se não souber qual kit comprar, o post kit Arduino iniciante compara os conteúdos em detalhes.
| Componente | Qtd. | Dias em que é usado |
|---|---|---|
| Arduino Uno, ESP32 ou Raspberry Pi Pico + cabo USB | 1 | Todos os dias |
| Protoboard e jumpers macho-macho | 1 + 30 | Todos os dias |
| LED (vermelho, amarelo, verde) | 6–8 | 1, 2, 3, 6, 7, 9, 11 |
| Resistor de 220 Ω | 8 | 1, 2, 3, 6, 7, 11 |
| Resistor de 10 kΩ | 2 | 7 |
| Resistor de 1 kΩ (divisor de tensão para ESP32 e Pico) | 3 | 10, 11 |
| Botão de pressão | 2 | 4, 7, 9 |
| Potenciômetro de 10 kΩ | 1 | 5, 13 |
| LED RGB | 1 | 6 |
| LDR | 1 | 7 |
| Buzzer passivo | 1 | 8, 11 |
| Sensor de distância HC-SR04 | 1 | 10, 11 |
| Sensor de temperatura e umidade DHT11 | 1 | 12 |
| Display LCD I2C 16x2 | 1 | 12, 14 |
| Servo motor SG90 | 1 | 13, 14 |
Qual caminho escolher: Uno, ESP32 ou Pico?
As três placas dão conta do plano inteiro, mas cada uma oferece uma experiência de aprendizado diferente. O Uno trabalha com 5 V, então se conecta diretamente a todos os módulos do kit, e a maioria dos exemplos na internet é escrita para ele; se é seu primeiro contato com eletrônica, é o caminho mais fácil para encontrar erros. O ESP32 é programado na mesma linguagem do Arduino, mas o processador dual-core de 240 MHz, o Wi-Fi e o Bluetooth permitem acompanhar o projeto final pelo celular; em troca, você precisa lembrar que os pinos dele são de 3,3 V. O Pico permite escrever código em MicroPython e ver ele rodar assim que você salva; se você estuda Python na escola, leva esse conhecimento direto para o hardware. Se estiver em dúvida, dê uma olhada na comparação Arduino ou ESP32.
| Caminho | Para quem é | Linguagem e editor | Pontos fortes | Atenção |
|---|---|---|---|---|
| Arduino Uno | Quem está começando na eletrônica | Arduino C++, Arduino IDE | Pinos de 5 V, funciona direto com todos os módulos do kit, mais exemplos de código | Sem Wi-Fi, só 2 KB de RAM |
| ESP32 | Quem já sabe o básico e quer se conectar à internet | Arduino C++, Arduino IDE (pacote da placa ESP32) | Wi-Fi e Bluetooth, dual-core de 240 MHz, ADC de 12 bits | Pinos de 3,3 V; sensores com sinal de 5 V precisam de divisor de tensão |
| Raspberry Pi Pico | Quem quer aprender Python | MicroPython, Thonny | Roda na hora, sem esperar compilação, dual-core de 133 MHz, preço baixo | Pinos de 3,3 V; o Pico clássico não tem conexão sem fio (o Pico W tem) |
Rotina diária: a regra de 1–2 horas
- Primeiros 15 minutos, leitura: Leia o post indicado para o dia e desenhe no papel o esquema do circuito e a tabela de pinos.
- 30–45 minutos, montagem e código: Monte o circuito com o cabo USB desconectado, confira as ligações mais uma vez e só então carregue o código.
- 20 minutos, modificação: Depois que o código funcionar, mude pelo menos uma coisa por conta própria: o tempo, o pino, o valor limite ou a quantidade de LEDs. É aqui que o aprendizado de verdade acontece.
- 10 minutos, anotações: Escreva em um caderno o que você fez, onde travou e como resolveu; essas anotações vão economizar muito tempo no projeto final.
- Dias flexíveis: Se você ficar doente ou um projeto demorar mais, pode usar os dias 7 e 14 como dias de recuperação.
Semana 1: o básico (dias 1–7)
O objetivo da primeira semana é aprender na prática quatro conceitos fundamentais: saída digital, entrada digital, leitura analógica e PWM. Cada dia acrescenta mais ou menos um comando novo e um componente novo; no fim do dia 7 você vai usar com tranquilidade pinMode, digitalWrite, digitalRead, analogRead, analogWrite e Serial.println.
- Dia 1 – Acender um LED: Rode o Blink com o LED integrado da placa, depois ligue um LED externo ao D13 na protoboard, com um resistor de 220 Ω, e mude o tempo de piscada. Componentes: placa, protoboard, 1 LED, 1 resistor de 220 Ω. Leia: Como usar a protoboard, Como calcular o resistor do LED.
- Dia 2 – Semáforo: Ligue LEDs vermelho, amarelo e verde ao D10, D9 e D8 e use delay para imitar a sequência de luzes de um cruzamento real. Componentes: 3 LEDs, 3 resistores de 220 Ω. Leia: Semáforo com Arduino.
- Dia 3 – LEDs sequenciais e Super Máquina: Aprenda a usar um laço for e um array de pinos enquanto acende 6 LEDs em sequência. Componentes: 6 LEDs, 6 resistores de 220 Ω. Leia: Efeito Super Máquina e LEDs sequenciais, Como usar arrays no Arduino.
- Dia 4 – LED com botão: Primeiro faça um LED que fica aceso enquanto você segura o botão, depois um que alterna o estado a cada toque; aqui você aprende INPUT_PULLUP e debounce. Componentes: 1 botão, 1 LED, 1 resistor de 220 Ω. Leia: Como ligar um botão no Arduino, Resistores de pull-up e pull-down.
- Dia 5 – Potenciômetro e Monitor Serial: Leia valores de 0–1023 com analogRead, acompanhe no Monitor Serial e use map para transformar o valor na velocidade de piscada do LED. Componentes: potenciômetro de 10 kΩ, 1 LED. Leia: O que é potenciômetro, Como usar o Monitor Serial, A função map.
- Dia 6 – PWM e LED RGB: Acenda e apague um LED devagar com analogWrite (efeito de respiração), depois misture os três canais do LED RGB para criar sua própria cor. Componentes: 1 LED RGB, 3 resistores de 220 Ω. Leia: O que é PWM, Como usar um LED RGB.
- Dia 7 – Luz noturna com LDR e revisão da semana: Ligue o LDR com um resistor de 10 kΩ como divisor de tensão e acenda o LED quando o ambiente escurecer. Na segunda metade do dia, monte o semáforo com botão de pedestre mostrado abaixo. Componentes: LDR, resistor de 10 kΩ, 3 LEDs, botão. Leia: Sensor de luz LDR, Divisor de tensão.
O projeto de encerramento da semana 1 junta em um só circuito o que você aprendeu nos dias 2, 4 e 5: um semáforo que fica verde para os carros; quando um pedestre aperta o botão, ele passa para amarelo, depois vermelho, e volta ao verde depois de cinco segundos. O botão é ligado entre o D2 e o GND; graças ao resistor de pull-up interno, você não precisa de um resistor externo, e o pino lê LOW quando o botão é pressionado.
1// Yaya butonlu trafik lambası / Pedestrian button traffic light
2const int RED_PIN = 10; // kırmızı LED / red LED
3const int YELLOW_PIN = 9; // sarı LED / yellow LED
4const int GREEN_PIN = 8; // yeşil LED / green LED
5const int BUTTON_PIN = 2; // buton, diğer ucu GND / button, other leg to GND
6
7void setup() {
8 pinMode(RED_PIN, OUTPUT);
9 pinMode(YELLOW_PIN, OUTPUT);
10 pinMode(GREEN_PIN, OUTPUT);
11 pinMode(BUTTON_PIN, INPUT_PULLUP); // basılınca LOW okunur / reads LOW when pressed
12 digitalWrite(GREEN_PIN, HIGH); // araçlara yeşil / green for cars
13 Serial.begin(9600);
14}
15
16void loop() {
17 if (digitalRead(BUTTON_PIN) == LOW) {
18 Serial.println("Yaya istegi / Pedestrian request");
19 delay(1000);
20 digitalWrite(GREEN_PIN, LOW);
21 digitalWrite(YELLOW_PIN, HIGH); // sarı: yavaşla / yellow: slow down
22 delay(2000);
23 digitalWrite(YELLOW_PIN, LOW);
24 digitalWrite(RED_PIN, HIGH); // araçlar durur, yaya geçer / cars stop, pedestrians cross
25 delay(5000);
26 digitalWrite(YELLOW_PIN, HIGH); // kırmızı + sarı: hazırlan / red + yellow: get ready
27 delay(1500);
28 digitalWrite(RED_PIN, LOW);
29 digitalWrite(YELLOW_PIN, LOW);
30 digitalWrite(GREEN_PIN, HIGH);
31 delay(3000); // art arda basmayı engelle / ignore repeated presses
32 }
33}O delay(3000) no final do código impede que o semáforo volte a ficar vermelho logo em seguida se um pedestre apertar o botão várias vezes; semáforos reais usam um tempo de espera parecido. Como modificação sua, tente deixar o tempo do vermelho ajustável com um potenciômetro, ou fazer o buzzer dar bipes curtos enquanto o vermelho estiver aceso. O ponto fraco desse código é que a placa não consegue fazer mais nada enquanto o delay está rodando; no dia 9 você vai resolver isso com millis.
Semana 2: som, tempo, sensores e display (dias 8–14)
Na segunda semana a placa começa a medir o mundo lá fora e a mostrar os resultados. Nesses dias você vai instalar uma biblioteca pela primeira vez, medir tempo com precisão de microssegundos e escrever texto em um display. Como os projetos são um pouco mais longos, não hesite em dividir um dia em dois se precisar; o plano não é uma corrida, é uma forma de criar um hábito.
- Dia 8 – Buzzer e melodia: Toque notas com tone(pino, frequência, duração); 262 Hz é dó, 294 Hz é ré, 330 Hz é mi. O buzzer ativo dá um único som fixo; para melodias, você precisa de um buzzer passivo. Componentes: buzzer passivo. Leia: O que é buzzer.
- Dia 9 – millis em vez de delay: Consiga ler o botão enquanto um LED pisca uma vez por segundo. Essa é a base do projeto final; todo projeto que faz várias coisas ao mesmo tempo usa millis ou uma máquina de estados. Componentes: 2 LEDs, botão. Leia: millis ou delay, Máquina de estados no Arduino.
- Dia 10 – Medir distância com o HC-SR04: Meça o tempo que uma onda sonora leva para ir e voltar; como o som se propaga no ar a cerca de 343 m/s, dividir o tempo em microssegundos por 58 dá a distância em centímetros. Componentes: HC-SR04. Leia: Sensor de distância HC-SR04.
- Dia 11 – Sensor de estacionamento: Junte os dias 8 e 10: quanto mais perto o obstáculo, menor o intervalo entre os bipes do buzzer, e o LED pisca a cada bipe. Componentes: HC-SR04, buzzer passivo, LED, resistor de 220 Ω. Leia: Sistema de estacionamento com Arduino.
- Dia 12 – DHT11 e LCD I2C: Instale sua primeira biblioteca e mostre temperatura e umidade em um LCD 16x2. Graças ao I2C, o display é ligado com apenas 4 fios; a maioria dos módulos tem o endereço 0x27 ou 0x3F. Componentes: DHT11, LCD I2C 16x2. Leia: Como instalar uma biblioteca no Arduino, Sensor DHT11, Display LCD I2C.
- Dia 13 – Servo motor e plano do projeto final: Gire o SG90 entre 0 e 180 graus com a biblioteca Servo e controle o ângulo com um potenciômetro. Na segunda metade do dia, escolha seu projeto final e coloque o plano no papel seguindo os passos abaixo. Componentes: servo SG90, potenciômetro. Leia: O que é servo motor, Servo tremendo: como resolver.
- Dia 14 – Projeto final e apresentação: Junte os códigos dos dias anteriores, coloque o circuito em uma caixa ou em uma maquete de papelão, grave um vídeo curto e apresente seu projeto para a família ou para a turma. Componentes: a lista de peças do projeto final. Leia: Apresentação de projeto em feira de ciências.
O código abaixo é o sensor de estacionamento do dia 11 e reaproveita, dentro de uma função, o método de medir distância que você aprendeu no dia 10. O tempo limite de 30.000 microssegundos no pulseIn corresponde a cerca de 5 metros; se o sensor não receber eco, o código retorna -1 em vez de esperar para sempre. A função map converte a faixa de 0–50 cm em uma pausa de 50–500 ms, então os bipes ficam mais frequentes à medida que o obstáculo se aproxima.
1// Park sensörü: HC-SR04 + buzzer + LED / Parking sensor: HC-SR04 + buzzer + LED
2const int TRIG_PIN = 7;
3const int ECHO_PIN = 6;
4const int BUZZER_PIN = 5; // pasif buzzer / passive buzzer
5const int LED_PIN = 4; // 220 ohm dirençle / with a 220 ohm resistor
6
7long readDistanceCm() {
8 digitalWrite(TRIG_PIN, LOW);
9 delayMicroseconds(2);
10 digitalWrite(TRIG_PIN, HIGH); // 10 mikrosaniye tetik darbesi / 10 microsecond trigger pulse
11 delayMicroseconds(10);
12 digitalWrite(TRIG_PIN, LOW);
13 unsigned long duration = pulseIn(ECHO_PIN, HIGH, 30000UL); // 30 ms zaman aşımı / 30 ms timeout
14 if (duration == 0) return -1; // yankı yok / no echo
15 return duration / 58; // mikrosaniye -> cm / microseconds -> cm
16}
17
18void setup() {
19 pinMode(TRIG_PIN, OUTPUT);
20 pinMode(ECHO_PIN, INPUT);
21 pinMode(BUZZER_PIN, OUTPUT);
22 pinMode(LED_PIN, OUTPUT);
23 Serial.begin(9600);
24}
25
26void loop() {
27 long cm = readDistanceCm();
28 Serial.print("Mesafe / Distance: ");
29 Serial.print(cm);
30 Serial.println(" cm");
31
32 if (cm > 0 && cm < 50) {
33 int pause = map(cm, 0, 50, 50, 500); // yaklaştıkça kısalır / shorter when closer
34 tone(BUZZER_PIN, 2000, 50); // 2 kHz, 50 ms bip / 2 kHz, 50 ms beep
35 digitalWrite(LED_PIN, HIGH);
36 delay(50);
37 digitalWrite(LED_PIN, LOW);
38 delay(pause);
39 } else {
40 noTone(BUZZER_PIN);
41 digitalWrite(LED_PIN, LOW);
42 delay(200);
43 }
44}| Ligação | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| HC-SR04 VCC | 5V | VIN / 5V | VBUS (5 V) |
| HC-SR04 GND | GND | GND | GND |
| HC-SR04 TRIG | D7 | GPIO 5 | GP14 |
| HC-SR04 ECHO | D6 | GPIO 18 (com divisor de tensão) | GP15 (com divisor de tensão) |
| Buzzer (+) | D5 | GPIO 19 | GP13 |
| LED (com 220 Ω) | D4 | GPIO 23 | GP12 |
Caminho ESP32: o mesmo plano, com Wi-Fi
Se você está seguindo o caminho do ESP32, faz os dias 1–13 com quase o mesmo código; só muda os números dos pinos. Há duas diferenças para prestar atenção: no ESP32, o analogRead retorna valores de 0–4095 (12 bits), e para leitura analógica você deve preferir os pinos do ADC1 (GPIO 32–39), porque os pinos do ADC2 não podem ser usados com o Wi-Fi ligado. Além disso, reserve uma noite depois do dia 9 para o Wi-Fi: o código abaixo mostra a distância medida pelo sensor de estacionamento em uma página web na sua rede local; a página se atualiza sozinha a cada segundo e o LED acende quando a distância fica abaixo de 30 cm. Se você deixar o buzzer ligado ao GPIO 19, como na tabela, também fica fácil adicionar um aviso sonoro no projeto final. Para configurar a placa, veja o post O que é ESP32.
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* WIFI_SSID = "AgAdi"; // kendi ağ adın / your network name
5const char* WIFI_PASS = "Sifre123"; // kendi şifren / your password
6
7const int TRIG_PIN = 5;
8const int ECHO_PIN = 18; // gerilim bölücüyle / through a voltage divider
9const int LED_PIN = 23;
10
11WebServer server(80);
12
13long readDistanceCm() {
14 digitalWrite(TRIG_PIN, LOW);
15 delayMicroseconds(2);
16 digitalWrite(TRIG_PIN, HIGH);
17 delayMicroseconds(10);
18 digitalWrite(TRIG_PIN, LOW);
19 unsigned long duration = pulseIn(ECHO_PIN, HIGH, 30000UL); // 30 ms zaman aşımı / 30 ms timeout
20 if (duration == 0) return -1;
21 return duration / 58;
22}
23
24void handleRoot() {
25 long cm = readDistanceCm();
26 digitalWrite(LED_PIN, (cm > 0 && cm < 30) ? HIGH : LOW); // 30 cm altında uyarı / warn below 30 cm
27 String html = "<html><head><meta charset='utf-8'><meta http-equiv='refresh' content='1'></head><body>";
28 html += "<h1>Mesafe: " + String(cm) + " cm</h1></body></html>";
29 server.send(200, "text/html", html);
30}
31
32void setup() {
33 Serial.begin(115200);
34 pinMode(TRIG_PIN, OUTPUT);
35 pinMode(ECHO_PIN, INPUT);
36 pinMode(LED_PIN, OUTPUT);
37 WiFi.mode(WIFI_STA);
38 WiFi.begin(WIFI_SSID, WIFI_PASS);
39 while (WiFi.status() != WL_CONNECTED) { // bağlanana kadar bekle / wait until connected
40 delay(500);
41 Serial.print(".");
42 }
43 Serial.println();
44 Serial.print("IP: ");
45 Serial.println(WiFi.localIP()); // bu adresi tarayıcıya yaz / type this address in a browser
46 server.on("/", handleRoot);
47 server.begin();
48}
49
50void loop() {
51 server.handleClient();
52}Depois de carregar o código, abra o Monitor Serial a 115200 baud; quando a conexão for feita, digite o endereço IP exibido no navegador do celular. O celular e o ESP32 precisam estar na mesma rede Wi-Fi. O ESP32 só se conecta a redes de 2,4 GHz; se ele não conectar, siga o checklist do post ESP32 não conecta ao Wi-Fi. Adicionar os dados do DHT11 e um link para ligar e desligar um LED nessa página no projeto final é uma boa meta para o próximo passo.
Caminho Raspberry Pi Pico: os mesmos dias com MicroPython
No caminho do Pico, você usa o editor Thonny em vez do Arduino IDE; depois de instalar o MicroPython no Pico uma única vez, o código vai para a placa assim que você salva e executa. O LED integrado fica no GP25 no Pico clássico (no Pico W, você acessa com Pin("LED")), você usa machine.PWM para PWM e machine.ADC para leitura analógica, e o read_u16 retorna um valor na faixa de 0–65535. Se a sintaxe do Python for novidade para você, dê uma olhada no post Fundamentos do MicroPython antes do dia 1; para conhecer a placa, há o guia O que é Raspberry Pi Pico. O código abaixo é a versão em MicroPython do sensor de estacionamento do dia 11 e usa a coluna do Pico na tabela de pinos.
1from machine import Pin, PWM, time_pulse_us
2import time
3
4trig = Pin(14, Pin.OUT)
5echo = Pin(15, Pin.IN) # gerilim bölücüyle / through a voltage divider
6buzzer = PWM(Pin(13)) # pasif buzzer / passive buzzer
7led = Pin(12, Pin.OUT)
8
9def mesafe_cm():
10 trig.value(0)
11 time.sleep_us(2)
12 trig.value(1)
13 time.sleep_us(10) # 10 mikrosaniye tetik / 10 microsecond trigger
14 trig.value(0)
15 sure = time_pulse_us(echo, 1, 30000) # 30 ms zaman aşımı / 30 ms timeout
16 if sure < 0:
17 return -1 # yankı yok / no echo
18 return sure / 58
19
20while True:
21 cm = mesafe_cm()
22 print("Mesafe / Distance:", cm, "cm")
23 if 0 < cm < 50:
24 bekle = int(50 + cm * 9) # yaklaştıkça kısalır / shorter when closer
25 buzzer.freq(2000)
26 buzzer.duty_u16(32768) # yüzde 50 doluluk / 50 percent duty
27 led.value(1)
28 time.sleep_ms(50)
29 buzzer.duty_u16(0)
30 led.value(0)
31 time.sleep_ms(bekle)
32 else:
33 buzzer.duty_u16(0)
34 led.value(0)
35 time.sleep_ms(200)Projeto final: o que você vai concluir no fim das férias?
O projeto final reúne as peças que você aprendeu em duas semanas em um único dispositivo útil. Um bom projeto final deve ter pelo menos uma entrada (um sensor ou botão), um processamento (código que toma decisões) e uma saída (LED, som, display ou motor). Nenhuma das opções abaixo precisa de um componente caro além do kit; escolha a que combina com o seu nível e trabalhe nela a partir do dia 13. Para mais ideias, confira a lista de ideias de projetos Arduino.
| Nível / caminho | Projeto final | Dias que combina | Componentes extras |
|---|---|---|---|
| Uno – iniciante | Assistente de estacionamento inteligente: bipes que aceleram conforme a distância, centímetros no LCD, cancela com servo que abaixa a 10 cm | 4, 9, 10, 11, 12, 13 | Nenhum, o kit basta |
| Uno – alternativa | Miniestação meteorológica: dados do DHT11 no LCD, um botão troca as páginas, a luz de fundo do display apaga no escuro | 4, 7, 9, 12 | Nenhum, o kit basta |
| ESP32 | Estação do quarto acompanhada pelo celular: temperatura, umidade e distância em uma página web, um LED ligado e desligado pelo navegador | 6, 9, 10, 12 + Wi-Fi | Nenhum, a placa ESP32 basta |
| Pico | Jogo de reação: quando um LED acende em um momento aleatório, quem apertar mais rápido ganha, o tempo aparece no console do Thonny e o vencedor é celebrado com uma melodia no buzzer | 4, 8, 9 | Um segundo botão |
- Descreva em uma frase: Escreva o que o dispositivo vai fazer em uma frase clara, como “Conforme o carro se aproxima da garagem, os bipes aceleram, e a cancela abaixa a 10 cm.”
- Desenhe um diagrama entrada-processamento-saída: Desenhe no papel, com caixas, qual sensor vai fornecer os dados, o que o código vai decidir e qual componente vai reagir.
- Faça um plano de pinos: Anote em uma tabela em qual pino cada componente será ligado. Coloque as saídas que precisam de PWM, como o brilho de um LED, nos pinos marcados com ~; lembre que, no Uno, a biblioteca Servo desativa o PWM no D9 e no D10. A ferramenta Pinagem facilita encontrar o mapa de pinos da sua placa.
- Teste parte por parte: Primeiro rode cada módulo sozinho, com seu próprio código pequeno; só passe a juntar tudo quando todos funcionarem separadamente.
- Junte tudo e limpe os delays: Coloque o código em um único arquivo e troque os delays longos pela estrutura com millis que você aprendeu no dia 9, para que a leitura do sensor, o som e o display não fiquem esperando um pelo outro.
- Coloque em uma caixa e apresente: Coloque o circuito em uma caixa de papelão ou plástico, prenda os fios com fita e grave um vídeo de demonstração de 30–60 segundos. Se quiser deixar o circuito permanente, soldar em placa perfurada pode ser o seu próximo passo.
Onde você costuma travar e como resolver
| Problema | Causa provável | Solução |
|---|---|---|
| O código não carrega, a porta não aparece | Placa ou porta errada selecionada, driver CH340 faltando ou cabo que só carrega | Selecione a placa e a porta no menu Ferramentas, use um cabo USB que transmita dados, instale o driver |
| O LED não acende de jeito nenhum | LED invertido ou terminais fora da mesma fileira da protoboard | A perna longa (ânodo) vai para o lado do pino, a curta (cátodo) para o lado do GND; tente mudar a ligação uma fileira |
| O botão dispara sem ser pressionado | Pino flutuando, sem resistor de pull-up | Use pinMode(pino, INPUT_PULLUP) e ligue o outro terminal do botão ao GND |
| O HC-SR04 mostra sempre 0 ou -1 | TRIG e ECHO trocados ou o sensor não está recebendo 5 V | Confira a tabela de pinos, ligue o VCC ao 5 V, aponte o sensor para uma superfície plana a pelo menos 2 cm |
| A luz de fundo do LCD acende, mas não aparece texto | Ajuste de contraste ou endereço I2C errado | Gire o trimpot azul na parte de trás do módulo, teste os endereços 0x27 e 0x3F |
| A placa reinicia quando o servo se move | O servo puxa mais corrente do que o USB consegue fornecer | Alimente o servo com uma fonte externa de 5 V e ligue o GND da fonte ao GND da placa |
| Erro “Failed to connect” ao carregar no ESP32 | A placa não entra no modo de download | Segure o botão BOOT quando o carregamento começar e solte quando aparecer “Connecting...” |
Depois de duas semanas, você terá não só um projeto final funcionando, mas também um método para aprender sozinho qualquer sensor ou módulo novo: ler, desenhar, montar, testar, modificar. Se você mantiver esse hábito com um projeto por semana quando as aulas voltarem, até as férias de verão estará pronto para um projeto de nível de feira de ciências; o post Ideias de projetos Arduino para o TÜBİTAK é um bom começo para a fase das ideias. Você encontra os esquemas do circuito e os códigos passo a passo dos projetos do plano (LED, semáforo, botão, luz noturna com LDR, medição de distância e DHT11) para Uno, ESP32 e Pico no app BlueGrays, e pode acompanhar cada dia pelo app.
Perguntas frequentes
Dá para aprender Arduino nas férias de inverno?
Sim. Trabalhando 1–2 horas por dia, em duas semanas você aprende entrada e saída digital e analógica, leitura de sensores, displays e controle de motores. O importante é terminar todo dia um projeto pequeno, mas completo, e modificar o código por conta própria. No fim das férias você será capaz de montar um projeto que combina vários módulos.
Qual kit iniciante devo comprar para começar com Arduino?
Um kit iniciante com Arduino Uno, protoboard, jumpers, LEDs, resistores, botão, potenciômetro, LDR, buzzer, HC-SR04, DHT11, servo e LCD I2C é suficiente para o plano inteiro. Os clones do Uno rodam o mesmo código da placa original; talvez você só precise instalar o driver CH340.
Devo começar com Arduino, ESP32 ou Raspberry Pi Pico?
Se você não tem experiência, o Arduino Uno é o começo mais fácil; ele trabalha com 5 V e a maioria dos exemplos é escrita para ele. Se quiser conectar seus projetos à internet, o ESP32 é uma escolha melhor, e se quiser aprender Python, o Raspberry Pi Pico com MicroPython. Os conceitos fundamentais que você aprende são os mesmos nas três placas.
Dá para aprender Arduino sem ter uma placa?
Sim. Simuladores que rodam no navegador, como o Wokwi e o Tinkercad, permitem ligar virtualmente componentes como LEDs, botões, potenciômetros, o HC-SR04, servos e LCDs e rodar o seu código. Você pode fazer a primeira semana deste plano inteiramente em simulação e depois testar o mesmo código em um circuito real quando a placa chegar.
Qual é o projeto mais fácil de fazer com Arduino?
O projeto mais fácil é ligar um LED com um resistor de 220 Ω e fazê-lo piscar (Blink). Depois vêm o semáforo, o controle de um LED com botão e a luz noturna com LDR. Esses quatro projetos ensinam o básico de saída digital, entrada digital e leitura analógica no Arduino.
Preciso saber programar para aprender Arduino?
Você não precisa saber programar antes; a linguagem do Arduino é baseada em C++, mas nos projetos para iniciantes você se vira com alguns comandos e estruturas simples de if e for. Rodar códigos de exemplo prontos e modificá-los linha por linha é a forma mais rápida de aprender. Se você sabe Python, pode fazer os mesmos projetos com o Raspberry Pi Pico e MicroPython.
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…

LED piscando com ESP32
Ensina o uso básico de uma saída GPIO no ESP32. Fazemos um LED piscar ligando e desligando um pino digital. É a versão para ESP32 do clássico projeto blink do Arduino UNO: os comandos básicos de blink no ambiente Arduino são os mesmos, mas a disposição dos pinos e os níveis de 3,3 V dos GPIOs do ESP32 diferem dos do Arduino UNO.

Raspberry Pi Pico: semáforo (3 LEDs em sequência)
Simulamos um semáforo real com LEDs vermelho, amarelo e verde — o primeiro projeto com 3 LEDs da série Pico! Verde por 4 segundos: "siga"; amarelo por 1,5 segundo: "prepare-se"; vermelho por 3 segundos: "pare"; e vermelho+amarelo por 1 segundo: "saída" (padrão de semáforo europeu). Aprenda definição de funções (def all_off()), lógica de máquina de estados (sequência) e sincronização de vários GPIOs.
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

