Início / Projetos Arduino / Projetos Squids / Básico / Projeto 06 - Simulação Semáforo com Arduino

---

Projeto 06 - Simulação Semáforo com Arduino

Angelo Luis Ferreira | 01/06/2020 Acessos: 26.948

Objetivo

Criar um simulador de farol de pedestre em conjunto com um semáforo para automóveis. O sistema de luzes é alterado (vermelho) para que os carros parem e os pedestres possam atravessar a rua em segurança (verde). Para iniciar o semáforo é preciso pressionar o botão uma vez.

Aplicação

Para fins didáticos. Pode ser utilizado também em maquetes para ferrovia em miniatura ou em mini cidades de brinquedo.

Componentes necessários

Referência	Componente	Quantidade	Imagem	Observação
Protoboard	Protoboard 400 pontos	1		No mínimo utilizar protoboard com 400 pontos
Jumpers	Kit cabos ligação macho / macho	1
Resistor	Resistor	5		5 Resistor 200Ω Se precisar usar outros valores, calcule o resistor apropriado para o led utilizado - Calcular Resistor.
Led 5mm	LED 5mm	5		2 leds vermelhos, 2 leds verdes e um led amarelo alto brilho ou difuso Você poderá utilizar também LEDs de 3 mm na cor que desejar.
Push Button	Push button 6X6X5mm	1
Arduino UNO R3	Arduino UNO	1		Você poderá utilizar uma placa Arduino UNO original ou similar

Montagem do Circuito

Conecte os componentes no Protoboard como mostra a figura abaixo. Verifique cuidadosamente os cabos de ligação antes de ligar seu Arduino. Lembre-se que o Arduino deve estar totalmente desconectado da força enquanto você monta o circuito.

Atenção

1) Lembre-se que o LED tem polaridade: O terminal maior tem polaridade positiva e o lado do chanfro tem polaridade negativa.

1.1. Portanto, faça a conexão do Arduino no terminal positivo (anodo) e o GND no terminal negativo (catodo) do led.

1.2. Para evitar danos ao led é necessário a inclusão de um resistor no circuito. Como o resistor é um limitador da corrente elétrica, ele poderá estar conectado no anodo (terminal maior) ou no catodo (terminal menor) do led, tanto faz.

2. Determinamos o valor do resistor através da tabela prática: Tabela prática de utilização de leds 3mm e 5mm. Entretanto, o mais correto é sempre verificar o datasheet do fabricante do LED para você ter os exatos valores de tensão e corrente do mesmo - leia Como calcular o resistor adequado para o led e Leds ligados em série e em paralelo.

Obs.: Resistores iguais ou superiores a 250 Ω poderão ser utilizados em LEDs de todas as cores para um circuito com tensão igual ou inferior a 5V.

Valores utilizados para nossos projetos: LEDs difusos ou de alto brilho: Vermelho, Laranja e Amarelo: 150 Ω | Led Verde e Azul: 100 Ω

3. Monte os botões (push button) sem resistor, pois habilitaremos o pull-up interno do arduino através da programação. Desta forma, quando o botão estiver pressionado, o Arduino retornará "LOW" ou "0". Assista o vídeo Arduino: Botão e Resistor de Pull Up Interno e veja o projeto Projeto 02b - Led apaga com push button pressionado (pull-up interno do Arduino).

Obs.: Os resistores pull-up e pull-down garantem um nível lógico estável quando por exemplo uma tecla não está pressionada. Geralmente utiliza-se um resistor de 10KΩ para esse propósito. A seguir é exibida a ligação desses resistores no circuito para leitura de tecla do botão:

Atenção: Observe que neste projeto não utilizaremos o resistor de 10K pois vamos habilitar o resitor pull-up interno do Arduino através da programação. Leia mais em Como usar push button com Arduino (programação)

4. A montagem do nosso projeto foi realizada em um protoboard com linhas de alimentação não contínuas, onde acrescentamos jampers para a ligação. Verifique se o seu protoboard possui linhas de alimentação contínuas ou separadas - saiba mais em protoboard

Código do projeto (Sketch)

Faça o dowload e abra o arquivo projeto06.ino no IDE do Arduino: DOWNLOAD - projeto06.ino

Ou se preferir, copie e cole o código abaixo no IDE do Arduino:

