Traffic Light with Treadmill and Sensor

This is a traffic light with a treadmill and a sensor that detects if someone still crossing the road.

Jun 9, 2018

•

1875 views

•

0 respects

Components and supplies

Jumper wires (generic)

Ultrasonic Sensor - HC-SR04 (Generic)

Arduino Nano R3

Pushbutton switch 12mm

LED (generic)

Resistor 1k ohm

Project description

Code

Untitled file

arduino

1int carro_vermelho_pin = 12;   //semaforo vermelho
2int carro_amarelo_pin  = 11;    //semaforo amanrelo
3int carro_verde_pin = 10;       // semaforo verde
4int  passadeira_vermelho_pin = 8;
5int passadeira_verde_pin = 7;
6int botao = 9;            // pin do botao
7int cross_time = 0;   //tempo para os peoes atravessarem
8int  tempo_1s = 0;
9const int pin_echo = 2;
10const int pin_trig = 5;
11volatile  int techo;
12int estimulo_ss;
13int  duracao2;
14unsigned long ttrig;
15volatile  int leitura;
16int cm2;
17long duration;
18int tempo, cm;
19
20static int maquina_semaforo_state  = 1; // estado inicial da maquina do semaforo
21static int maquina_sensor_state  = 1; // estado inicial da maquina do sensor
22
23void setup() {
24  attachInterrupt(0,  pin_ISR, CHANGE);
25  pinMode(pin_trig, OUTPUT);
26  pinMode(pin_echo, INPUT);
27  pinMode(carro_vermelho_pin, OUTPUT);
28  pinMode(carro_amarelo_pin, OUTPUT);
29  pinMode(carro_verde_pin, OUTPUT);
30  pinMode(passadeira_vermelho_pin, OUTPUT);
31  pinMode(passadeira_verde_pin, OUTPUT);
32  pinMode(botao, INPUT);    // botao
33  /// desliga todos os LEDS ///
34  digitalWrite(carro_vermelho_pin, LOW);
35  digitalWrite(carro_amarelo_pin, LOW);
36  digitalWrite(carro_verde_pin, LOW);
37  digitalWrite(passadeira_vermelho_pin, LOW);
38  digitalWrite(passadeira_verde_pin,  LOW);
39  Serial.begin(9600);
40
41}
42
43void loop() {
44  int cross_time_time  = 10000;
45  int distancia_seguranca = 20;
46  int distancia_ninguem = 2;
47  int time_delay = 2000;
48  int estimulo_1;
49  int estimulo_cross;
50  int  state_botao = digitalRead(botao);       // le o valor 0 ou 1 do botao
51  estimulo_ss  = 1;
52
53
54        Serial.print(cm2 - 7); //calibration constant 7cm
55        Serial.print("cm2");
56        Serial.println();
57
58  if (millis() - cross_time > cross_time_time &&  cross_time != 0 && ((cm2-7) > distancia_seguranca ||(cm2-7) < distancia_ninguem))  {  // verifica se o tempo atual - o cross time foi maior que 10seg
59    estimulo_1  = 0; estimulo_cross = 1;          // verifica que nao esta nunquem na passadeira  e que o tempo passou
60    Serial.println("Cross");
61//    while(1);
62  }  else {
63    if (millis() - tempo_1s > time_delay && tempo_1s != 0) {    // se  o tempo do dalay passou
64      estimulo_1 = 1; estimulo_cross = 0;
65      //  maquina_semaforo(estimulo_1, estimulo_cross, state_botao);
66      Serial.println("1s");
67    } else {
68      estimulo_1 = 0; estimulo_cross = 0;   // reinicio os estimos  do delay e da passadeira
69      // maquina_semaforo(estimulo_1, estimulo_cross,  state_botao);
70      Serial.println("nada");
71    }
72
73  }
74
75  maquina_semaforo(estimulo_1,  estimulo_cross, state_botao);        // passa prara o estado a seguir
76  maquina_sensor();
77}
78
79
80
81
82
83
84
85void  maquina_sensor()
86{
87  maquina_sensor_next_state(estimulo_ss);
88  maquina_sensor_outputs();
89}
90
91
92void  maquina_sensor_next_state(int estimulo_ss)
93{
94  switch (maquina_sensor_state)
95  {
96    case 1:
97      {
98        if (estimulo_ss = 1)
99        {
100          maquina_sensor_state  = 2;
101        }
102        break;
103      }
104    case 2:
105      {
106        maquina_sensor_state  = 3;
107        break;
108      }
109    case 3:
110      {
111        if (leitura  == 1) {
112          maquina_sensor_state = 1;
113        }
114        break;
115      }
116  }
117}
118
119void maquina_sensor_outputs()
120{
121  switch (maquina_sensor_state)
122  {
123    case 1:
124      {
125        leitura = 0;
126        break;
127      }
128    case 2:
129      {
130        digitalWrite(pin_trig, LOW);
131        delayMicroseconds(2);
132        digitalWrite(pin_trig, HIGH);
133        delayMicroseconds(5);
134        digitalWrite(pin_trig,  LOW);
135         ttrig = micros();
136        //leitura = digitalRead(pin_echo);
137        break;
138      }
139    case 3:
140      {
141        Serial.print(leitura);
142        Serial.print("leitura");
143        Serial.println();
144        duracao2  = techo - ttrig;
145        cm2 = microsecondsToCentimeters(duracao2);
146//        Serial.print(cm2  - 7); //calibration constant 7cm
147//        Serial.print("cm2");
148//        Serial.println();
149        break;
150      }
151  }
152}
153
154void maquina_semaforo_outputs(int state_botao)                                  // outputs                     int do botao 
155{
156  
157  switch(maquina_semaforo_state)
158  {
159    case 1:
160    {
161      if(state_botao==HIGH)
162      {
163        
164        digitalWrite(12, LOW);   //semafero Verme
165        digitalWrite(carro_amarelo_pin,  LOW);
166        digitalWrite(carro_verde_pin, HIGH);
167        digitalWrite(passadeira_vermelho_pin,  HIGH);     //pass vermelho
168        digitalWrite(passadeira_verde_pin, LOW);
169      }
170      tempo_1s = 0;
171      break;
172    }
173
174    case 2:
175    {
176      digitalWrite(12, LOW);
177      digitalWrite(carro_amarelo_pin, HIGH);
178      digitalWrite(carro_verde_pin, LOW);
179      tempo_1s = millis();                             //  registar o tempo atual 
180      break;
181    }
182
183    case 3: //delay
184    {
185      break;
186    }
187    
188    
189    case 4:
190    {
191      digitalWrite(12,  HIGH);
192      digitalWrite(carro_amarelo_pin, LOW);
193      digitalWrite(carro_verde_pin,  LOW);
194      tempo_1s = millis();
195      break;
196    }
197
198    case 5:
199    {
200      //delay
201      break;
202    }
203
204    case 6:
205    {
206      digitalWrite(passadeira_verde_pin, HIGH);
207      digitalWrite(passadeira_vermelho_pin,  LOW);
208      cross_time = millis();
209      tempo_1s = 0;
210      break;
211    }
212
213    case 7:
214    {
215      //delay cross time
216      break;
217    }
218
219    case 8:
220    {
221      digitalWrite(passadeira_verde_pin, LOW);
222      digitalWrite(passadeira_vermelho_pin, HIGH);
223      tempo_1s = millis();
224      //cross_time = 0;
225      break;
226    }
227
228    case 9:
229    {
230      //delay
231      break;
232    }
233//    Serial.print(maquina_semaforo_state);
234//    Serial.print("<-maquina_semaforo_state");
235//    Serial.println();
236  }
237}
238
239void  maquina_semaforo(int estimulo_1, int estimulo_cross, int state_botao){
240
241           //  verifica se o tempo atual - o cross time foi maior que 10seg
242      maquina_semaforo_next_state(estimulo_1,  estimulo_cross, state_botao);        // passa prara o estado a seguir 
243      maquina_semaforo_outputs(state_botao);              
244
245
246}
247
248void maquina_semaforo_next_state(int estimulo_1,  int estimulo_cross, int state_botao){                                  // estimulo  e o valor do tempo se passou ou nao a 0 ou 1
249  
250  switch(maquina_semaforo_state)                                                            // maquina de delays  so faz os delays mais nada
251  {
252    case 1:
253    {
254      if(state_botao==LOW)
255        {
256         maquina_semaforo_state=2;
257        }
258      break;
259    }
260
261    case 2:
262    {
263      maquina_semaforo_state=3;
264      break;
265    }
266
267    case 3:
268    {
269      if(estimulo_1 == 1){                   //  vindo de cima
270        maquina_semaforo_state=4;
271      }
272      break;
273    }
274    
275    
276    case 4:
277    {
278      maquina_semaforo_state=5;
279      break;
280    }
281
282    case 5:
283    {
284      if(estimulo_1 == 1){
285        maquina_semaforo_state=6;
286      }
287      break;
288    }
289
290    case  6:
291    {
292      maquina_semaforo_state=7;
293      break;
294    }
295
296    case 7:
297    {
298      if(estimulo_cross == 1 ){
299        maquina_semaforo_state=8;
300      }
301      break;
302    }
303
304    case 8:
305    {
306      maquina_semaforo_state=9;
307      break;
308    }
309
310    case 9:
311    {
312      if(estimulo_1 == 1){
313        maquina_semaforo_state=1;
314      }
315      maquina_semaforo_state=1;
316      break; 
317    }
318//    Serial.print(maquina_semaforo_state);
319//    Serial.print("<-maquina_semaforo_state");
320//    Serial.println();
321  }
322  Serial.println(maquina_semaforo_state);
323}
324
325
326void  pin_ISR() {
327  techo = micros();
328  leitura = 1;
329}
330
331long microsecondsToCentimeters(long  microseconds) {
332  // The speed of sound is 340 m/s or 29 microseconds per centimeter.
333  // The ping travels out and back, so to find the distance of the object we
334  // take half of the distance travelled.
335  return microseconds / 29 / 2;
336}

