Você está começando uma jornada prática em que programação, eletricidade e eletrônica trabalham juntas. A partir daqui, o código deixa de ficar apenas na tela e passa a controlar componentes físicos reais: LEDs, botões, buzzers, potenciômetros, sensores e atuadores.
O Arduino é uma plataforma de prototipagem eletrônica. Na prática, ele funciona como um pequeno computador programável especializado em interagir com o mundo físico.
Em vez de trabalhar apenas com teclado, mouse e monitor, ele pode ler sinais de sensores e controlar componentes como LEDs, buzzers, motores e displays.
Um sistema embarcado é um sistema eletrônico programado para executar uma tarefa específica.
O programa enviado ao Arduino define o que os pinos devem fazer: enviar sinal, ler sinal, ligar, desligar, medir ou controlar algum componente.
Para um componente funcionar, a corrente precisa percorrer um caminho fechado. Em muitos projetos iniciais, esse caminho começa no 5V ou em um pino digital, passa pelo componente e retorna ao GND.
Entrada é aquilo que envia informação para o Arduino, como um botão ou potenciômetro. Saída é aquilo que o Arduino controla, como LED ou buzzer.
Um sinal digital trabalha com dois estados: HIGH ou LOW, ligado ou desligado. Um sinal analógico pode variar gradualmente dentro de uma faixa de valores.
PWM é uma técnica que liga e desliga um sinal muito rapidamente para simular níveis intermediários. É assim que o Arduino consegue controlar o brilho de um LED em pinos PWM.
A sequência foi organizada para que cada projeto acrescente uma ideia nova sem abandonar o que já foi aprendido.
A partir do primeiro projeto, cada montagem irá unir eletricidade, eletrônica e programação. O LED protegido será o ponto de partida: simples, visual e essencial para entender circuito fechado, polaridade e proteção por resistor.
Antes de começar a programar o Arduino, é importante entender como a eletricidade percorre um circuito e como os componentes eletrônicos trabalham juntos.
Uma forma simples de entender tensão, corrente e resistência é imaginar a eletricidade como água passando por um cano.
A tensão elétrica funciona como a força que empurra a água. A corrente elétrica representa o fluxo em movimento. Já a resistência elétrica dificulta a passagem da corrente.
A tensão elétrica é medida em volts. A corrente elétrica é medida em ampere. A resistência elétrica é medida em ohms.
Para que a corrente elétrica passe pelo circuito, ele precisa estar fechado.
A Lei de Ohm relaciona tensão, corrente e resistência elétrica. Ela será utilizada frequentemente nos projetos com Arduino.
O resistor limita a corrente elétrica e protege o LED.
Quando o LED é ligado diretamente em uma bateria sem resistor, ele pode ser danificado devido ao excesso de corrente elétrica.
O LED possui polaridade. O terminal maior normalmente representa o positivo. O menor representa o negativo.
No circuito em série, os componentes ficam no mesmo caminho da corrente elétrica. Se um componente falhar, o circuito para de funcionar.
No circuito em paralelo, existem ramificações diferentes. Assim, uma parte do circuito pode continuar funcionando mesmo que outra apresente problema.
Ao longo dos projetos, serão utilizados LEDs, resistores, botões, sensores, buzzer, potenciômetro, display e diversos outros componentes eletrônicos.
O Tinkercad será utilizado para montar, testar e simular os circuitos eletrônicos.
No ambiente Tinkercad é possível movimentar componentes, criar circuitos, alterar fios e testar montagens eletrônicas.
Além da montagem dos circuitos, o Tinkercad também permite programar placas Arduino e executar simulações em tempo real.
O Arduino funciona apenas como fonte de 5V e GND para alimentar o LED protegido por resistor.
Montar um circuito simples com LED protegido por resistor, usando o Arduino Uno R3 apenas como fonte de alimentação. Na imagem, o Arduino fornece 5V ao barramento positivo da protoboard e GND ao barramento negativo. O LED acende continuamente porque há um caminho elétrico fechado passando pelo resistor de 300 Ω e pelo LED.
| Ponto inicial | Ponto final | Observação |
|---|---|---|
| Pino 5V do Arduino | Barramento positivo da protoboard | Fio vermelho da imagem; fornece alimentação positiva ao circuito. |
| Pino GND do Arduino | Barramento negativo da protoboard | Fio preto da imagem; fornece a referência negativa do circuito. |
| Barramento positivo da protoboard | Uma extremidade do resistor de 300 Ω | O resistor recebe alimentação positiva a partir do trilho positivo. |
| Outra extremidade do resistor | Anodo do LED | O resistor fica em série antes do LED, limitando a corrente. |
| Catodo do LED | Barramento negativo da protoboard | Fecha o caminho de retorno até o GND. |
Na imagem, o Arduino não controla nenhum pino digital. Ele é usado somente como fonte de energia. O fio vermelho leva o 5V do Arduino até o barramento positivo da protoboard. O fio preto leva o GND do Arduino até o barramento negativo.
A partir do barramento positivo, a corrente passa pelo resistor de 300 Ω, depois entra no anodo do LED. O catodo do LED retorna ao barramento negativo, fechando o circuito no GND.
O caminho elétrico representado na imagem é: 5V → barramento positivo → resistor de 300 Ω → LED → barramento negativo → GND.
A imagem mostra o Arduino Uno R3 à direita e a protoboard à esquerda. O fio vermelho sai do pino 5V do Arduino e alimenta o barramento positivo da protoboard. O fio preto sai do GND do Arduino e chega ao barramento negativo. O resistor de 300 Ω está em série com o LED. A polaridade do LED deve ser respeitada: o anodo recebe o sinal que vem do resistor e o catodo retorna ao GND.
Neste projeto, não há ligação em pinos digitais, pois o Arduino funciona apenas como fonte de alimentação.
// Projeto 1: LED protegido
// Neste projeto, o Arduino Uno R3 funciona apenas como fonte de 5V.
// Não há programação funcional obrigatória.
void setup() {
// Nenhuma configuração é necessária neste projeto.
}
void loop() {
// Nenhum comando é necessário neste projeto.
}// Projeto 1: LED protegido — comentário com o nome do projeto.
// Neste projeto... — explica que o Arduino não controlará o LED por programação.
void setup() — função executada uma única vez quando o Arduino liga.
// Nenhuma configuração... — indica que nenhum pino será configurado.
void loop() — função que normalmente se repete continuamente.
// Nenhum comando... — reforça que o funcionamento depende apenas da montagem elétrica.
Ao conectar o Arduino ao computador pelo cabo USB, o LED deve acender continuamente. Ele não pisca e não depende do código, porque está alimentado diretamente pelo 5V do Arduino através do resistor de 300 Ω.
| Erro | Consequência |
|---|---|
| Ligar o LED sem resistor | Pode queimar o LED. |
| Inverter anodo e catodo do LED | O LED não acende. |
| Ligar 5V diretamente no GND | Gera curto-circuito perigoso. |
| Colocar o resistor em uma linha que não esteja conectada ao LED | O circuito fica aberto e o LED não funciona. |
| Não ligar o GND do Arduino ao barramento negativo | Não há caminho completo para a corrente retornar. |
| Confundir os barramentos positivo e negativo da protoboard | O circuito pode não funcionar ou pode ser ligado de forma incorreta. |
Monte o circuito do LED protegido usando resistor de 300 Ω. Depois, com o Arduino desligado, inverta o LED na protoboard e ligue novamente. Por que o LED acende em uma posição e não acende na outra?
O LED externo deixa de ser ligado diretamente ao 5V e passa a ser controlado pelo pino digital 8.
Fazer um LED externo piscar usando o pino digital 8 do Arduino Uno R3. No Projeto 1, o LED acendia porque estava ligado diretamente ao 5V. Neste projeto, o LED pisca porque o Arduino controla o pino digital por programação.
| Ponto inicial | Ponto final | Observação |
|---|---|---|
| Pino digital 8 do Arduino | Uma extremidade do resistor de 300 Ω | Fio vermelho da imagem; agora o LED é alimentado pelo pino digital, não pelo 5V direto. |
| Outra extremidade do resistor | Anodo do LED | O resistor fica em série antes do LED. |
| Catodo do LED | Barramento negativo da protoboard | Retorno do LED para o GND. |
| Barramento negativo da protoboard | Pino GND do Arduino | Fio preto da imagem; fecha o circuito elétrico. |
Na imagem, o fio vermelho não vem do pino 5V. Ele sai do pino digital 8 do Arduino e chega à região do resistor na protoboard. O resistor de 300 Ω fica em série com o LED, protegendo-o contra excesso de corrente.
O catodo do LED retorna ao barramento negativo da protoboard, e esse barramento está ligado ao GND do Arduino pelo fio preto. Assim, o caminho do LED é: pino digital 8 → resistor de 300 Ω → LED → GND.
Quando o código coloca o pino 8 em HIGH, o LED acende. Quando coloca em LOW, o LED apaga.
A imagem deve ser lida da seguinte forma: o Arduino Uno R3 fica à direita, a protoboard à esquerda, o fio vermelho sai do pino digital 8 e vai até o resistor de 300 Ω. O resistor está em série com o LED. O retorno do LED é feito para o barramento negativo da protoboard, que está ligado ao GND do Arduino pelo fio preto.
Este circuito visual mostra claramente a transição do Projeto 1 para o Projeto 2: agora o LED não recebe 5V fixo; ele recebe comando do pino digital 8.
// Projeto 2: Blink com LED externo
// O LED será controlado pelo pino digital 8 do Arduino.
int pinoLed = 8;
void setup() {
pinMode(pinoLed, OUTPUT);
}
void loop() {
digitalWrite(pinoLed, HIGH);
delay(1000);
digitalWrite(pinoLed, LOW);
delay(1000);
}int pinoLed = 8; — cria uma variável com o número do pino usado no circuito.
pinMode(pinoLed, OUTPUT); — configura o pino 8 como saída.
digitalWrite(pinoLed, HIGH); — envia tensão pelo pino 8 e acende o LED.
delay(1000); — mantém o LED aceso por 1 segundo.
digitalWrite(pinoLed, LOW); — para de enviar tensão pelo pino 8 e apaga o LED.
delay(1000); — mantém o LED apagado por 1 segundo.
loop() — repete o ciclo continuamente.
Ao enviar o código para o Arduino, o LED externo deve acender por 1 segundo, apagar por 1 segundo e repetir esse comportamento continuamente.
| Erro | Consequência |
|---|---|
| Ligar o LED no 5V em vez do pino 8 | O LED fica sempre aceso e não obedece ao código. |
| Usar pino diferente no circuito e no código | O LED não pisca como esperado. |
| Esquecer o resistor de 300 Ω | Pode queimar o LED. |
| Inverter o LED | O LED não acende. |
| Não ligar o retorno ao GND | O circuito fica aberto e o LED não funciona. |
| Colocar resistor e LED em linhas desconectadas da protoboard | O caminho elétrico não se completa. |
Altere o tempo do pisca-pisca trocando delay(1000); por delay(300);. O LED pisca mais rápido ou mais devagar? Por quê?
O botão é lido no pino digital 2 e o LED é acionado pelo pino digital 8 somente enquanto o botão estiver pressionado.
Fazer um botão controlar um LED. O LED deve acender somente enquanto o botão estiver pressionado. O aluno deve compreender entrada digital, saída digital, leitura de botão, digitalRead(), if/else e a lógica do INPUT_PULLUP.
| Parte do circuito | Ponto inicial | Ponto final | Observação |
|---|---|---|---|
| LED | Pino digital 8 do Arduino | Resistor de 300 Ω | Saída digital que controla o LED. |
| LED | Resistor de 300 Ω | Anodo do LED | Resistor em série para limitar a corrente. |
| LED | Catodo do LED | GND do Arduino / barramento negativo | Fecha o circuito do LED. |
| Botão | Um terminal do botão | Pino digital 2 do Arduino | Entrada digital lida pelo programa. |
| Botão | Terminal oposto do botão | GND | Com INPUT_PULLUP, pressionar o botão liga o pino 2 ao GND. |
A parte do LED segue a mesma lógica do Blink: o pino digital 8 alimenta o resistor de 300 Ω, o resistor vai ao anodo do LED e o catodo retorna ao GND.
Na imagem, o botão tátil está atravessando o vão central da protoboard. Essa posição é importante para evitar que os terminais fiquem ligados de forma errada. Um lado do botão está ligado ao pino digital 2; o lado oposto está ligado ao GND.
Como o código usa INPUT_PULLUP, não é necessário resistor externo no botão. O Arduino mantém o pino 2 em HIGH quando o botão está solto. Quando o botão é pressionado, ele conecta o pino 2 ao GND, e a leitura passa a ser LOW.
A imagem mostra dois circuitos simples funcionando juntos. O primeiro é a saída: LED no pino digital 8, com resistor de 300 Ω em série e retorno ao GND. O segundo é a entrada: botão tátil na protoboard, com um lado ligado ao pino digital 2 e o outro lado ligado ao GND.
O desenho precisa deixar claro que o botão não recebe 5V diretamente. Ele trabalha com o resistor interno de pull-up do Arduino. Por isso, neste projeto, botão pressionado significa leitura LOW.
// Projeto 3: Botão com LED
// O LED acende somente enquanto o botão estiver pressionado.
// O botão usa INPUT_PULLUP, portanto pressionado = LOW.
int pinoLed = 8;
int pinoBotao = 2;
void setup() {
pinMode(pinoLed, OUTPUT);
pinMode(pinoBotao, INPUT_PULLUP);
}
void loop() {
int estadoBotao = digitalRead(pinoBotao);
if (estadoBotao == LOW) {
digitalWrite(pinoLed, HIGH);
} else {
digitalWrite(pinoLed, LOW);
}
}int pinoLed = 8; — guarda o pino usado pelo LED.
int pinoBotao = 2; — guarda o pino usado pelo botão.
pinMode(pinoLed, OUTPUT); — configura o LED como saída digital.
pinMode(pinoBotao, INPUT_PULLUP); — configura o botão como entrada e ativa o resistor interno de pull-up.
digitalRead(pinoBotao); — lê HIGH ou LOW no pino do botão.
if (estadoBotao == LOW) — verifica se o botão está pressionado, pois com INPUT_PULLUP pressionado = LOW.
digitalWrite(pinoLed, HIGH); — liga o LED enquanto o botão está pressionado.
else / digitalWrite(pinoLed, LOW); — desliga o LED quando o botão está solto.
Com o Arduino ligado e o código enviado, o LED fica apagado quando o botão está solto, acende enquanto o botão está pressionado e apaga novamente ao soltar.
| Erro | Consequência |
|---|---|
| Colocar o botão sem atravessar corretamente o vão central | O botão pode ficar sempre ligado ou nunca funcionar. |
| Ligar os dois fios no mesmo lado elétrico do botão | O pino 2 pode ficar sempre em LOW ou nunca mudar. |
| Esperar que botão pressionado seja HIGH | A lógica fica invertida, pois com INPUT_PULLUP pressionado = LOW. |
| Usar INPUT em vez de INPUT_PULLUP | O botão pode apresentar leitura flutuante. |
| Trocar os pinos 2 ou 8 no circuito sem alterar o código | O botão ou o LED não funcionam. |
| Esquecer o resistor do LED | Pode queimar o LED. |
Altere o comportamento para o contrário: botão solto = LED aceso; botão pressionado = LED apagado. Por que, neste circuito com INPUT_PULLUP, o botão pressionado é lido como LOW?
O buzzer ativo é controlado pelo pino digital 8, emitindo som intermitente por programação.
Fazer o Arduino controlar um buzzer ativo, emitindo som de forma intermitente. Na imagem, o buzzer está ligado diretamente entre o pino digital 8 e o GND. O aluno deve perceber que o buzzer é uma saída sonora, assim como o LED era uma saída visual.
| Ponto inicial | Ponto final | Observação |
|---|---|---|
| Terminal positivo (+) do buzzer ativo | Pino digital 8 do Arduino | Fio vermelho da imagem; saída controlada pelo programa. |
| Terminal negativo (-) do buzzer ativo | Pino GND do Arduino | Fio preto da imagem; fecha o circuito elétrico. |
Na imagem, o buzzer ativo está colocado na protoboard. O terminal positivo, indicado pelo símbolo +, é ligado ao pino digital 8 do Arduino. O terminal negativo, indicado pelo símbolo -, é ligado ao GND.
O caminho elétrico é simples: pino digital 8 → buzzer ativo → GND. Quando o programa aciona o pino 8 com tone(), o buzzer emite som. Quando o programa executa noTone(), o som é interrompido.
A imagem mostra o Arduino Uno R3 à direita e a protoboard à esquerda. O buzzer ativo aparece com polaridade identificada. O fio vermelho liga o terminal positivo do buzzer ao pino digital 8. O fio preto liga o terminal negativo ao GND. Não há LED nem resistor neste projeto.
O desenho deve destacar que o buzzer é uma saída sonora controlada por programação.
// Projeto 4: Buzzer ativo
// O Arduino controla um buzzer no pino digital 8.
// O som liga e desliga de forma intermitente.
int pinoBuzzer = 8;
void setup() {
pinMode(pinoBuzzer, OUTPUT);
}
void loop() {
tone(pinoBuzzer, 1000);
delay(1000);
noTone(pinoBuzzer);
delay(1000);
}int pinoBuzzer = 8; — guarda o número do pino usado pelo buzzer.
pinMode(pinoBuzzer, OUTPUT); — configura o pino 8 como saída digital.
tone(pinoBuzzer, 1000); — aciona o buzzer no pino 8 usando frequência de 1000 Hz. Em buzzer ativo, serve principalmente como acionamento didático.
delay(1000); — mantém o som por 1 segundo.
noTone(pinoBuzzer); — interrompe o som no pino 8.
delay(1000); — mantém o buzzer em silêncio por 1 segundo.
loop() — repete som e silêncio continuamente.
Ao enviar o código para o Arduino, o buzzer deve emitir som por 1 segundo, ficar em silêncio por 1 segundo e repetir continuamente.
| Erro | Consequência |
|---|---|
| Inverter positivo e negativo do buzzer | O buzzer pode não funcionar. |
| Ligar o positivo em pino diferente do código | O buzzer não toca. |
| Esquecer o GND | O circuito não fecha. |
| Ligar o buzzer direto no 5V | Ele fica ligado continuamente, sem obedecer ao código. |
| Usar buzzer ativo esperando notas musicais precisas | O controle de frequência pode não ser fiel, pois o buzzer ativo já possui oscilador interno. |
| Remover os delays | O som pode parecer contínuo ou rápido demais. |
Troque os dois delay(1000); por delay(300);. O buzzer ficou mais rápido ou mais lento? O que o delay() está controlando neste projeto?
O potenciômetro é lido no A0 e controla o brilho do LED ligado ao pino PWM 9.
Controlar o brilho de um LED usando um potenciômetro de 10 kΩ. O aluno deve perceber a relação entre entrada analógica e saída PWM, usando analogRead(), map() e analogWrite().
| Componente | Ponto inicial | Ponto final | Observação |
|---|---|---|---|
| Potenciômetro | Um terminal lateral | 5V do Arduino | Fio vermelho da imagem; alimenta uma extremidade do potenciômetro. |
| Potenciômetro | Outro terminal lateral | GND do Arduino | Fio preto da imagem; fornece a referência negativa. |
| Potenciômetro | Terminal central | Pino analógico A0 | Fio amarelo da imagem; envia ao Arduino a tensão variável. |
| LED | Pino PWM 9 do Arduino | Resistor de 300 Ω | Saída PWM que controla o brilho do LED. |
| LED | Resistor de 300 Ω | Anodo do LED | Resistor em série com o LED. |
| LED | Catodo do LED | GND | Fecha o circuito do LED. |
Na imagem, o potenciômetro está encaixado na protoboard e usa três ligações. Um terminal lateral vai ao 5V, o outro terminal lateral vai ao GND e o terminal central vai ao pino analógico A0. O terminal central é o cursor do potenciômetro: ele entrega ao Arduino uma tensão variável conforme o eixo é girado.
A parte do LED usa o pino PWM 9. O sinal sai do pino 9, passa pelo resistor de 300 Ω, entra no anodo do LED e retorna pelo catodo ao GND.
O Arduino lê o valor variável do potenciômetro no A0 com analogRead() e usa esse valor para controlar o brilho do LED no pino 9 com analogWrite().
A imagem mostra dois blocos conectados ao Arduino. O primeiro bloco é a entrada analógica: potenciômetro de 10 kΩ com uma lateral em 5V, outra lateral em GND e terminal central no A0. O segundo bloco é a saída PWM: LED ligado ao pino 9, passando por resistor de 300 Ω e retornando ao GND.
O desenho deve deixar evidente que o potenciômetro não acende o LED diretamente. Ele envia uma leitura analógica ao Arduino, e o Arduino controla o brilho do LED por PWM.
// Projeto 5: Potenciômetro com PWM
// O potenciômetro controla o brilho de um LED.
// Potenciômetro no A0 e LED no pino PWM 9.
int pinoPotenciometro = A0;
int pinoLed = 9;
int leituraPotenciometro = 0;
int brilhoLed = 0;
void setup() {
pinMode(pinoLed, OUTPUT);
}
void loop() {
leituraPotenciometro = analogRead(pinoPotenciometro);
brilhoLed = map(leituraPotenciometro, 0, 1023, 0, 255);
analogWrite(pinoLed, brilhoLed);
}int pinoPotenciometro = A0; — representa o pino analógico usado pelo potenciômetro.
int pinoLed = 9; — representa o pino PWM usado pelo LED.
int leituraPotenciometro = 0; — guarda a leitura de 0 a 1023.
int brilhoLed = 0; — guarda o valor PWM de 0 a 255.
pinMode(pinoLed, OUTPUT); — configura o pino do LED como saída.
analogRead(pinoPotenciometro); — lê a tensão variável no A0 e converte em número de 0 a 1023.
map(leituraPotenciometro, 0, 1023, 0, 255); — converte a faixa da entrada analógica para a faixa do PWM.
analogWrite(pinoLed, brilhoLed); — envia PWM ao LED. Quanto maior o valor, maior o brilho.
Ao girar o potenciômetro, o brilho do LED deve variar gradualmente: apagado ou quase apagado em uma extremidade, intermediário no meio e máximo na outra extremidade.
| Erro | Consequência |
|---|---|
| Ligar o terminal central do potenciômetro no 5V ou GND | A leitura não varia corretamente. |
| Não ligar o terminal central ao A0 | O Arduino não lê a posição do potenciômetro. |
| Esquecer o GND do potenciômetro | A leitura fica instável ou incorreta. |
| Usar pino diferente de A0 no circuito sem mudar o código | O controle não funciona. |
| Ligar o LED em pino sem PWM | O brilho pode não variar corretamente com analogWrite(). |
| Usar pino diferente do 9 sem mudar o código | O LED não responde ao PWM esperado. |
| Esquecer o resistor de 300 Ω do LED | Pode queimar o LED. |
| Inverter o LED | O LED não acende. |
Inverta o controle do brilho trocando map(leituraPotenciometro, 0, 1023, 0, 255) por map(leituraPotenciometro, 0, 1023, 255, 0). O que mudou no comportamento do LED ao girar o potenciômetro?
O Arduino lê a luminosidade do ambiente pelo LDR e acende o LED automaticamente quando estiver escuro.
Montar um circuito que percebe a luminosidade do ambiente usando um fotoresistor, também chamado de LDR. Quando o ambiente estiver escuro, o Arduino acende o LED automaticamente. Quando houver luz suficiente, o LED permanece apagado.
Neste projeto, o aluno começa a juntar sensor, leitura analógica, decisão com if e saída digital em uma situação parecida com uma iluminação automática.
| Componente | Ponto inicial | Ponto final | Observação |
|---|---|---|---|
| LDR | Uma extremidade do LDR | 5V do Arduino | O LDR participa da leitura da luminosidade. |
| LDR | Outra extremidade do LDR | Pino analógico A0 | O ponto ligado ao A0 envia ao Arduino uma tensão variável. |
| Resistor do LDR | Pino analógico A0 | GND do Arduino | O resistor de 10 kΩ forma o divisor de tensão usado na leitura analógica. |
| LED | Pino digital 7 do Arduino | Resistor de 300 Ω | Saída digital que controla o LED. |
| LED | Resistor de 300 Ω | Anodo do LED | O resistor fica em série para limitar a corrente. |
| LED | Catodo do LED | GND | Fecha o circuito do LED. |
O LDR é usado como sensor de luminosidade. Ele não liga o LED diretamente. Ele apenas ajuda o Arduino a perceber se o ambiente está mais claro ou mais escuro.
O ponto de leitura do sensor vai ao pino analógico A0. O resistor de 10 kΩ trabalha junto com o LDR formando um divisor de tensão. Assim, a tensão lida pelo Arduino muda conforme a luz muda.
O LED é ligado ao pino digital 7, passa pelo resistor de 300 Ω e retorna ao GND. Quando o programa decide que está escuro, o pino 7 fica em HIGH e o LED acende.
A imagem mostra o Arduino Uno R3 ligado à protoboard. O LDR fica na parte do sensor e está associado ao resistor de 10 kΩ, criando uma leitura analógica no pino A0. Essa parte representa a entrada de informação do circuito.
O LED fica na parte da saída. Ele é controlado pelo pino digital 7, passa por um resistor de 300 Ω e retorna ao GND. Assim, o circuito tem uma entrada que percebe a luz e uma saída que responde acendendo ou apagando o LED.
// Projeto 6: Fotoresistor (LDR)
// O Arduino lê a luminosidade no A0 e controla um LED no pino 7.
const int pinoLDR = A0;
const int pinoLED = 7;
int leitura = 0;
void setup() {
pinMode(pinoLDR, INPUT);
pinMode(pinoLED, OUTPUT);
Serial.begin(9600);
}
void loop() {
leitura = analogRead(pinoLDR);
Serial.print("Leitura: ");
Serial.println(leitura);
if (leitura < 40) {
digitalWrite(pinoLED, HIGH);
} else {
digitalWrite(pinoLED, LOW);
}
delay(100);
}const int pinoLDR = A0; — define que o LDR será lido pela entrada analógica A0.
const int pinoLED = 7; — define que o LED será controlado pelo pino digital 7.
int leitura = 0; — cria uma variável para guardar o valor lido pelo sensor.
pinMode(pinoLDR, INPUT); — indica que o pino do LDR será usado como entrada.
pinMode(pinoLED, OUTPUT); — configura o pino do LED como saída.
Serial.begin(9600); — inicia a comunicação com o monitor serial.
analogRead(pinoLDR); — lê a variação de luz no sensor e gera um valor numérico.
Serial.print() e Serial.println() — mostram a leitura para o aluno observar os valores.
if (leitura < 40) — verifica se a leitura indica pouca luz.
digitalWrite(pinoLED, HIGH); — acende o LED quando o ambiente está escuro.
digitalWrite(pinoLED, LOW); — apaga o LED quando há luz suficiente.
delay(100); — cria uma pequena pausa entre as leituras.
Ao cobrir o LDR com a mão, a leitura no monitor serial deve mudar e o LED deve acender quando o valor ficar abaixo do limite definido no código. Ao iluminar o sensor, o LED deve apagar.
Dependendo da montagem, da iluminação da sala e da posição do LDR, pode ser necessário ajustar o valor 40 para outro limite.
| Erro | Consequência |
|---|---|
| Ligar o LDR sem o resistor de 10 kΩ | A leitura pode ficar incorreta ou instável. |
| Ligar o ponto de leitura em lugar diferente do A0 | O Arduino não lê o sensor conforme o código. |
| Usar pino diferente do 7 para o LED sem alterar o código | O LED não responde ao programa. |
| Inverter o LED | O LED não acende. |
| Esquecer o resistor de 300 Ω do LED | Pode queimar o LED. |
| Usar limite 40 sem observar o monitor serial | O LED pode acender ou apagar fora do momento desejado. |
| Não ligar o GND corretamente | O circuito pode ficar aberto ou apresentar leituras estranhas. |
Abra o monitor serial, cubra o LDR com a mão e anote os valores aproximados. Depois ilumine o LDR e anote novamente. Com base nesses números, ajuste o limite do if para que o LED acenda somente quando o ambiente estiver escuro.
O Arduino envia um pulso ultrassônico, mede o tempo do eco e calcula a distância até um objeto.
Montar um circuito capaz de medir a distância entre o sensor HC-SR04 e um objeto. O Arduino enviará um pequeno pulso pelo pino TRIG, aguardará o retorno pelo pino ECHO e mostrará o resultado, em centímetros, no Monitor Serial.
Neste projeto, o aluno passa a trabalhar com uma medição baseada em tempo: o programa não recebe a distância pronta, mas calcula o valor a partir da duração do eco.
| Pino do HC-SR04 | Ligação no Arduino | Função |
|---|---|---|
| VCC | 5V | Alimenta o sensor. |
| TRIG | Pino digital 3 | Recebe do Arduino um pulso curto que inicia a medição. |
| ECHO | Pino digital 2 | Permanece em HIGH durante o tempo de ida e volta do som. |
| GND | GND | Fecha o circuito e fornece a referência elétrica. |
O HC-SR04 possui dois transdutores circulares. Um deles emite ondas ultrassônicas e o outro recebe o eco refletido por um objeto.
O pino TRIG é configurado como saída porque o Arduino envia por ele o comando de início. O pino ECHO é configurado como entrada porque o Arduino mede nele a duração do sinal devolvido pelo sensor.
Os pinos VCC e GND alimentam o módulo. Nesta montagem, o sensor deve ser alimentado com 5V.
O sensor mede o tempo que o som leva para ir até o objeto e retornar. Como esse tempo inclui os dois percursos, o cálculo considera apenas metade do caminho.
No programa, pulseIn() mede a duração do pulso recebido no pino ECHO. Dividindo esse tempo por aproximadamente 58, obtemos uma estimativa da distância em centímetros.
O sensor não identifica qual é o objeto. Ele apenas informa o tempo do eco; o Arduino transforma esse tempo em distância.
// Projeto 7: Sensor de distância com HC-SR04
// O Arduino mede o tempo do eco e calcula a distância em centímetros.
const int pinoTrig = 3;
const int pinoEcho = 2;
long duracao = 0;
float distancia = 0;
void setup() {
pinMode(pinoTrig, OUTPUT);
pinMode(pinoEcho, INPUT);
Serial.begin(9600);
}
void loop() {
distancia = medirDistancia();
Serial.print("Distancia: ");
Serial.print(distancia);
Serial.println(" cm");
delay(200);
}
float medirDistancia() {
digitalWrite(pinoTrig, LOW);
delayMicroseconds(2);
digitalWrite(pinoTrig, HIGH);
delayMicroseconds(10);
digitalWrite(pinoTrig, LOW);
duracao = pulseIn(pinoEcho, HIGH);
return duracao / 58.0;
}const int pinoTrig = 3; — define o pino que enviará o comando de início da medição.
const int pinoEcho = 2; — define o pino que receberá o sinal de retorno.
long duracao = 0; — guarda o tempo do pulso em microssegundos. O tipo long permite armazenar valores maiores.
float distancia = 0; — guarda a distância com possibilidade de casas decimais.
pinMode(pinoTrig, OUTPUT); — configura TRIG como saída.
pinMode(pinoEcho, INPUT); — configura ECHO como entrada.
distancia = medirDistancia(); — chama a função e guarda o valor que ela retorna.
digitalWrite(pinoTrig, LOW); — garante que o pino comece desligado.
delayMicroseconds(2); — cria uma pausa curta para estabilizar o sinal.
digitalWrite(pinoTrig, HIGH); e delayMicroseconds(10); — enviam o pulso de 10 microssegundos que inicia a medição.
pulseIn(pinoEcho, HIGH); — mede por quanto tempo o pino ECHO permaneceu em HIGH.
return duracao / 58.0; — converte o tempo medido em uma estimativa de distância e devolve o resultado à função principal.
Serial.print() e Serial.println() — exibem a distância no Monitor Serial.
Ao abrir o Monitor Serial na velocidade de 9600, devem aparecer medições semelhantes a:
Distancia: 18.45 cm Distancia: 18.31 cm Distancia: 32.76 cm
Ao aproximar ou afastar um objeto da frente do sensor, os valores devem mudar. Pequenas oscilações são normais porque a reflexão do som varia conforme a posição, o formato e o material do objeto.
| Erro | Consequência |
|---|---|
| Trocar VCC e GND | O sensor não funciona e pode ser danificado. |
| Ligar TRIG e ECHO nos pinos errados | O programa não consegue iniciar ou medir corretamente o eco. |
| Usar pinos diferentes de 3 e 2 sem alterar o código | As ligações físicas deixam de corresponder ao programa. |
| Não configurar o Monitor Serial em 9600 | Os dados podem aparecer ilegíveis. |
| Apontar o sensor para uma superfície muito inclinada ou irregular | O eco pode ser desviado e a leitura ficar instável. |
| Colocar o objeto muito próximo dos transdutores | A medição pode ficar incorreta porque o sensor possui uma distância mínima de funcionamento. |
| Esquecer de dividir o tempo de ida e volta | O resultado calculado fica aproximadamente duas vezes maior. |
Posicione uma régua diante do sensor e escolha três distâncias, como 10 cm, 20 cm e 30 cm. Compare os valores da régua com os valores exibidos no Monitor Serial e anote as diferenças encontradas.
Depois, repita o teste usando objetos de formatos ou materiais diferentes. Observe quais deles produzem leituras mais estáveis e explique por que a reflexão do som pode mudar.
O Arduino controla separadamente os canais vermelho, verde e azul para produzir diferentes combinações de cores.
Aprender a ligar e controlar um LED RGB de cátodo comum. O componente reúne três LEDs internos — vermelho, verde e azul — que podem ser acionados separadamente ou ao mesmo tempo.
Ao combinar esses três canais, o circuito produzirá vermelho, verde, azul, amarelo, ciano, magenta, branco e o estado apagado.
| Terminal do LED RGB | Ligação | Observação |
|---|---|---|
| Vermelho (R) | Pino digital 9, passando por resistor de 300 Ω | Controla o canal vermelho. |
| Cátodo comum | GND | É o terminal comum dos três LEDs internos. |
| Verde (G) | Pino digital 11, passando por resistor de 300 Ω | Controla o canal verde. |
| Azul (B) | Pino digital 10, passando por resistor de 300 Ω | Controla o canal azul. |
O segundo terminal do LED, na orientação mostrada na imagem, é o cátodo comum e deve ser ligado ao GND pelo jumper preto.
Os outros três terminais correspondem às cores vermelho, verde e azul. Cada canal precisa de seu próprio resistor para limitar a corrente e proteger o componente.
Os jumpers seguem as cores dos canais, facilitando a identificação visual das ligações.
Embora pareça um único LED, o componente possui três emissores de luz dentro da mesma cápsula. Cada emissor responde a um pino diferente do Arduino.
Como o modelo é de cátodo comum, enviar HIGH a um canal acende essa cor; enviar LOW a apaga.
Quando dois ou três canais são ligados simultaneamente, as luzes se combinam e nossos olhos percebem uma nova cor.
// Projeto 10: LED RGB
// Combinação de cores com sinais digitais.
const int pinoLEDR = 9;
const int pinoLEDB = 10;
const int pinoLEDG = 11;
void setup() {
pinMode(pinoLEDR, OUTPUT);
pinMode(pinoLEDB, OUTPUT);
pinMode(pinoLEDG, OUTPUT);
}
void loop() {
definirCor(HIGH, LOW, LOW); // Vermelho
delay(1000);
definirCor(LOW, HIGH, LOW); // Verde
delay(1000);
definirCor(LOW, LOW, HIGH); // Azul
delay(1000);
definirCor(HIGH, HIGH, LOW); // Amarelo
delay(1000);
definirCor(LOW, HIGH, HIGH); // Ciano
delay(1000);
definirCor(HIGH, LOW, HIGH); // Magenta
delay(1000);
definirCor(HIGH, HIGH, HIGH); // Branco
delay(1000);
definirCor(LOW, LOW, LOW); // Apagado
delay(1000);
}
void definirCor(bool vermelho, bool verde, bool azul) {
digitalWrite(pinoLEDR, vermelho);
digitalWrite(pinoLEDG, verde);
digitalWrite(pinoLEDB, azul);
}const int pinoLEDR = 9; — associa o canal vermelho ao pino 9.
const int pinoLEDB = 10; — associa o canal azul ao pino 10.
const int pinoLEDG = 11; — associa o canal verde ao pino 11.
pinMode(..., OUTPUT); — configura os três pinos como saídas digitais.
definirCor(HIGH, LOW, LOW); — liga somente o vermelho.
definirCor(HIGH, HIGH, LOW); — liga vermelho e verde ao mesmo tempo, formando amarelo.
void definirCor(bool vermelho, bool verde, bool azul) — recebe o estado de cada canal e evita repetir três comandos em cada etapa.
digitalWrite() — envia HIGH ou LOW para ligar ou desligar cada cor.
| Vermelho | Verde | Azul | Resultado |
|---|---|---|---|
| HIGH | LOW | LOW | Vermelho |
| LOW | HIGH | LOW | Verde |
| LOW | LOW | HIGH | Azul |
| HIGH | HIGH | LOW | Amarelo |
| LOW | HIGH | HIGH | Ciano |
| HIGH | LOW | HIGH | Magenta |
| HIGH | HIGH | HIGH | Branco |
| LOW | LOW | LOW | Apagado |
Ao iniciar a simulação, o LED deve apresentar cada combinação por aproximadamente um segundo.
A sequência será: vermelho, verde, azul, amarelo, ciano, magenta, branco e apagado. Depois, o ciclo recomeçará automaticamente.
As cores combinadas podem não parecer perfeitamente puras porque cada emissor interno possui brilho próprio e a percepção também varia conforme a tela ou o componente físico.
| Problema | Possível causa ou correção |
|---|---|
| Nenhuma cor acende | Confira se o cátodo comum está ligado ao GND e se a orientação do LED está correta. |
| Uma das cores não aparece | Verifique o jumper, o resistor e o pino correspondente àquela cor. |
| As cores aparecem trocadas | Confirme a ordem dos terminais e compare-a com as cores dos jumpers. |
| O LED foi ligado sem os três resistores | Desligue o circuito e coloque um resistor em série com cada canal de cor. |
| O comportamento está invertido | Confira se o componente escolhido é realmente de cátodo comum; LEDs de ânodo comum usam lógica invertida. |
Altere a ordem das cores no programa. Mostre primeiro as três cores primárias, depois as três combinações secundárias, mantenha o branco aceso por dois segundos e apague o LED antes de reiniciar.
Depois, retire duas cores da sequência e explique quais chamadas de definirCor() foram removidas.
O Arduino controla a posição de um Micro Servo e introduz, pela primeira vez no módulo, o uso de uma biblioteca.
Conhecer o servomotor e aprender a posicionar seu eixo em ângulos determinados pelo programa.
Neste projeto o Micro Servo irá assumir, em sequência, as posições aproximadas de 0°, 90° e 180°, retornando depois para 90° e reiniciando o ciclo.
Não é necessário resistor nem protoboard nesta montagem.
| Fio do Micro Servo | Função | Arduino |
|---|---|---|
| Amarelo | Sinal de controle | Pino digital D6 |
| Vermelho | Alimentação | 5V |
| Preto | GND / solo | GND |
Diferentemente de um motor comum, que normalmente gira enquanto estiver alimentado, o servomotor é utilizado para posicionar seu eixo.
O Arduino envia um sinal de controle e o circuito interno do servo movimenta o eixo até a posição solicitada.
No Micro Servo utilizado no Tinkercad, trabalharemos com posições entre aproximadamente 0° e 180°.
Até este ponto, os programas utilizaram diretamente os comandos básicos do Arduino. Neste projeto aparece um novo conceito: a biblioteca.
Uma biblioteca é um conjunto de códigos já preparados para facilitar determinada tarefa. A biblioteca Servo já contém os recursos necessários para controlar um servomotor sem precisarmos programar manualmente todos os sinais elétricos envolvidos.
#include <Servo.h> — inclui no programa os recursos da biblioteca Servo.
Servo meuServo; — cria um objeto chamado meuServo. Esse será o nome usado pelo programa para representar e controlar o servomotor.
Neste momento não é necessário aprofundar orientação a objetos: basta entender que meuServo passa a ser o nome pelo qual comandaremos esse componente.
// Projeto 11: Servo Motor
// Controle de posições com a biblioteca Servo.
#include <Servo.h>
Servo meuServo;
const int pinoServo = 6;
void setup() {
meuServo.attach(pinoServo);
}
void loop() {
meuServo.write(0);
delay(1000);
meuServo.write(90);
delay(1000);
meuServo.write(180);
delay(1000);
meuServo.write(90);
delay(1000);
}#include <Servo.h> — disponibiliza os comandos da biblioteca Servo.
Servo meuServo; — cria o objeto que representará o servo no programa.
const int pinoServo = 6; — registra que o fio de sinal está ligado ao pino D6.
meuServo.attach(pinoServo); — associa o objeto meuServo ao pino D6 e inicia o controle do servo por esse pino.
meuServo.write(0); — solicita a posição aproximada de 0°.
meuServo.write(90); — solicita a posição aproximada de 90°.
meuServo.write(180); — solicita a posição aproximada de 180°.
delay(1000); — mantém cada etapa por um segundo antes do próximo comando.
attach() não representa um ângulo. Ele informa à biblioteca qual pino do Arduino será usado para controlar aquele servo.
Depois dessa associação, os comandos enviados a meuServo produzirão o sinal de controle no pino D6.
Já write() informa a posição desejada. Por exemplo, meuServo.write(90) solicita que o eixo vá aproximadamente para 90°.
Ao iniciar a simulação, o servo será inicializado pela biblioteca e poderá apresentar um pequeno reposicionamento inicial.
Em seguida, deverá executar continuamente a sequência:
0° → 90° → 180° → 90° → 0°...
Cada posição permanecerá aproximadamente um segundo antes da próxima ordem.
| Problema | Possível causa ou correção |
|---|---|
| O servo não se movimenta | Confira as três ligações: sinal em D6, alimentação em 5V e GND. |
O programa não reconhece Servo | Confira se a linha #include <Servo.h> está presente e escrita corretamente. |
| O servo não responde aos comandos | Verifique se attach() está no setup() e se utiliza o mesmo pino ligado ao fio de sinal. |
| A sequência ocorre rápido demais | Confira os valores de delay(). |
| O servo físico real apresenta comportamento instável | Servos podem exigir mais corrente do que o Arduino consegue fornecer em determinadas situações. Este projeto inicial utiliza o Micro Servo do Tinkercad e uma montagem didática simples. |
Altere a sequência para que o servo passe pelas posições 30°, 60°, 120° e 150°, permanecendo um segundo em cada uma delas.
Depois, crie outra sequência usando pelo menos quatro posições diferentes, sem utilizar estruturas de repetição novas.
Reutilizando o circuito do potenciômetro com PWM para visualizar, no Monitor Serial, o que o Arduino está lendo e enviando ao LED.
Até agora, observamos o resultado dos programas principalmente pelo comportamento dos componentes: LED acendendo, buzzer tocando ou brilho variando.
Neste laboratório, a pergunta muda: como descobrir quais valores o Arduino está lendo enquanto o programa está funcionando?
Utilizar o Monitor Serial para acompanhar os valores lidos no potenciômetro e os valores enviados ao LED pelo PWM.
O circuito é conhecido. A novidade está em enxergar os dados que antes ficavam invisíveis.
| Componente | Ligação | Função |
|---|---|---|
| Potenciômetro | Terminal central no A0; laterais em 5V e GND | Enviar ao Arduino uma leitura analógica variável. |
| LED | Pino PWM 9, resistor de 300 Ω e GND | Variar o brilho de acordo com o valor calculado no programa. |
| Monitor Serial | Comunicação pelo cabo USB | Mostrar no computador os valores enviados pelo Arduino. |
// Laboratório 2: Conversando com o Arduino
// Utilizando o Monitor Serial.
// O potenciômetro controla o brilho do LED e envia
// as informações para o Monitor Serial.
int pinoPotenciometro = A0;
int pinoLed = 9;
int leituraPotenciometro = 0;
int brilhoLed = 0;
void setup() {
pinMode(pinoLed, OUTPUT);
Serial.begin(9600);
}
void loop() {
leituraPotenciometro = analogRead(pinoPotenciometro);
brilhoLed = map(leituraPotenciometro, 0, 1023, 0, 255);
analogWrite(pinoLed, brilhoLed);
Serial.print("Leitura: ");
Serial.print(leituraPotenciometro);
Serial.print(" Brilho: ");
Serial.println(brilhoLed);
delay(100);
}Serial.begin(9600); — inicia a comunicação entre o Arduino e o computador.
Serial.print() — escreve um texto ou valor no Monitor Serial sem mudar de linha.
Serial.println() — escreve um texto ou valor e muda para a próxima linha.
9600 — representa a velocidade da comunicação. Use o mesmo valor no programa e no Monitor Serial.
Ao girar o potenciômetro, duas coisas devem acontecer ao mesmo tempo:
Você deverá visualizar algo parecido com:
Leitura: 532 Brilho: 132
O potenciômetro gera leituras de aproximadamente 0 a 1023.
O brilho do LED usa valores de aproximadamente 0 a 255.
É por isso que usamos a função map(): ela adapta a faixa de valores da entrada analógica para a faixa usada pelo PWM.
1. Altere o delay(100) para delay(500). O que mudou na exibição dos valores?
2. Gire o potenciômetro até aproximadamente a metade. Quais valores aparecem em Leitura e Brilho?
3. Em outro momento, teste a mesma ideia com o circuito do LDR. O que muda: o programa ou os valores lidos?
Reutilizando o HC-SR04 do Projeto 7, LEDs e buzzer para criar alertas visuais e sonoros de proximidade.
Este laboratório reutiliza a medição desenvolvida no Projeto 7 — Sensor de distância com HC-SR04. Mantenha o sensor ligado aos pinos TRIG 3 e ECHO 2.
Agora serão acrescentados componentes já estudados: seis LEDs, resistores e um buzzer.
Construir um sistema de alerta de proximidade semelhante a um sensor de ré didático.
O programa transformará a distância medida em dois tipos de resposta: uma indicação visual com LEDs e um aviso sonoro cujo intervalo diminui à medida que o objeto se aproxima.
Também serão reutilizados o Arduino, a protoboard e o HC-SR04 montados no Projeto 7.
| Componente | Ligação no Arduino | Função |
|---|---|---|
| HC-SR04 — TRIG | Pino digital 3 | Iniciar a medição ultrassônica. |
| HC-SR04 — ECHO | Pino digital 2 | Informar a duração do eco. |
| Buzzer passivo | Pino digital 7 e GND | Produzir o alerta sonoro. |
| LED verde 1 | Pino digital 8, resistor de 300 Ω e GND | Primeiro nível de aproximação. |
| LED verde 2 | Pino digital 9, resistor de 300 Ω e GND | Segundo nível de aproximação. |
| LED verde 3 | Pino digital 10, resistor de 300 Ω e GND | Terceiro nível de aproximação. |
| LED amarelo 1 | Pino digital 11, resistor de 300 Ω e GND | Alerta intermediário. |
| LED amarelo 2 | Pino digital 12, resistor de 300 Ω e GND | Alerta elevado. |
| LED vermelho | Pino digital 13, resistor de 300 Ω e GND | Distância crítica. |
// Laboratório 3: Sensor de ré
// Reutiliza o HC-SR04 do Projeto 7.
const int pinoTrig = 3;
const int pinoEcho = 2;
const int pinoBuzzer = 7;
float distancia = 0;
int intervalo = 0;
void setup() {
Serial.begin(9600);
pinMode(pinoTrig, OUTPUT);
pinMode(pinoEcho, INPUT);
pinMode(pinoBuzzer, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);
}
void loop() {
distancia = medirDistancia();
Serial.print("Distancia: ");
Serial.print(distancia);
Serial.println(" cm");
if (distancia > 60) {
digitalWrite(8, LOW);
digitalWrite(9, LOW);
digitalWrite(10, LOW);
digitalWrite(11, LOW);
digitalWrite(12, LOW);
digitalWrite(13, LOW);
noTone(pinoBuzzer);
}
else if (distancia <= 10) {
digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
digitalWrite(12, HIGH);
digitalWrite(13, HIGH);
tone(pinoBuzzer, 1750);
}
else {
if (distancia <= 20) {
digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
digitalWrite(12, HIGH);
digitalWrite(13, LOW);
intervalo = 100;
}
else if (distancia <= 30) {
digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
digitalWrite(12, LOW);
digitalWrite(13, LOW);
intervalo = 150;
}
else if (distancia <= 40) {
digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
digitalWrite(10, HIGH);
digitalWrite(11, LOW);
digitalWrite(12, LOW);
digitalWrite(13, LOW);
intervalo = 200;
}
else if (distancia <= 50) {
digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
digitalWrite(10, LOW);
digitalWrite(11, LOW);
digitalWrite(12, LOW);
digitalWrite(13, LOW);
intervalo = 250;
}
else {
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
digitalWrite(10, LOW);
digitalWrite(11, LOW);
digitalWrite(12, LOW);
digitalWrite(13, LOW);
intervalo = 300;
}
tone(pinoBuzzer, 1750);
delay(intervalo);
noTone(pinoBuzzer);
delay(intervalo);
}
}
float medirDistancia() {
digitalWrite(pinoTrig, LOW);
delayMicroseconds(2);
digitalWrite(pinoTrig, HIGH);
delayMicroseconds(10);
digitalWrite(pinoTrig, LOW);
long duracao = pulseIn(pinoEcho, HIGH);
return duracao / 58.0;
}distancia = medirDistancia(); — reutiliza a função criada no Projeto 7.
if (distancia > 60) — mantém todos os alertas desligados quando o objeto está longe.
else if (distancia <= 10) — representa a situação crítica: todos os LEDs acendem e o buzzer permanece ligado.
Os demais testes com else if dividem a distância em faixas. Cada faixa define quantos LEDs ficarão acesos e qual será o valor de intervalo.
tone(pinoBuzzer, 1750); — inicia o som do buzzer na frequência de 1750 Hz.
delay(intervalo); — determina por quanto tempo o buzzer fica ligado e desligado. Quanto menor o intervalo, mais rápidos ficam os bipes.
Quanto mais próximo o objeto estiver do HC-SR04, maior será o número de LEDs acesos e mais rápidos serão os bipes.
Ao chegar a 10 cm ou menos, todos os LEDs devem permanecer acesos e o buzzer deve emitir um sinal contínuo.
| Erro | Consequência |
|---|---|
| Inverter a polaridade de um LED | Esse LED não acende. |
| Esquecer algum resistor de 300 Ω | O LED fica sem proteção e pode ser danificado. |
| Ligar um LED em pino diferente do indicado | A sequência visual não corresponde ao programa. |
| Usar buzzer ativo no lugar do passivo | O comportamento do comando tone() pode não ser o esperado. |
| Trocar TRIG e ECHO | A medição de distância não funciona corretamente. |
| Não compartilhar o GND entre os componentes | O circuito pode não funcionar ou apresentar comportamento instável. |
1. Altere o limite máximo de 60 cm para 100 cm e redistribua as faixas de distância.
2. Troque a frequência 1750 por outros valores e compare os sons produzidos.
3. Modifique o código para manter apenas os LEDs, sem utilizar o buzzer.
Este circuito é apenas didático. O HC-SR04 e a montagem em protoboard não são componentes automotivos e não devem ser usados como sistema real de segurança ou manobra de veículos.
Reutilizando o LED RGB do Projeto 10 e os botões do Projeto 3 para controlar separadamente as cores vermelho, verde e azul.
Este laboratório integra dois conhecimentos já trabalhados: o LED RGB do Projeto 10 e a leitura de botões do Projeto 3.
O LED continua sendo de cátodo comum, com os canais vermelho, verde e azul protegidos por resistores. Os três botões serão usados como entradas digitais.
Controlar cada canal do LED RGB com um botão independente.
Ao pressionar mais de um botão ao mesmo tempo, as cores serão combinadas: vermelho + verde produz amarelo, verde + azul produz ciano, vermelho + azul produz magenta e os três juntos produzem branco.
Todos esses componentes já foram utilizados em projetos anteriores.
| Componente | Ligação no Arduino | Função |
|---|---|---|
| Canal vermelho do LED RGB | Pino 9, passando por resistor de 300 Ω | Controlar a luz vermelha. |
| Canal azul do LED RGB | Pino 10, passando por resistor de 300 Ω | Controlar a luz azul. |
| Canal verde do LED RGB | Pino 11, passando por resistor de 300 Ω | Controlar a luz verde. |
| Cátodo comum do LED RGB | GND | Referência comum dos três LEDs internos. |
| Botão vermelho | Pino 7 e GND | Controlar o canal vermelho. |
| Botão verde | Pino 6 e GND | Controlar o canal verde. |
| Botão azul | Pino 5 e GND | Controlar o canal azul. |
Os três botões utilizam INPUT_PULLUP. Dessa forma, não é necessário acrescentar resistores externos para manter as entradas em um estado conhecido.
Quando o botão está solto, a leitura é HIGH. Quando ele é pressionado, o pino é conectado ao GND e a leitura passa para LOW.
Por isso, neste programa, a condição leituraBotaoR == LOW significa que o botão vermelho está pressionado.
| Botões pressionados | Cor resultante |
|---|---|
| Vermelho | Vermelho |
| Verde | Verde |
| Azul | Azul |
| Vermelho + Verde | Amarelo |
| Verde + Azul | Ciano |
| Vermelho + Azul | Magenta |
| Vermelho + Verde + Azul | Branco |
| Nenhum | Apagado |
const int pinoLEDG = 11;
const int pinoLEDB = 10;
const int pinoLEDR = 9;
const int pinoBotaoR = 7;
const int pinoBotaoG = 6;
const int pinoBotaoB = 5;
int leituraBotaoR;
int leituraBotaoG;
int leituraBotaoB;
void setup() {
pinMode(pinoLEDR, OUTPUT);
pinMode(pinoLEDG, OUTPUT);
pinMode(pinoLEDB, OUTPUT);
pinMode(pinoBotaoR, INPUT_PULLUP);
pinMode(pinoBotaoG, INPUT_PULLUP);
pinMode(pinoBotaoB, INPUT_PULLUP);
}
void loop() {
leituraBotaoR = digitalRead(pinoBotaoR);
leituraBotaoG = digitalRead(pinoBotaoG);
leituraBotaoB = digitalRead(pinoBotaoB);
if (leituraBotaoR == LOW) {
digitalWrite(pinoLEDR, HIGH);
} else {
digitalWrite(pinoLEDR, LOW);
}
if (leituraBotaoG == LOW) {
digitalWrite(pinoLEDG, HIGH);
} else {
digitalWrite(pinoLEDG, LOW);
}
if (leituraBotaoB == LOW) {
digitalWrite(pinoLEDB, HIGH);
} else {
digitalWrite(pinoLEDB, LOW);
}
delay(100);
}const int pinoLEDG = 11;, pinoLEDB = 10; e pinoLEDR = 9; — definem os três pinos que controlam os canais do LED RGB.
pinoBotaoR = 7, pinoBotaoG = 6 e pinoBotaoB = 5 — identificam os pinos usados para ler os três botões.
pinMode(..., INPUT_PULLUP); — ativa o resistor interno de pull-up do Arduino. Por isso, o botão solto gera HIGH e o botão pressionado gera LOW.
digitalRead() — lê o estado de cada botão e armazena o resultado nas variáveis leituraBotaoR, leituraBotaoG e leituraBotaoB.
Cada estrutura if / else verifica um botão independentemente. Se estiver pressionado, o respectivo canal recebe HIGH e acende; caso contrário, recebe LOW e permanece apagado.
digitalWrite() é adequado aqui porque cada canal trabalha apenas com dois estados: ligado ou desligado. Neste laboratório não há controle gradual de brilho.
delay(100); — cria uma pequena pausa entre as leituras sucessivas dos botões.
Cada botão deve controlar somente seu respectivo canal de cor.
Ao pressionar dois ou três botões simultaneamente, os canais permanecem ligados ao mesmo tempo e formam as demais combinações RGB. Ao soltar todos os botões, o LED deve apagar.
| Erro | Consequência |
|---|---|
| Ligar um botão em pino diferente do código | A cor acionada não corresponde ao botão esperado. |
| Esquecer que INPUT_PULLUP inverte a lógica | O aluno pode interpretar HIGH como botão pressionado, quando neste circuito ocorre o contrário. |
| Não ligar os botões ao GND | O pressionamento não produz a mudança esperada na entrada. |
| Trocar os terminais R, G ou B do LED | As cores exibidas não correspondem ao programa. |
| Ligar incorretamente o cátodo comum | O LED pode não acender corretamente. |
| Retirar algum dos três resistores | Um dos canais fica sem limitação adequada de corrente. |
1. Inverta no código dois botões e observe como muda a associação entre botão e cor.
2. Altere delay(100) para delay(500) e compare a resposta dos botões.
3. Modifique o programa para que cada botão controle uma cor diferente da indicada pelo jumper.
Integrando o sensor ultrassônico HC-SR04 do Projeto 7 com o Servo Motor do Projeto 11 para criar uma aplicação prática de abertura automática.
Este laboratório reutiliza conhecimentos já trabalhados: medição de distância com o HC-SR04, controle de posição com Servo Motor, uso do Monitor Serial, funções e estruturas condicionais.
O principal conceito novo será a estrutura de repetição for, usada para movimentar o servo gradualmente.
Construir uma lixeira automática didática: quando uma mão ou objeto se aproximar a 15 cm ou menos, o servo deverá abrir a tampa gradualmente até 120°, mantê-la aberta por 3 segundos e fechá-la novamente.
O sistema só poderá abrir outra vez depois que o objeto se afastar do sensor.
Todos os componentes principais já foram utilizados anteriormente. A protoboard é usada aqui para distribuir 5V e GND ao sensor e ao servo.
| Componente | Terminal / fio | Ligação |
|---|---|---|
| Arduino | 5V | Barramento positivo (+) da protoboard |
| Arduino | GND | Barramento negativo (−) da protoboard |
| Micro Servo | Sinal (amarelo) | Pino digital D9 |
| Micro Servo | Alimentação (vermelho) | Barramento positivo (+) |
| Micro Servo | GND (preto) | Barramento negativo (−) |
| HC-SR04 | VCC | Barramento positivo (+) |
| HC-SR04 | TRIG | Pino digital D3 |
| HC-SR04 | ECHO | Pino digital D2 |
| HC-SR04 | GND | Barramento negativo (−) |
A variável podeAbrir funciona como uma trava lógica.
bool podeAbrir = true; — inicialmente a lixeira está liberada para abrir.
podeAbrir = false; — depois que a abertura começa, impede que o sistema abra novamente enquanto o objeto continuar perto.
Quando a distância volta a ser maior que 15 cm, podeAbrir recebe true e uma nova abertura fica autorizada.
Uma variável do tipo bool possui apenas dois valores possíveis: true ou false.
Nos programas anteriores, quando era necessário repetir comandos, eles apareciam escritos várias vezes. O for permite repetir automaticamente um bloco de código enquanto uma condição for verdadeira.
for (posicao = 0; posicao <= 120; posicao += 1) {
meuServo.write(posicao);
delay(15);
}posicao = 0 — valor inicial: o movimento começa em 0°.
posicao <= 120 — condição: a repetição continua enquanto a posição for menor ou igual a 120°.
posicao += 1 — atualização: após cada repetição, a posição aumenta 1 grau.
Assim, o servo recebe sucessivamente 0°, 1°, 2°, 3°... até 120°, criando um movimento gradual.
Para fechar a tampa, o processo é invertido: começa em 120° e diminui 1 grau a cada repetição até chegar a 0°.
#include <Servo.h>
Servo meuServo;
const int pinoServo = 9;
const int TRIG = 3;
const int ECHO = 2;
int posicao = 0;
unsigned int distancia;
bool podeAbrir = true;
void setup() {
meuServo.attach(pinoServo);
meuServo.write(0);
Serial.begin(9600);
pinMode(TRIG, OUTPUT);
pinMode(ECHO, INPUT);
}
void loop() {
distancia = medirDistancia(TRIG, ECHO);
Serial.println(distancia);
// Libera uma nova abertura somente depois
// que a mão ou objeto se afastar.
if (distancia > 15) {
podeAbrir = true;
}
if (distancia <= 15 && podeAbrir) {
podeAbrir = false;
// Abre a tampa gradualmente.
for (posicao = 0; posicao <= 120; posicao += 1) {
meuServo.write(posicao);
delay(15);
}
// Mantém a tampa aberta por 3 segundos.
delay(3000);
// Fecha a tampa gradualmente.
for (posicao = 120; posicao >= 0; posicao -= 1) {
meuServo.write(posicao);
delay(15);
}
}
}
int medirDistancia(int pinoTrig, int pinoEcho) {
digitalWrite(pinoTrig, LOW);
delayMicroseconds(2);
digitalWrite(pinoTrig, HIGH);
delayMicroseconds(10);
digitalWrite(pinoTrig, LOW);
return pulseIn(pinoEcho, HIGH) / 58;
}#include <Servo.h> e Servo meuServo; — reutilizam a biblioteca e o objeto apresentados no Projeto 11.
const int pinoServo = 9; — define o D9 como pino de sinal do servo.
TRIG = 3 e ECHO = 2 — definem os pinos do HC-SR04.
meuServo.write(0); — inicia a tampa na posição fechada.
medirDistancia(TRIG, ECHO) — reutiliza a função de medição do sensor ultrassônico.
Serial.println(distancia); — permite acompanhar as medições no Monitor Serial.
if (distancia > 15) — libera uma nova abertura somente quando o objeto se afasta.
if (distancia <= 15 && podeAbrir) — inicia a abertura somente quando há um objeto próximo e a trava está liberada.
Os dois comandos for realizam a abertura e o fechamento graduais.
A lixeira deve responder a uma aproximação apenas uma vez, abrir e fechar suavemente e exigir que a mão seja afastada antes de aceitar uma nova abertura.
O Monitor Serial deve continuar exibindo as distâncias sempre que o programa estiver novamente na etapa de leitura.
| Problema | Verifique |
|---|---|
| Servo não se move | Sinal no D9, alimentação no barramento positivo e GND no negativo. |
| Sensor não mede corretamente | TRIG no D3, ECHO no D2, VCC em 5V e GND comum. |
| Tampa abre repetidamente sem afastar a mão | Confira a variável podeAbrir e as duas estruturas if. |
| Tampa abre, mas não fecha gradualmente | Confira o segundo for: ele deve começar em 120 e usar posicao -= 1. |
| Movimento muito lento ou muito rápido | O delay(15) dentro do for controla o intervalo entre cada grau. |
medirDistancia()boolfor1. Troque a distância de acionamento de 15 cm para 20 cm.
2. Altere a abertura máxima de 120° para 90° e observe o resultado.
3. Troque o tempo de 3 segundos por 5 segundos.
4. Altere o delay(15) dos movimentos para comparar uma abertura mais rápida e uma mais lenta.
No Tinkercad, o Micro Servo e o HC-SR04 são alimentados pelos 5V do Arduino para simplificar o laboratório. Em uma aplicação física, o servo pode exigir uma alimentação adequada à corrente e à carga mecânica. A protoboard também é indicada para prototipagem, não como montagem definitiva de uma lixeira em uso cotidiano.
Esta seção reúne exercícios de revisão e aprofundamento dos fundamentos e dos projetos iniciais. As atividades estão organizadas por tema e misturam múltipla escolha interativa, questões abertas, completar código, interpretação de código e análise técnica. As questões abertas e os códigos não exibem gabarito.
Revise a base conceitual antes dos projetos: alimentação, GND, circuito fechado, resistor, protoboard, entrada, saída, digital, analógico e PWM.
Circuito usado: LED externo em um pino digital. Objetivo: configurar um pino como saída e ligar o LED.
// Complete o código conceitual.
// Pense: qual pino está ligado ao LED?
// Pense: qual modo permite controlar um componente de saída?
int pinoLed = ____;
void setup() {
pinMode(____, OUTPUT);
}
void loop() {
digitalWrite(pinoLed, ____);
}
Explique o que esse código faz, que tipo de componente poderia estar ligado ao A0 e que tipo de valores apareceriam no Monitor Serial.
int valor = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
valor = analogRead(A0);
Serial.println(valor);
delay(500);
}
Exercícios sobre alimentação elétrica, polaridade, resistor em série e uso do Arduino apenas como fonte de 5V e GND.
Circuito usado: LED protegido ligado diretamente ao 5V e GND. Objetivo: reconhecer que não há controle por programação neste projeto.
void setup() {
// Nenhuma configuração é ______________ neste projeto.
}
void loop() {
// Nenhum comando é ______________ neste projeto.
}
Explique por que esse código vazio ainda é coerente com o Projeto 1, desde que o circuito esteja montado corretamente.
void setup() {
}
void loop() {
}
Exercícios sobre controle digital de saída, pino 8, HIGH, LOW, delay e transição entre alimentação direta e programação.
Circuito usado: LED com resistor no pino digital 8. Objetivo: fazer o LED piscar por programação.
int pinoLed = ____;
void setup() {
pinMode(pinoLed, ______);
}
void loop() {
digitalWrite(pinoLed, ______);
delay(1000);
digitalWrite(pinoLed, ______);
delay(1000);
}
Explique como será o comportamento do LED. Ele fica mais tempo aceso ou apagado? Justifique.
int pinoLed = 8;
void setup() {
pinMode(pinoLed, OUTPUT);
}
void loop() {
digitalWrite(pinoLed, HIGH);
delay(200);
digitalWrite(pinoLed, LOW);
delay(800);
}
Exercícios sobre entrada digital, saída digital, botão tátil, INPUT_PULLUP, digitalRead, if/else e lógica invertida.
Circuito usado: botão no pino 2 e LED no pino 8. Objetivo: acender o LED somente enquanto o botão está pressionado.
int pinoLed = ____;
int pinoBotao = ____;
void setup() {
pinMode(pinoLed, ______);
pinMode(pinoBotao, ____________);
}
void loop() {
int estadoBotao = digitalRead(__________);
if (estadoBotao == ______) {
digitalWrite(pinoLed, HIGH);
} else {
digitalWrite(pinoLed, LOW);
}
}
Explique o comportamento desse código. O LED acende quando o botão está pressionado ou solto? Justifique com base no INPUT_PULLUP.
int pinoLed = 8;
int pinoBotao = 2;
void setup() {
pinMode(pinoLed, OUTPUT);
pinMode(pinoBotao, INPUT_PULLUP);
}
void loop() {
int estadoBotao = digitalRead(pinoBotao);
if (estadoBotao == HIGH) {
digitalWrite(pinoLed, HIGH);
} else {
digitalWrite(pinoLed, LOW);
}
}
Exercícios sobre saída sonora, buzzer ativo, pino digital 8, tone(), noTone() e controle de tempo com delay().
Circuito usado: buzzer ativo no pino digital 8. Objetivo: emitir som intermitente.
int pinoBuzzer = ____;
void setup() {
pinMode(pinoBuzzer, ______);
}
void loop() {
______(pinoBuzzer, 1000);
delay(1000);
______(pinoBuzzer);
delay(1000);
}
Explique como será o som produzido. O tempo de som será maior ou menor que o tempo de silêncio?
int pinoBuzzer = 8;
void setup() {
pinMode(pinoBuzzer, OUTPUT);
}
void loop() {
tone(pinoBuzzer, 1000);
delay(200);
noTone(pinoBuzzer);
delay(1200);
}
Exercícios sobre entrada analógica, potenciômetro, analogRead, map, PWM, analogWrite e controle gradual de brilho.
Circuito usado: potenciômetro no A0 e LED no pino PWM 9. Objetivo: controlar o brilho do LED.
int pinoPotenciometro = ____;
int pinoLed = ____;
int leituraPotenciometro = 0;
int brilhoLed = 0;
void setup() {
pinMode(pinoLed, ______);
}
void loop() {
leituraPotenciometro = __________(pinoPotenciometro);
brilhoLed = map(leituraPotenciometro, 0, ____, 0, ____);
__________(pinoLed, brilhoLed);
}
Explique o que mudou em relação ao controle normal do brilho. O LED aumenta ou diminui o brilho quando a leitura do potenciômetro aumenta?
int pinoPotenciometro = A0;
int pinoLed = 9;
void setup() {
pinMode(pinoLed, OUTPUT);
}
void loop() {
int leitura = analogRead(pinoPotenciometro);
int brilho = map(leitura, 0, 1023, 255, 0);
analogWrite(pinoLed, brilho);
}
Revise a leitura analógica do LDR, o controle do LED, o uso do monitor serial e a decisão feita com o comando if.
Complete mentalmente as partes que fazem a leitura do LDR e acendem o LED.
leitura = __________(pinoLDR);
if(leitura < 40){
digitalWrite(pinoLED, ______);
}
else {
digitalWrite(pinoLED, ______);
}Revise os terminais do LED RGB de cátodo comum, o uso de um resistor por canal e as combinações digitais das cores vermelho, verde e azul.
definirCor(HIGH, LOW, HIGH)?Complete a chamada que deve acender ciano e a chamada que apaga o LED.
definirCor(____, ____, ____); // Ciano
definirCor(____, ____, ____); // ApagadoCrie uma sequência que mostre: azul, magenta, vermelho, amarelo, verde e ciano. Coloque o LED apagado por 500 ms entre cada cor.
Revise a ligação do Micro Servo, a diferença entre alimentação e sinal, o primeiro uso de biblioteca e os comandos attach() e write().
#include <Servo.h>?meuServo.attach(pinoServo)?attach() e write()?Complete as linhas para associar o servo ao pino 6 e solicitar a posição de 120°.
const int pinoServo = ____;
void setup() {
meuServo.________(pinoServo);
}
void loop() {
meuServo.________(120);
}Sem utilizar for ou qualquer estrutura nova de repetição, escreva uma sequência que mova o servo para 20°, 70°, 110°, 160° e depois retorne para 70°. Utilize delay() entre as posições.
No código do laboratório, troque delay(100) por delay(500). Execute o programa e observe o Monitor Serial.
Explique o que mudou na exibição dos valores.
Gire o potenciômetro até uma posição intermediária e observe os valores exibidos no Monitor Serial.
Anote um exemplo de leitura e brilho. Depois explique por que o valor do brilho é menor que o valor da leitura.
Modifique o código para mostrar apenas a leitura do potenciômetro no Monitor Serial.
O objetivo é exibir somente números, um por linha.
Revise a integração entre distância, faixas condicionais, LEDs e buzzer.
Considere que o sensor mediu 35 cm. Indique quantos LEDs devem acender e qual intervalo será utilizado pelo buzzer.
Modifique a lógica para que o alerta contínuo seja acionado somente quando a distância for menor ou igual a 5 cm.
Explique qual condição precisa ser alterada.
Explique por que o Laboratório 3 é uma integração de conhecimentos anteriores e não a apresentação de um novo componente.
Revise INPUT_PULLUP, leitura digital e o controle independente dos três canais do LED RGB.
Explique por que o programa considera o botão pressionado quando digitalRead() retorna LOW.
Considere que os botões vermelho e azul estão pressionados e o botão verde está solto. Qual cor deverá aparecer no LED? Explique usando os três canais RGB.
Troque delay(100) por delay(1000). Antes de testar, preveja como essa mudança afetará a resposta do circuito aos botões.
No laboratório, analogWrite() recebe apenas 0 e 255. Explique o que cada valor faz neste circuito e por que não ocorre variação gradual de brilho.
Explique por que este conteúdo é um laboratório e não um novo projeto, identificando quais conhecimentos anteriores foram reutilizados.
Revise a integração entre HC-SR04 e Servo Motor, o uso de bool como trava lógica e a estrutura de repetição for.
podeAbrir?for, o que faz posicao += 1?for?podeAbrir voltar a true?Explique as três partes de for (posicao = 0; posicao <= 120; posicao += 1): inicialização, condição e atualização.
A mão permanece a 10 cm do sensor mesmo depois de a tampa fechar. Explique por que a tampa não abre novamente.
Complete o laço para fechar a tampa gradualmente:
for (posicao = ____; posicao >= ____; posicao ____ 1) {
meuServo.write(posicao);
delay(15);
}Modifique o programa para abrir a tampa quando a distância for 25 cm ou menos, abrir somente até 100° e permanecer aberta por 4 segundos.
Explique por que a lixeira automática é um laboratório e não um projeto de componente novo. Identifique quais conhecimentos dos Projetos 7 e 11 foram reutilizados e qual conceito de programação foi acrescentado.