Semáforo interativo para carros e pedestres
Olá pessoal!
No tutorial de hoje vamos desenvolver um semáforo de trânsito interativo para carros e pedestres controlado pela NODEMCU ESP8266.
Para isso, criaremos dois semáforos, um com três LEDs que representará a sinalização para os carros e um com dois LEDS e um botão para simular o semáforo dos pedestres.
Este projeto deve funcionar da seguinte maneira: o semáforo de carros estará sempre aberto (sinal verde) e apenas será fechado (sinal vermelho) quando o botão do pedestre for acionado.
Neste projeto, faremos uso das estruturas de controle de fluxo While e for. No While todas as instruções contidas em seu laço serão repetidas continuamente, e infinitamente, até que a sua condicional se torne falsa. Por sua vez, a estrutura for permite que certo trecho do código seja executado um determinado número de vezes.
MATERIAIS NECESSÁRIOS
1 x NODEMCU ESP8266;
1 x Cabo micro USB;
1 x Protoboard;
1 x Resistor de 220 Ω;
2 x LEDs difuso de 5 mm na cor verde;
2 x LEDs difuso de 5 mm na cor vermelha;
1 x LED difuso de 5 mm na cor amarela;
1 x Resistor de 10 kΩ;
1 x Botão tipo push button;
Fios de jumper.
ESQUEMÁTICO DE LIGAÇÃO DOS COMPONENTES
Verifique se a sua placa NODEMCU ESP8266 encontra-se descontada do seu computador. Em seguida, monte atentamente o circuito da Figura 1.
Ao montar seu circuito na protoboard preste atenção nos seguintes pontos:
• Atente-se a polaridade dos LEDs. Lembre-se que o terminal mais longo do LED é o ânodo (positivo) e deve ser conectado na alimentação positiva. Por sua vez, o terminal mais curto do LED (cátodo) deve ser conectado ao GND;
• O LED vermelho do semáforo de carros encontra-se conectado ao pino digital D1 (GPIO5), o LED amarelo do semáforo de carros deve ser conectado ao pino digital D2 (GPIO4) e o LED verde deve ser conectado ao pino digital D2 (GPIO0);
• O botão deve ser montado com dois terminais abaixo da cavidade central da protoboard e os outros dois acima. Vamos conectar o push button com um resistor de 10 kΩ pull-up (resistor conectado ao VCC (3,3 V)). Desta forma, quando o botão estiver pressionado a NODEMCU ESP8266 receberá nível lógico baixo (LOW) por meio do pino digital D4 (GPIO2).
• O LED vermelho do semáforo de pedestres deve ser conectado ao pino digital D5 (GPIO14) e o LED verde ao pino digital D6 (GPIO12);
Certifique-se de que todas as ligações estão corretas e, então, conecte sua placa NODEMCU ESP8266 ao computador para realizar a programação.
ELABORANDO O CÓDIGO
A proposta desse projeto é criar um semáforo interativo para carros e pedestres. Para melhor compreensão da lógica de programação do projeto proposto vamos aos seguintes passos:
1. Declarar as variáveis
Iniciaremos o código declarando as variáveis correspondentes aos LEDs dos semáforos de carros e pedestres. Com base no esquemático elétrico, vamos atribuir ao pino D1 à variável vermelhoCar, o pino D2 à variável amareloCar, o pino D3 à variável verdeCar, o pino D5 à variável vermelhoPed e o pino D6 à variável verdePed. Em seguida, atribuímos o pino D4 à variável buttonPin.
2. Configurar as portas de entrada e saída
Na função setup configuraremos as variáveis relacionadas aos LEDs dos semáforos como saída e, apenas, a variável buttonPin como entrada.
3. Verificar se o botão do pedestre foi pressionado
Conforme dito anteriormente, o semáforo de carros estará sempre aberto, enquanto o botão de pedestre não for pressionado. Desta forma, enquanto buttonPin estiver em nível lógico alto (não pressionado), os LED verde dos carros (verdeCar) e vermelho dos pedestres (vermelhoPed) estarão sempre ligados.
Para ler buttonPin utilizamos a instrução digitalRead(buttonPin) e faremos a verificação de seu estado usando a estrutura de controle de fluxo While. Deste modo, a instrução de verificação será while (digitalRead(buttonPin)). Dentro do laço de repetição While vamos acionar os LED verde dos carros (verdeCar) e vermelho dos pedestres (vermelhoPed).
4. Fechar o semáforo dos carros e abrir o semáforo dos pedestres
Uma vez pressionado o botão do pedestre, buttonPin terá seu estado alterado para o nível lógico baixo (LOW) e o programa sairá do laço de repetição While. Neste caso, o semáforo dos carros deve ser fechado e o sinal dos pedestres aberto.
Deste modo, iniciaremos este trecho do código incluindo um intervalo de espera de 2,5 segundos. Em seguida, vamos desativar o LED verde dos carros (verdeCar) e acionar o LED amarelo dos carros (amareloCar). Logo após, incluiremos mais um intervalo de espera de 2,5 segundos. O próximo passo é desligar o LED amarelo dos carros (amareloCar) e ligar o LED vermelho dos carros (vermelhoCar), fechando o sinal para os carros.
Após um intervalo de 2,5 segundos, vamos desligar o LED vermelho dos pedestres (vermelhoPed) e acionar o LED verde (verdePed).
5. Fechar o semáforo dos pedestres
Para sinalizar aos pedestres que o semáforo irá fechar vamos piscar o LED vermelho (vermelhoPed) cinco vezes. Para isso, utilizaremos a estrutura de controle for, que será inclusa ao código com a sintaxe: for (int i = 0; i <= 5; i++). Após o for, o primeiro parâmetro a ser incluído é a variável que será utilizada como contados. O outro parâmetro é uma condição, que deve ser satisfeita para que as instruções do laço for sejam executadas. Neste projeto, as instruções do for serão realizadas enquanto a variável i for menor ou igual que 5. Por fim, deve ser incluído o incremento.
No laço de repetição for, vamos incluir o comando para piscar o LED vermelho (vermelhoPed). Este comando terá a seguinte sintaxe digitalWrite(vermelhoPed, !(digitalRead(vermelhoPed);, que inverterá o estado de vermelhoPed a cada execução do laço.
Ao fim, vamos colocar verdePed e vermelhoCar em nível lógico baixo, desligando os LEDs correspondentes a eles. Desta forma, o Sketch deste projeto ficará da seguinte maneira:
/*
---- SEMÁFORO DE CARROS E PEDESTRES ---
=================================================
== BLOG DA ROBOTICA - www.blogdarobotica.com ==
=================================================
Autor: Carol Correia Viana
E-mail: contato@blogdarobotica.com
Facebook: facebook.com/blogdarobotica
Instagram:@blogdarobotica
YouTube: youtube.com/user/blogdarobotica
=================================================
== CASA DA ROBOTICA - www.casadarobotica.com ==
=================================================
Facebook: facebook.com/casadaroboticaoficial
Instagram:@casadarobotica
=================================================
*/
int vermelhoCar = 5; //Define vermelhoCar no pino D1 (GPIO5) - vermelho dos carros
int amareloCar = 4; //Define amareloCar no pino D2 (GPIO4) - amarelo dos carros
int verdeCar = 0; //Define verdeCar no pino D3 (GPIO0) - verde dos carros
int vermelhoPed = 14; //Define vermelhoPed no pino D5 (GPIO14) - vermelho dos pedestres
int verdePed = 12; //Define verdePed no pino D6 (GPIO12) - verde dos pedestres
int buttonPin = 2; //Define buttonPin no pino D4 (GPIO2) - botão dos pedestres
void setup() {
//Configura os pinos dos LEDs como saída e do botão como entrada
pinMode(vermelhoCar, OUTPUT);
pinMode(amareloCar, OUTPUT);
pinMode(verdeCar, OUTPUT);
pinMode(vermelhoPed, OUTPUT);
pinMode(verdePed, OUTPUT);
pinMode(buttonPin, INPUT);
}
void loop() {
while (digitalRead(buttonPin)) { //Enquanto o botão não for pressionado
digitalWrite(verdeCar, HIGH); //Liga o LED verde dos carros
digitalWrite(vermelhoPed, HIGH); //Liga o LED vermelho dos pedestres
}
//instruções que serão realizadas quando o botão for pressionado
delay(2500); //Intervalo de 2,5 segundos
digitalWrite(verdeCar, LOW); //Desliga o LED verde dos carros
digitalWrite(amareloCar, HIGH); //Liga o LED amarelo dos carros
delay(2500); //Intervalo de 2,5 segundo
digitalWrite(amareloCar, LOW); //Desliga o LED amarelo dos carros
digitalWrite(vermelhoCar, HIGH); //Liga o LED vermelho dos carros
delay(2500); //Intervalo de 2,5 segundo
digitalWrite(vermelhoPed, LOW); //Desliga o LED vermelho dos pedestres
digitalWrite(verdePed, HIGH); //Liga o LED verde dos pedestres
delay(4000); //Intervalo de 4 segundos
//Pisca LED vermelho dos Pedestres
for (int i = 0; i <= 5; i++) { //fazer 5 vezes
digitalWrite(vermelhoPed, !(digitalRead(vermelhoPed))); //Inverte o estado do LED vermelho dos pedestres
delay(500); //Intervalo de 0,5 segundo
}
delay(500); //Intervalo de 0,5 segundo
digitalWrite(verdePed, LOW); //Desliga o LED verde dos pedestres
digitalWrite(vermelhoCar, LOW); //Desliga o LED vermelho dos pedestres
}
Obrigada a todos e qualquer dúvida deixe nos comentários abaixo!
Abraços,
Carol Correia Viana
Bacharel em Engenharia Elétrica com ênfase em Eletrônica, mestra em Engenharia Industrial e especialista em Docência com ênfase em Educação Inclusiva. Atua no setor de Desenvolvimento de Produtos na Casa da Robótica. Editora chefe e articulista no Blog da Robótica. Fanática por livros, Star Wars e projetos Maker.