int carro_vermelho_pin = 12;   //semaforo vermelho
int carro_amarelo_pin  = 11;    //semaforo amanrelo
int carro_verde_pin = 10;       // semaforo verde
int  passadeira_vermelho_pin = 8;
int passadeira_verde_pin = 7;
int botao = 9;            // pin do botao
int cross_time = 0;   //tempo para os peoes atravessarem
int  tempo_1s = 0;
const int pin_echo = 2;
const int pin_trig = 5;
volatile  int techo;
int estimulo_ss;
int  duracao2;
unsigned long ttrig;
volatile  int leitura;
int cm2;
long duration;
int tempo, cm;

static int maquina_semaforo_state  = 1; // estado inicial da maquina do semaforo
static int maquina_sensor_state  = 1; // estado inicial da maquina do sensor

void setup() {
  attachInterrupt(0,  pin_ISR, CHANGE);
  pinMode(pin_trig, OUTPUT);
  pinMode(pin_echo, INPUT);
  pinMode(carro_vermelho_pin, OUTPUT);
  pinMode(carro_amarelo_pin, OUTPUT);
  pinMode(carro_verde_pin, OUTPUT);
  pinMode(passadeira_vermelho_pin, OUTPUT);
  pinMode(passadeira_verde_pin, OUTPUT);
  pinMode(botao, INPUT);    // botao
  /// desliga todos os LEDS ///
  digitalWrite(carro_vermelho_pin, LOW);
  digitalWrite(carro_amarelo_pin, LOW);
  digitalWrite(carro_verde_pin, LOW);
  digitalWrite(passadeira_vermelho_pin, LOW);
  digitalWrite(passadeira_verde_pin,  LOW);
  Serial.begin(9600);

}