/*******************************************************************************
*
*    Projeto 6: Semáforo Completo
*    Data: 15/05/2020
*                       http://squids.com.br/arduino                
*
*******************************************************************************/
// Define pinos utilizados
int autoVermelho = 2;
int autoAmarelo = 3;
int autoVerde = 4;
int pinBot = 8;
int pedVermelho = 11;
int pedVerde = 12;

// Define variaveis
int ini = 0;

//******************************************************************************
 
void setup() {
  // Define os pinos de saidas
  pinMode(autoVermelho, OUTPUT);
  pinMode(autoAmarelo, OUTPUT);
  pinMode(autoVerde, OUTPUT);
  pinMode(pedVermelho, OUTPUT);
  pinMode(pedVerde, OUTPUT);
  // Define o pino de entrada
  pinMode(pinBot, INPUT_PULLUP);
}

//******************************************************************************
 
void loop() {
  // faz a leitura do botão - inicia o semáforo
  if (digitalRead(pinBot) == LOW) {
    while (digitalRead(pinBot) == LOW) {} // espera soltar o botão
    delay(10);
    // Posição inical após presionar botão. Somente o verde dos carros e o vermelho dos pedestres acesos
    digitalWrite(autoVerde, HIGH); 
    digitalWrite(autoVerde, LOW);
    digitalWrite(autoVerde, LOW);
    digitalWrite(pedVerde, LOW);
    digitalWrite(pedVermelho, HIGH);
    ini = 1;        
  }
  // funcionamento do semáforo após pressionar o botão
  if (ini == 1) {
  // Acende o verde dos carros e o vermelho dos pedestres
    digitalWrite(autoVerde, HIGH); 
    digitalWrite(pedVermelho, HIGH);  
    delay(5000); // Aguarda 5 segundos
    digitalWrite(autoVerde, LOW);
    // apaga o verde dos carros e acende o amarelo
    digitalWrite(autoAmarelo, HIGH);
    delay(3000); // aguarda mais 3 segundos
    // apaga o amarelo dos carros e acende o vermelho
    digitalWrite(autoAmarelo, LOW); 
    digitalWrite(autoVermelho, HIGH);
    // apaga o vermelho dos pedestres e acende o verde
    digitalWrite(pedVermelho, LOW); 
    digitalWrite(pedVerde, HIGH);
    delay(5000);  // aguarda mais 5 segundos
    digitalWrite(pedVerde, LOW);
    for(int x = 0; x<5; x++) { // Pisca 5x o vermelho dos pedestres
      digitalWrite(pedVermelho, HIGH);
      delay(250);
      digitalWrite(pedVermelho, LOW);
      delay(250);
    }
    digitalWrite(autoVermelho, LOW);
  }  
}

Depois, faça a verificação e o upload para o microcontrolador.

Vídeo

Como o projeto deve funcionar

1. Pressione o botão para iniciar o nosso semáforo.

2. O programa irá iniciar com o semáforo no verde, para para permitir que os carros passem, e a luz para pedestres no vermelho.

3. O semáforo para carros vai do verde para o amarelo e depois para o vermelho, e então o semáforo para pedestres vai para o verde.

4. Depois de um intervalo de tempo, a luz verde para pedestre deverá piscar para avisar aos pedestres que devem atravessar rapidamente antes que o semáforo feche.

5. Então, a luz vermelha do semáforo do pedestre ascende e a luz dos carros vai do vermelho para o verde, permitindo novamente o fluxo do tráfego.

Explicando o código do projeto

1. Primeiro declaramos as constantes e as variáveis do projeto.

1.1. Observe que utilizamos a variável tipo "int". Veja na tabela abaixo as diferenças nos tipos de constantes e variáveis:

1.2. As variáveis tipo int autoVermelho, autoAmarelo e AutoVerde  definem as portas digitais 2, 3 e 4 respectivamente. Referem-se aos leds do semáforo de automóveis.

1.3. A variável tipo int pinBot define a porta digital 8 onde está conectado o botão (push button) utilizado para iniciar o funcionamento do semáforo.

1.4. As variáveis tipo int pedVermelho e pedVerde definem as portas digitais 11 e 12. Referem-se aos leds do semáforo de pedestres.

1.5. A variável tipo int ini recebe o valor zero.

2. Através da strutura void setup(), definimos:

2.1. Define autoVermelho, autoAmarelo, autoVerde, pedVermelho e pedVerde como saídas do controlador Arduino (OUTPUT) referentes aos pinos 2, 3, 4 ,11 e 12.

