Blog
Projeto de Semáforo Baseado em Arduino Uno
Os semáforos são algo que vemos todos os dias nas estradas. Eles controlam o fluxo de veículos e mantêm o trânsito em movimento de maneira organizada e sem acidentes. A maioria das pessoas nunca para para pensar em como essas luzes realmente funcionam, mas a ideia por trás delas é bastante simples quando você a analisa.
Neste artigo, construiremos um pequeno modelo de sistema de semáforo utilizando um Arduino Uno, alguns LEDs e uma protoboard. Este é um dos projetos mais comuns para iniciantes em eletrônica e sistemas embarcados, pois ensina os fundamentos do controle de saída digital, temporização e montagem de circuitos, tudo em um projeto simples.
Ao final deste artigo, você entenderá como um semáforo real funciona, como conectar os componentes, como escrever o código para ele e como testá-lo em sua própria placa Arduino.
Por que Este Projeto é um Bom Ponto de Partida
Qualquer pessoa que seja nova no Arduino ou em eletrônica frequentemente se esforça para encontrar um projeto que seja simples o suficiente para entender, mas que ainda ensine algo útil. O projeto de semáforo é perfeito para isso porque requer apenas um punhado de componentes, a fiação não é complicada e o código é curto e fácil de seguir. Ao mesmo tempo, ele introduz alguns conceitos muito importantes como:
- Como conectar LEDs com segurança utilizando resistores
- Como os pinos digitais em um microcontrolador funcionam
- Como controlar o tempo usando atrasos
- Como estruturar um programa utilizando laços de repetição
Estes são os mesmos blocos de construção usados em projetos muito mais avançados, portanto, aprendê-los aqui oferece uma base sólida para qualquer coisa que você possa construir posteriormente.
Componentes Necessários
Para construir este projeto, você não precisará de muitas peças. Aqui está a lista completa:
- Placa Arduino Uno
- Cabo USB para conectar o Arduino a um computador
- Placa de ensaio
- LED vermelho
- LED Amarelo
- LED verde
- Três resistores (220 ohms é um bom valor para LEDs)
- Fios jumper (macho para macho)
Todas estas peças são baratas e facilmente disponíveis em qualquer loja de eletrônicos ou loja online. Se você é estudante ou hobbista, é provável que já tenha a maioria delas guardadas de outros projetos pequenos. Para futuros projetos comerciais, a PCBCool também pode dar suporte Aquisição de componentes, auxiliando os clientes no gerenciamento da disponibilidade e aquisição de listas de materiais (BOM) juntamente com Montagem de PCB.
Compreendendo o Funcionamento de um Semáforo Real
Antes de começar a fiação, é útil compreender o padrão real que os semáforos seguem na vida real. Um semáforo padrão possui três cores, e cada uma delas tem um significado:
- Vermelho significa parar. Veículos não devem se mover.
- Amarelo significa prepare-se. A luz está prestes a mudar, portanto, os motoristas devem diminuir a velocidade.
- Verde significa siga. Veículos estão autorizados a se mover.
O ciclo normal na maioria dos países segue este padrão: a luz permanece vermelha por algum tempo, depois fica verde e, antes de voltar ao vermelho, exibe brevemente o amarelo como aviso. Este ciclo se repete continuamente. Nosso projeto Arduino irá copiar este mesmo padrão usando LEDs em vez de lâmpadas grandes de semáforo.
Diagrama do Circuito e Fiação
A fiação para este projeto é bastante simples, pois estamos trabalhando apenas com três LEDs. Cada LED precisa ser conectado a um pino digital do Arduino através de um resistor, e o outro terminal de cada LED precisa ser conectado ao pino de terra.
Abaixo está o diagrama do circuito mostrando como tudo deve ser conectado. Os LEDs vermelho, amarelo e verde são posicionados na protoboard, e cada um é conectado de volta ao Arduino usando jumpers coloridos. Observe como o fio preto percorre o trilho inferior da protoboard para fornecer uma conexão de terra comum para os três LEDs.
Conforme demonstrado no diagrama, as conexões são:
- LED vermelho conectado ao pino digital 9
- LED amarelo conectado ao pino digital 8
- LED verde conectado ao pino digital 7
- Todas as pernas de aterramento dos LEDs são conectadas ao pino GND do Arduino através do barramento de aterramento da protoboard.
O(a) senhor(a) pode usar diferentes pinos se preferir, apenas certifique-se de que os pinos em seu código correspondam aos pinos que o(a) senhor(a) realmente conectar.
Etapas de Fiação
Aqui está um passo a passo para construir o circuito:
- Posicione o Arduino ao lado da protoboard de forma que os fios possam alcançar confortavelmente o outro lado.
- Insira os LEDs vermelho, amarelo e verde na protoboard, mantendo algum espaço entre eles. Cada LED possui duas pernas, uma mais longa (positiva) e outra mais curta (negativa).
- Conecte um resistor de 220 ohms à perna mais longa (positiva) de cada LED. O resistor protege o LED contra corrente excessiva, que poderia queimá-lo.
- Passe um fio jumper da outra extremidade de cada resistor para os pinos digitais do Arduino (9, 8 e 7 em nosso exemplo).
- Conecte o terminal menor (negativo) de cada LED ao barramento de terra na protoboard.
- Finalmente, conecte o barramento de terra na protoboard ao pino GND do Arduino usando um único fio jumper.
Uma vez que esta fiação esteja completa, seu protoboard e Arduino devem se assemelhar à imagem abaixo, mostrando a configuração física finalizada com todos os três LEDs conectados e ligados à placa.
Nesta imagem, o Arduino Uno pode ser visto sendo alimentado através de um cabo USB, com fios jumper descendo para a protoboard onde os três LEDs estão dispostos em fila. Isto corresponde exatamente ao que descrevemos no diagrama do circuito, apenas em sua.
Escrevendo o código
Agora que o hardware está pronto, precisamos escrever o programa que controlará os LEDs. A linguagem de programação do Arduino é baseada em C e C++, mas para um projeto como este, você só precisa conhecer alguns comandos básicos.
Aqui está o código completo para o projeto do semáforo:
int redLED = 9;
int yellowLED = 8;
int greenLED = 7;
void setup() {
pinMode(redLED, OUTPUT);
pinMode(yellowLED, OUTPUT);
pinMode(greenLED, OUTPUT);
}
void loop() {
// Luz vermelha acesa
digitalWrite(redLED, HIGH);
digitalWrite(yellowLED, LOW);
digitalWrite(greenLED, LOW);
delay(5000);
// Luz verde acesa
digitalWrite(redLED, LOW);
digitalWrite(yellowLED, LOW);
digitalWrite(greenLED, HIGH);
delay(5000);
// Luz amarela acesa
digitalWrite(redLED, LOW);
digitalWrite(yellowLED, HIGH);
digitalWrite(greenLED, LOW);
delay(2000);
}
Explicando o Código
Vamos analisar o que cada parte deste código está fazendo:
- No topo, declaramos três variáveis (redLED, yellowLED, greenLED) e atribuímos a elas os números dos pinos que usamos na nossa fiação. Isso torna o código mais fácil de ler e alterar posteriormente, pois não teremos que lembrar os números dos PINOS ao longo do programa.
- A função setup() é executada apenas uma vez quando o Arduino é ligado ou reiniciado. Dentro dela, informamos ao Arduino que cada um desses três pinos será utilizado como SAÍDA (OUTPUT), o que significa que o Arduino enviará energia para fora desses pinos em vez de ler energia chegando.
- A função loop() executa repetidamente, sem parar, enquanto o Arduino estiver energizado. É aqui que o padrão real do semáforo acontece.
- digitalWrite(redLED, HIGH) liga o LED vermelho enviando 5 volts para o pino. digitalWrite(redLED, LOW) o desliga, enviando 0 volts.
- delay(5000) instrui o Arduino a esperar por 5000 milissegundos, o que equivale a 5 segundos, antes de prosseguir para a próxima linha de código. É isso que cria a temporização entre cada luz.
Como a função loop() mantém a repetição, o padrão de vermelho, depois verde, depois amarelo e, em seguida, de volta ao vermelho continuará infinitamente, assim como um semáforo real.
É possível alterar os valores de atraso para que as luzes permaneçam acesas por períodos mais curtos ou mais longos, dependendo de como você deseja que seu modelo se comporte.
Carregando o Código para o Arduino
Após ter escrito ou copiado o código para o software Arduino IDE em seu computador, siga os passos abaixo para executá-lo em sua placa:
- Conecte o Arduino ao seu computador utilizando o cabo USB.
- Abra a IDE do Arduino e cole o código em um novo sketch.
- Vá ao menu Ferramentas e selecione o tipo de placa correto, que deve ser Arduino Uno.
- Adicionalmente, no menu Ferramentas, selecione a porta COM correta à qual seu Arduino está conectado.
- Clique no botão de upload, que se parece com uma seta apontando para a direita.
- Aguarde a IDE exibir “Done uploading” na parte inferior da tela.
Assim que o upload for concluído, seus LEDs devem imediatamente começar a seguir o padrão de semáforo que definimos no código.
Testando e Observando o Resultado
Após o upload do código, você deverá ver o LED vermelho acender primeiro e permanecer aceso por 5 segundos. Em seguida, ele se apagará e o LED verde acenderá por mais 5 segundos. Após isso, o LED verde se apagará e o LED amarelo acenderá por 2 segundos, avisando que o ciclo está prestes a recomeçar. Então, todo o padrão se repetirá desde o início com a luz vermelha novamente.
Se você testar esta configuração em um ambiente mais escuro, o brilho dos LEDs se torna muito mais visível e proporciona um belo efeito semelhante ao de semáforos reais brilhando à noite. A imagem abaixo mostra os LEDs brilhando em um ambiente com pouca luz, o que realmente destaca como as cores se destacam quando a luz ambiente é reduzida.
Esse tipo de teste também é útil para confirmar que o seu circuito está funcionando corretamente. Se algum dos LEDs não acender, geralmente significa um dos seguintes problemas:
- O LED pode ter sido inserido invertido, uma vez que LEDs só funcionam em uma direção.
- Um fio pode não estar firmemente conectado à protoboard ou ao pino do Arduino
- O valor da resistência pode ser muito alto, atenuando o LED a ponto de não ser perceptível.
- O PIN no código não corresponde ao PIN utilizado na fiação. Revisar esta lista de verificação geralmente resolve a maioria dos problemas iniciantes de fiação.
Melhoria e Expansão do Projeto
Uma vez que seu semáforo básico esteja funcionando, existem muitas maneiras de expandir este projeto para torná-lo mais avançado e realista:
- Adicione uma sinalização de pedestres utilizando mais dois LEDs (vermelho para parar, verde para andar), que funcionará de forma oposta ao semáforo principal.
- Adicione um botão de acionamento para que pedestres possam solicitar a mudança do sinal, semelhante aos botões de travessia reais.
- Utilize uma tela LCD para exibir um cronômetro regressivo mostrando quantos segundos restam antes de a luz mudar.
- Controle múltiplos semáforos em um cruzamento, onde uma via deve estar vermelha enquanto a outra está verde, e eles mudam juntos em sincronia.
- Adicionar um buzzer que soa durante a fase de luz amarela como um sinal de aviso adicional.
Esses aprimoramentos não são muito difíceis, uma vez que se compreende a versão básica, e são uma ótima maneira de continuar aprendendo novas habilidades com o Arduino, como a leitura de entradas de botões, o uso de bibliotecas adicionais e o gerenciamento de múltiplos componentes trabalhando juntos ao mesmo tempo.
Considerações Finais
O projeto de semáforo baseado no Arduino Uno é uma das melhores maneiras para iniciantes se familiarizarem com eletrônica e programação ao mesmo tempo. Ele utiliza componentes simples e acessíveis, e a fiação é suficientemente fácil de completar em menos de trinta minutos. Ao mesmo tempo, os conceitos subjacentes, como controle de saída digital e temporização com atrasos, são utilizados em inúmeros outros projetos de eletrônica, desde sistemas de automação residencial até robótica.
Perguntas Frequentes
A razão principal é que cada camada adicionada torna o processo de fabricação mais difícil de controlar. Mais camadas significam mais chances de defeitos nas camadas internas, problemas de alinhamento, falhas de laminação e refugo.
As ilhas BGA são pequenas e densamente espaçadas, de modo que pequenos erros de fabricação podem facilmente se tornar problemas de montagem.
Sam K atua em sistemas eletrônicos embarcados, com foco em projeto de hardware, desenvolvimento de PCB, programação de firmware e integração de sistemas. Ele também apoia a otimização de desempenho e auxilia na transformação de ideias de produtos eletrônicos em soluções confiáveis e funcionais no mundo real.