void loop() {
  int cross_time_time  = 10000;
  int distancia_seguranca = 20;
  int distancia_ninguem = 2;
  int time_delay = 2000;
  int estimulo_1;
  int estimulo_cross;
  int  state_botao = digitalRead(botao);       // le o valor 0 ou 1 do botao
  estimulo_ss  = 1;


        Serial.print(cm2 - 7); //calibration constant 7cm
        Serial.print("cm2");
        Serial.println();

  if (millis() - cross_time > cross_time_time &&  cross_time != 0 && ((cm2-7) > distancia_seguranca ||(cm2-7) < distancia_ninguem))  {  // verifica se o tempo atual - o cross time foi maior que 10seg
    estimulo_1  = 0; estimulo_cross = 1;          // verifica que nao esta nunquem na passadeira  e que o tempo passou
    Serial.println("Cross");
//    while(1);
  }  else {
    if (millis() - tempo_1s > time_delay && tempo_1s != 0) {    // se  o tempo do dalay passou
      estimulo_1 = 1; estimulo_cross = 0;
      //  maquina_semaforo(estimulo_1, estimulo_cross, state_botao);
      Serial.println("1s");
    } else {
      estimulo_1 = 0; estimulo_cross = 0;   // reinicio os estimos  do delay e da passadeira
      // maquina_semaforo(estimulo_1, estimulo_cross,  state_botao);
      Serial.println("nada");
    }

  }

  maquina_semaforo(estimulo_1,  estimulo_cross, state_botao);        // passa prara o estado a seguir
  maquina_sensor();
}







void  maquina_sensor()
{
  maquina_sensor_next_state(estimulo_ss);
  maquina_sensor_outputs();
}


void  maquina_sensor_next_state(int estimulo_ss)
{
  switch (maquina_sensor_state)
  {
    case 1:
      {
        if (estimulo_ss = 1)
        {
          maquina_sensor_state  = 2;
        }
        break;
      }
    case 2:
      {
        maquina_sensor_state  = 3;
        break;
      }
    case 3:
      {
        if (leitura  == 1) {
          maquina_sensor_state = 1;
        }
        break;
      }
  }
}

