fbpx

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.

Figura 1: Circuito elétrico para o projeto Semáforo Interativo – Carros e Pedestres.

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

Esse site utiliza o Akismet para reduzir spam. Aprenda como seus dados de comentários são processados.