2.1. Define pinBot como entrada do controlador Arduino (INPUT_PULLUP) referente ao pino 8 do microcontrolador.

2.2.1. INPUT_PULLUP habilita o resistor pull-up interno do Arduino, eliminando a necessidade de colocarmos um resistor de 10K ligado ao VCC (5V).

3. Através da estrutura void loop(), obtemos:

3.1. Primeiro fazemos a leituras dos botão através função digitalRead(pinBot), para verificar se ele está pressionado (0 ou LOW) ou se está liberado (1 ou HIGH).

3.1.1. A função digitalRead() lê o valor de um pino digital especificado, que pode ser HIGH ou LOW. Leia Referência Arduino - digitalRead().

3.1.2. Observe que configuramos o botão como PULLUP_INTERNO e desta forma o botão enviará um sinal LOW quando pressionado. Leia Como usar push button com Arduino (programação) .

3.2. Através da estrutura de  controle while (digitalRead ==LOW) {}, o programa aguarda que o botão seja liberado, ou seja, retorne HIGH. Leia Referência Arduino - while().

3.3. Forçamos uma pausa no programa de 10 milissegundos através da função delay(). Leia Referência Arduino - delay().

3.3.1. Isto é necessário para eliminarmos possíveis erros do botão em função da sua característica mecânica. Falaremos mais sobre isso em projetos futuros.

3.4. Através da função digitalWrite() ligamos os leds 4 e 11 (autoVerde e pedVermelho) iniciando a simulação. Observe que desligamos os demais leds.

3.4.1. A função digitalWrite() Aciona um valor HIGH ou LOW em um pino digital. Este valor será de 5V para HIGH e 0V para LOW. Leia Referência Arduino - digitalWrite().

3.5. Alteramos o valor da variável ini, passando de 0 para 1. Isto significa que a simulação poderá ser iniciada.

3.6. Utilizando a condiciona if (ini ==1) iniciamos a simulação do semáforo.

3.6.1. Observe que utilizamos o operador de comparação (==) que é diferente do operador de atribuição (=). Leia Referência Arduino - Condicional IF.

Simulação de um semáforo completo - automóveis e pedestres:

3.7. Acendemos o led verde dos automóveis (autoVerde - pino 4) e o vermelho dos pedestres (pedVermelho - pino 11) usando a função digitalWrite().

3.8. Através da função delay(), o programa espera 5 segundos (5000 ms).

3.9. Após a pausa, desligamos o led verde dos automóveis (autoVerde - pino 4) e acendemos o led amarelo dos automóveis (autoAmarelo - pino3).

3.10. Criamos mais uma pausa de 3 segundos no amarelo. Para isso utilizamos novamente a função delay().

3.11. Após os 3 segundos de pausa, apagamos o led amarelo (autoAmarelo - pino3) e acendemos o led vermelho (autoVermelho - pino 2) dos automóveis. Ao mesmo tempo, apagamos o led vermelho dos pedestres (pedVermelho - pino 11) e ligamos o led verde (pedVerde - pino 12).

3.12. Criamos mais uma pausa de 5 segundos e apagamos o led verde dos pedestres (pedVerde - pino 12).

3.13. Após apagarmos o led verde dos pedestres criamos um loop para piscar o led 5 vezes com o objetivo de chamar atenção:

3.13.1. Para piscar o led usamos o expressão for (int x = 0; x <5; x++):

3.13.1.1 Declaramos a variável local x como int. Incrementamos a variável em +1, usando a expressão x++. Obs.: O incremento será utilizado após o primeiro bloco de códigos ser totalmente utilizado. Desta forma, o loop irá de x=0 até x<5, ou seja, x=0, x=1 e x=3, realizando cinco repetições:

3.13.1.1.1. Através da função digitalWrite(led, HIGH) informamos o Arduino para acender o led.

3.13.1.1.2. Através da função delay(250) pausamos o programa em 250 milissegundos.

3.13.1.1.3. Através da função digitalWrite(led, HIGH) informamos o Arduino para acender o led.

3.13.1.1.3. Através da função delay(250) pausamos o programa em 250 milissegundos.

3.14. Finalmente apagamos o led vermelho para os pedestres (pedVermelho - pino 11), reiniciando a simulação.

Comentários