void maquina_sensor_outputs()
{
  switch (maquina_sensor_state)
  {
    case 1:
      {
        leitura = 0;
        break;
      }
    case 2:
      {
        digitalWrite(pin_trig, LOW);
        delayMicroseconds(2);
        digitalWrite(pin_trig, HIGH);
        delayMicroseconds(5);
        digitalWrite(pin_trig,  LOW);
         ttrig = micros();
        //leitura = digitalRead(pin_echo);
        break;
      }
    case 3:
      {
        Serial.print(leitura);
        Serial.print("leitura");
        Serial.println();
        duracao2  = techo - ttrig;
        cm2 = microsecondsToCentimeters(duracao2);
//        Serial.print(cm2  - 7); //calibration constant 7cm
//        Serial.print("cm2");
//        Serial.println();
        break;
      }
  }
}

void maquina_semaforo_outputs(int state_botao)                                  // outputs                     int do botao 
{
  
  switch(maquina_semaforo_state)
  {
    case 1:
    {
      if(state_botao==HIGH)
      {
        
        digitalWrite(12, LOW);   //semafero Verme
        digitalWrite(carro_amarelo_pin,  LOW);
        digitalWrite(carro_verde_pin, HIGH);
        digitalWrite(passadeira_vermelho_pin,  HIGH);     //pass vermelho
        digitalWrite(passadeira_verde_pin, LOW);
      }
      tempo_1s = 0;
      break;
    }

    case 2:
    {
      digitalWrite(12, LOW);
      digitalWrite(carro_amarelo_pin, HIGH);
      digitalWrite(carro_verde_pin, LOW);
      tempo_1s = millis();                             //  registar o tempo atual 
      break;
    }

    case 3: //delay
    {
      break;
    }
    
    
    case 4:
    {
      digitalWrite(12,  HIGH);
      digitalWrite(carro_amarelo_pin, LOW);
      digitalWrite(carro_verde_pin,  LOW);
      tempo_1s = millis();
      break;
    }

    case 5:
    {
      //delay
      break;
    }

    case 6:
    {
      digitalWrite(passadeira_verde_pin, HIGH);
      digitalWrite(passadeira_vermelho_pin,  LOW);
      cross_time = millis();
      tempo_1s = 0;
      break;
    }

    case 7:
    {
      //delay cross time
      break;
    }

    case 8:
    {
      digitalWrite(passadeira_verde_pin, LOW);
      digitalWrite(passadeira_vermelho_pin, HIGH);
      tempo_1s = millis();
      //cross_time = 0;
      break;
    }

    case 9:
    {
      //delay
      break;
    }
//    Serial.print(maquina_semaforo_state);
//    Serial.print("<-maquina_semaforo_state");
//    Serial.println();
  }
}

void  maquina_semaforo(int estimulo_1, int estimulo_cross, int state_botao){

           //  verifica se o tempo atual - o cross time foi maior que 10seg
      maquina_semaforo_next_state(estimulo_1,  estimulo_cross, state_botao);        // passa prara o estado a seguir 
      maquina_semaforo_outputs(state_botao);              


}

void maquina_semaforo_next_state(int estimulo_1,  int estimulo_cross, int state_botao){                                  // estimulo  e o valor do tempo se passou ou nao a 0 ou 1
  
  switch(maquina_semaforo_state)                                                            // maquina de delays  so faz os delays mais nada
  {
    case 1:
    {
      if(state_botao==LOW)
        {
         maquina_semaforo_state=2;
        }
      break;
    }

    case 2:
    {
      maquina_semaforo_state=3;
      break;
    }

    case 3:
    {
      if(estimulo_1 == 1){                   //  vindo de cima
        maquina_semaforo_state=4;
      }
      break;
    }
    
    
    case 4:
    {
      maquina_semaforo_state=5;
      break;
    }

    case 5:
    {
      if(estimulo_1 == 1){
        maquina_semaforo_state=6;
      }
      break;
    }

    case  6:
    {
      maquina_semaforo_state=7;
      break;
    }

    case 7:
    {
      if(estimulo_cross == 1 ){
        maquina_semaforo_state=8;
      }
      break;
    }

    case 8:
    {
      maquina_semaforo_state=9;
      break;
    }

    case 9:
    {
      if(estimulo_1 == 1){
        maquina_semaforo_state=1;
      }
      maquina_semaforo_state=1;
      break; 
    }
//    Serial.print(maquina_semaforo_state);
//    Serial.print("<-maquina_semaforo_state");
//    Serial.println();
  }
  Serial.println(maquina_semaforo_state);
}


void  pin_ISR() {
  techo = micros();
  leitura = 1;
}

long microsecondsToCentimeters(long  microseconds) {
  // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  // The ping travels out and back, so to find the distance of the object we
  // take half of the distance travelled.
  return microseconds / 29 / 2;
}

Downloadable files

traffic light with a treadmill and a sensor

Comments

Only logged in users can leave comments

David_Farinha

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content