sábado, 27 de enero de 2024

ALERTA TEMPRANA DE ACCIDENTES DE VEHÍCULO CON ARDUINO

 Alerta temprana de accidentes de vehículo con Arduino

Video demostración

 

Alumno: Pastor Nso Mangue
Asignatura: Innovación Docente de la Especialidad de Tecnología.
Máster: Máster Universitario en Profesor de Educación Secundaria Obligatoria y Bachillerato, Formación Profesional y Enseñanza de Idiomas
Centro: Universidad de Salamanca.
Curso: 2023/24

Descripción del proyecto

Este proyecto tiene la finalidad de demostrar a los alumnos la utilidad de los pequeños autómatas programables para el cuidado de las personas, cuando estos autómatas se integran con la telemática. También sirve para  demostrar a los alumnos que no hay que sobrecargar los autómatas con mucha lógica, sino dejarlas para lo que están hechas, que es, por una parte, recoger información con sensores y enviarla a otros sistemas con más capacidad de cálculo para la toma de decisiones; y por otra parte, recibir instrucciones de otros sistemas y aplicarlo a los actuadores.
 

ODS

Los objetivos de desarrollo sostenible relacionados con este trabajo son los siguientes:
  • Garantizar una vida sana y promover el bienestar para todos en todas las edades (ODS 3).
  • Garantizar una educación inclusiva, equitativa y de calidad y promover oportunidades de aprendizaje durante toda la vida para todos (ODS 4.
  • Construir infraestructuras resilientes, promover la industrialización sostenible y fomentar la innovación (ODS 9).
  • Lograr que las ciudades sean más inclusivas, seguras, resilientes y sostenibles ( ODS 11).
 El proyecto tiene dos partes diferenciadas, cuyos componentes se detallan en el apartado "Componentes":
  • Arduino: 
    • Un botón de encendido arranca el motor del vehículo.
    • Cada cinco segundos Arduino escanea los sensores y prepara una cadena de caracteres en formato JSON con los valores de los sensores y envía esa cadena al puerto serie.
    • Un sensor de volteo mide la posición del vehículo. Si el vehículo voltea (sensor en posición horizontal), se notifica un accidente y se apaga el motor del vehículo.
    • Un sensor de ultrasonido mide el contacto o choque, si ésto ocurre, notifica del accidente.
    • Un potenciómetro mide la velocidad del vehículo, que también se envía al panel de monitoreo.
       
  • Node-Red
    • Recoge del puerto serie la cadena en formato JSON enviada por Arduino.
    • Descompone la cadena JSON en parámetros individuales.
    • Presenta en el panel de visualización (Dashboard) los parámetros individuales que reflejan el estado del vehículo.

Alumnos para los que está dirigido

Este proyecto está dirigido a alumnos de Grado Superior de Formación Profesional; en especial a los del ciclo de Sistema Electrotécnicos y Automatizados. 

Aprendizaje Transversales

Este proyecto abarca conocimientos transversales de electrónica, domótica, electricidad y programación. Se puede impartir en asignaturas como Técnicas y procesos en instalaciones domóticas y automáticas, así como Configuración de instalaciones domóticas y automáticas. 

Componentes

Componentes Hardware:

  • Placa de Arduino ELEGOO UNO R3 
  • Protoboard
  • Botón pulsador.
  • Potenciómetro de 10 K
  • Diodo LED rojo
  • Diodo LED Verde          
  • 3 resistencias 220Ω
  • 1 sensor de ultrasonidos
  • Cables para circuito de diferentes longitudes
  • Cable puerto USB

 Componentes Software:

  • Entorno de desarrollo Arudiono
  • Librería ArduinoJson (para manipular cadenas en formato JSON).
  • Node-Red
  • Paleta Node-Red Serial (para conexión a puerto serie).
  • Paleta Node-Red Dashboard (para visualizar los parámetros del vehículo).

 Esquema

 



Código 

Código del Arduino

#include <ArduinoJson.h> //Librería para manipulacione de cadenas en formato JSON
// Variables globales para el sensor de ultrasonido
const int pinTrigger = 2;   //Pin digital 2 para el Trigger del sensor
const int pinEcho = 3;   //Pin digital 3 para el Echo del sensor

// Variables globales para el inclinometro
int tiltPin = 7;
int lectura;
int previo = LOW;
long time = 0;            // Para guardar la hora de la inversion de valor
long debounce = 50;       // Tiempo de rebote

// Variables arranque motor: botón
const int pinArranqueMotor = 8; // pin digital 8, para el botón de arranque del motor

//Variables globales del vehículo
String persona_contacto = "Pastor Nso Mangue";
String telefono_contacto = "682xxxxxx";
String email_contacto = "idu004695@usal.es";
String posicion_vehiculo = "Derecho"; //Puede ser "Derecho" o "Volteado"
String estado_vehiculo = "Normal"; //Puede ser "Normal" o "Chocado"
//String estado_motor = "OFF";
int velocidad_vehiculo = 0; // En kilometros/hora
int proximidad_choque = 0;
String longitud_coordenadas = "GSP inactivo"; // Para futuras aplicaciones
String latitud_coordenadas = "GPS inactivo"; // Para futuras aplicaciones
String vehiculo_accidentado = "NO"; // Estado general del vehículo

// Habilitar el documento JSON
JsonDocument payload;
/*Formato JSON de las variables globales del vehículo; una cadena de caracteres con formato interpretable
{"persona_contacto":"Pastor Nso Mangue",
"telefono_contacto":"682711196",
"email_contacto":"idu004695@usal.es",
"vehiculo_accidentado":"NO",
"posicion_vehiculo":"Derecho"
,"estado_vehiculo":"Chocado",
"velocidad_vehiculo":264,
"proximidad_choque":4,
"longitud_coordenadas":"GSP inactivo",
"latitud_coordenadas":"GPS inactivo"}
*/
// led de Arranque y Parada color amarillo, motor en funcionamiento
const int ledArranqueParada = 12;

// led indicador de accidente
const int ledAccidente = 13;

void setup() {

  //Inicialización sensor ultrasonido
  pinMode(pinTrigger, OUTPUT); //pin como salida
  pinMode(pinEcho, INPUT);  //pin como entrada
  digitalWrite(pinTrigger, LOW);//Inicializamos el pin con 0

  //Inicialización inclinometro
   pinMode(tiltPin, INPUT_PULLUP);

  //Botón de arranque
  pinMode(pinArranqueMotor, INPUT_PULLUP);

  //Definir los I/O de Arduino
  pinMode(ledArranqueParada , OUTPUT);  //definir pin como salida
  pinMode(ledAccidente , OUTPUT);  //definir pin como salida
  //Inicializar Puerto Serie
  Serial.begin(9600);
  //while (!Serial)
  // continue;    
}

void loop() {

  // Lectura sensor de ultrasonido
  long t; //timepo que demora en llegar el eco
  long d; //distancia en centimetros
  digitalWrite(pinTrigger, HIGH);
  delayMicroseconds(10);          //Enviamos un pulso de 10us
  digitalWrite(pinTrigger, LOW);
    t = pulseIn(pinEcho, HIGH); //obtenemos el ancho del pulso
  d = t/59;             //escalamos el tiempo a una distancia en cm
  proximidad_choque = d; //distancia del vehiculo al objeto con el que choca
  if (proximidad_choque < 10) {
    estado_vehiculo = "Chocado"; //Si hay contacto con el objeto, simular accidente y estado_vehículo = "Chocado"
    digitalWrite (ledAccidente, HIGH);
    vehiculo_accidentado = "SI";
    digitalWrite(ledArranqueParada,LOW); // Apagar el motor
    //estado_motor = "OFF";
  } else {
    estado_vehiculo = "Normal";
    digitalWrite (ledAccidente, LOW);
    vehiculo_accidentado = "NO";
  }
 
 // Lectura sensor de vuelco
 lectura = digitalRead(tiltPin);
 if (lectura != previo)  time = millis();   // Si hay cambio en la lectura
 if ((millis() - time) > debounce) {
    if (lectura == HIGH) {
      posicion_vehiculo = "Volcado"; // registrar qu el coche ha volcado
      vehiculo_accidentado = "SI";
      digitalWrite(ledArranqueParada,LOW); //Apagar el motor
      digitalWrite (ledAccidente, HIGH);
      //estado_motor = "OFF";
    } else {
      posicion_vehiculo = "Derecho"; // registrar que el coche sigue derecho
      digitalWrite (ledAccidente, LOW);
      vehiculo_accidentado = "NO";
    }
 }  
 previo = lectura ;

 // Lectura del potenciómetro de velocidad
 // leemos del pin A0 valor
  int velocidad = analogRead(A0);
  velocidad_vehiculo = map(velocidad, 0, 1023, 0, 240);velocidad; //registrar la velocidad del vehículo
  //velocidad_vehiculo = velocidad;

 // Indicar si el motor del vehículo está en funcionamiento o parado
  int estadoMotor = digitalRead (pinArranqueMotor);
  if (estadoMotor == HIGH) {
        digitalWrite(ledArranqueParada,HIGH);
  }

 
 //Comunicar el estado de las variables al panel de monitorización
  payload["persona_contacto"] = persona_contacto;
  payload["telefono_contacto"] = telefono_contacto;
  payload["email_contacto"] = email_contacto;
  payload["vehiculo_accidentado"] = vehiculo_accidentado;
  payload["posicion_vehiculo"] = posicion_vehiculo;
  payload["estado_vehiculo"] = estado_vehiculo;
  //payload["estado_motor"] = estado_motor;
  payload["velocidad_vehiculo"] = velocidad_vehiculo;
  payload["proximidad_choque"] = proximidad_choque;
  payload["longitud_coordenadas"] = longitud_coordenadas;
  payload["latitud_coordenadas"] = latitud_coordenadas;

  // Generar el documento JSON con todas las variables juntas y enviarlo al puerto serie de Arduino
  serializeJson(payload, Serial);
  Serial.println();  //acuse de envío de mensaje desde arduino por puerto serie
 
 delay(5000);  // Dormir 5 segundos y volver a escanear el estado del vehículo
}
 

Node-Red (flujos)


Posibles mejoras

Este proyecto se puede mejorar incorporando una aplicación móvil (Android o iOS), que le permita al usuario conectarse mediante Bluetooth a Arduino. Dicha aplicación se programará en pseudocódigo de Mit App Inventor 2.
A través de esta aplicación el usuario podrá configurar los parámetros de la persona de contacto, en caso de percance. 
La aplicación móvil también se encargará de alertar mediante voz o zumbido si el usuario excede de velocidad; así como notificar mediante SMS a un teléfono de contacto o incluso establecer una llamada al contacto en tiempo real.
Otras utilidad que se le puede dar a esta aplicación móvil es presentar al usuario su ubicación en el mapa y también incorporar la ubicación (latitud y longitud) en la notificaciones. 
Si se incorpora una tarjeta de memoria SD al proyecto, éste podría servir también como una especie de "caja negra" del vehículo, donde quedan registrados los parámetros como velocidad, posición, localización, estado del motor, etc.  

Aclaraciones 

En el vídeo, el autor describió la velocidad en kilómetros por segundo. En realidad, debería ser en kilómetros por hora.

miércoles, 24 de enero de 2024

Puerta de Garaje con sensor de distancia

Puerta de Garaje con sensor de distancia


Vídeo Demostrativo




Alumna: Nihal Aarabou Ibn Ajiba
Asignatura: Innovación Docente de la Especialidad de Tecnología.
Máster: Máster Universitario en Profesor de Educación Secundaria Obligatoria y Bachillerato, Formación Profesional y Enseñanza de Idiomas
Centro: Universidad de Salamanca.
Curso: 2023/24

Descripción del proyecto




Este prototipo tiene la finalidad de simular el funcionamiento de una puerta de garaje, que se abre y se cierra cuando detecta que hay un coche. Una vez que el coche llega a la puerta del garaje, se detecta con un ultrasonidos su presencia, y en ese momento, se abre la puerta, se enciende la led verde y pita el zumbador y cuando entra el coche se cierra la puerta del garaje y al mismo tiempo se enciende la luz roja y pita el zumbador con otra frecuencia.

El programa utiliza un sensor ultrasónico SR04 para medir la distancia entre un objeto y el sensor y mostrarla en el monitor serie.. El sensor SR04 emite un pulso ultrasónico y mide el tiempo que tarda en regresar el eco. A partir de este tiempo, puede calcular la distancia al objeto.

El programa se ejecuta continuamente en un bucle principal. En cada iteración del bucle, el programa lee la distancia del sensor SR04. Si la distancia es inferior a 5 centímetros, el programa simula la apertura y el cierre de una puerta mediante un servomotor.

Para abrir la puerta, el programa gira el servomotor de 90° a 0°. Para cerrar la puerta, el programa gira el servomotor de 0° a 90°.

Alumnos para los que está dirigido

Este proyecto esta pensado y adaptado perfectamente para las asignaturas de Tecnología y Digitalización de 1º de Bachillerato y de 4º de ESO.

Aprendizaje Transversal

Este proyecto puede utilizarse para el aprendizaje transversal con asignaturas como Educación Física.

Componentes

  • Placa de Arduino ELEGOO UNO R3 
  • Protoboard
  • Passive Buzzer 1PC
  • LED rojo 25 PCS
  • LED verde 25 PCS          
  • 2 resistencias 220Ω
  • sensor ultrasónico SR04 para medir la distancia entre el sensor y un objeto.
  • Cables para circuito de diferentes longitudes
  • Cable puerto USB.
  • 1 Servo Motor SG90
  • 1 barrera roja simula a una puerta de garaje (hecha con la impresora 3D).


Esquema 



Código:

#include<Servo.h>

#include "SR04.h"
#define TRIG_PIN 12
#define ECHO_PIN 11
SR04 sr04 = SR04(ECHO_PIN,TRIG_PIN);
long a;
Servo myServo;
int verde = 2;
int rojo= 3;
int tiempo;
int distancia;
int buzzer=6;
void setup() {
   pinMode(verde,OUTPUT);
   pinMode(rojo,OUTPUT);
   pinMode(buzzer,OUTPUT);
   myServo.attach(5);
   onOffLeds();
  Serial.begin(9600);
}
void loop() {
 leerDistancia();
 if(a<5){
  abrirPuerta();
  delay(2000);
  cerrarPuerta();
  delay(2000);
  }
}


void leerDistancia(){
  a=sr04.Distance();
   Serial.print(a);
   Serial.println("cm");
   delay(100);
  }

void onOffLeds(){
  digitalWrite(verde,HIGH);
  digitalWrite(rojo,HIGH);
  delay(2000);
  digitalWrite(verde,LOW);
  digitalWrite(rojo,LOW);
  delay(2000);
  digitalWrite(verde,HIGH);
  digitalWrite(rojo,HIGH);
  delay(2000);
  digitalWrite(verde,LOW);
  digitalWrite(rojo,LOW);
  }

void cerrarPuerta(){
  digitalWrite(verde,LOW);
  digitalWrite(rojo,HIGH);
    tone(buzzer,8000,2000);
  int angulo=0;
  do{
    angulo=angulo+1;
    myServo.write(angulo);
    delay(50);
    }while(angulo<90);
  digitalWrite(verde,LOW);
  digitalWrite(rojo,LOW);
       noTone(buzzer);
}

void abrirPuerta(){
  digitalWrite(verde,HIGH);
  digitalWrite(rojo,LOW);
  tone(buzzer,5000,2000);
  int angulo =90;
  do{
    angulo=angulo-1;
    myServo.write(angulo);
    delay(50);
    }while(angulo>0);  
  digitalWrite(verde,LOW);
  digitalWrite(rojo,LOW);
  noTone(buzzer);
  }

Comentarios

Estación meteorológica inteligente


 ESTACIÓN METEOROLÓGICA INTELIGENTE


Vídeo demostración.





Alumno: David Hidalgo González
Asignatura: Innovación docente de la especialidad de Tecnología
Máster: Máster Universitario en Profesor de educación secundaria obligatoria y bachillerato,      Formación profesional y enseñanza de idiomas.
Centro: Universidad de Salamanca
Curso: 2023-2024

Descripción del proyecto.

   Este prototipo tiene la finalidad de simular una estación meteorológica midiendo temperatura y humedad con la innovación de medir la cantidad de CO2 en el ambiente pudiendo detectar gas o humo, entre otros parámetros.

   El sistema está constituido de un sensor de temperatura y humedad (DHT11), un sensor de detección de exceso o fuga de gases como óxido nitroso, amoníaco, alcohol, aromáticos, humo y sulfuro (MQ135), una placa de arduino UNO, una protoboard, una pantalla LCD 16x2 en la que se muestran los parámetros de temperatura y humedad en la primera fila y humo en la segunda línea de escritura, un potenciómetro para poder regular la visualización de los datos en la pantalla lcd, un diodo led rojo que intermite cuando hay peligro de humo, gas u otros gases detectados por el mq135, una resistencia necesaria para limitar la corriente eléctrica que circula por el diodo led y un buzzer que simula una sirena que avisa del peligro de mala calidad del aire, detección de fuego o gases detectados por el mq135.


Alumnos a los que está dirigido.

   Este proyecto se puede adaptar a los alumnos de Tecnología y Digitalización de 3º y Tecnología de 4º de la ESO.


Aprendizaje transversal.

   Este proyecto puede emplearse para el aprendizaje transversal con asignaturas como dibujo técnico, informática, matemáticas, física y química y lengua.


ODS.

   El proyecto atiende, además, de forma transversal e intenta mejorar los siguientes ODS:

  • número 3; salud y bienestar.
  • número 4; educación de calidad.
  • número 9; industria, innovación e infraestructura.
  • número 13; acción por el clima.
  • número 15; vida de ecosistemas terrestres.




Componentes.

  • Placa de Arduino ELEGOO UNO R3.
  • Protoboard.
  • Pantalla lcd 16x2.
  • Potenciómetro de 10kΩ.
  • Led rojo.
  • Resistencia de 220Ω.
  • Buzzer
  • Sensor DHT11.
  • Sensor MQ135.
  • Cables para circuito de diferentes longitudes.
  • Cable usb tipo A a tipo B.


Esquemas obtenidos con Tinkercad:

1.- Vista de circuito.





2.- Vista esquemática.





Código arduino.

//Proyecto para estación meteorológica vigilante.

/*Incluimos varias librerías necesarias para los sensores
mq135, dht11 y pantalla lcd 16x2*/
#include <MQ135.h>
#include <DHT.h>
#include <LiquidCrystal.h>

#define DHTPIN 12
#define DHTTYPE DHT11

// Declaración de variables
const int pinMQ135 = 11;
const int DHT_SENSOR_PIN = 12;
const int pinBUZZER = 13;
const int pinLEDr = 8;
MQ135 mq135(A0);

DHT dht(DHTPIN, DHTTYPE);
//Pines usados lcd(rs,en,d4,d5,d6,d7)
LiquidCrystal lcd(7, 6, 5, 4, 3, 2);


void setup() {
  //Inicializamos el puerto serie para la depuración del código,
//los sensores y la pantalla lcd
  Serial.begin(9600);
  dht.begin();

  lcd.begin(16, 2);
  lcd.print ("   MUPES 2024");
  delay(2000);
  lcd.begin(16, 2);
  lcd.clear();

  //Definimos los pines del led rojo y buzzer como salidas de arduino
  pinMode(pinBUZZER, OUTPUT);
  pinMode(pinLEDr, OUTPUT);
}


void loop() {
 
  //Leemos los valores de los sensores
  float temperatura = dht.readTemperature();
  float humedad = dht.readHumidity();
  float humo = analogRead(A0);

  /*Posicionamos el cursor del lcd para escritura de los valores
  de las tres variables*/
  /*En la primera mitad de la primera línea escribimos el valor
  de la temperatura*/
  lcd.setCursor(0, 0);
  lcd.print("T:");
  lcd.print(temperatura);
  lcd.print("C");

  /*En la segunda mitad de la primera línea escribimos el valor
  de la humedad*/
  lcd.setCursor(9, 0);
  lcd.print("H:");
  lcd.print(humedad);
  lcd.print("%");

  //En la segunda línea del lcd escribimos el valor del humo o gas
  lcd.setCursor(0, 1);
  lcd.print("humo:");
  lcd.print(humo);
  lcd.print("ppm");

  /*Cuando el MQ135 detecta humo o gas, entre otros, activa
  intermitentemente el led rojo y continuamente el buzzer*/
  if(humo > 150){
    digitalWrite(pinBUZZER, HIGH);
    digitalWrite(pinLEDr, HIGH);
    delay(1000);
    digitalWrite(pinLEDr, LOW);
    delay(1000);
  }
  /*Cuando el MQ135 no detecta humo o gas, entre otros, desactiva
  el led rojo y el buzzer*/
  else{
    digitalWrite(pinLEDr, LOW);
    digitalWrite(pinBUZZER, LOW);
  }

  delay(500);
}

Salamanca, 24 de enero de 2024.





Sistema de medición de velocidad

Video demostración



Alumno: Victor Fagúndez Poyo
Asignatura: Innovación Docente de la Especialidad de Tecnología.
Máster: Máster Universitario en Profesor de Educación Secundaria Obligatoria y Bachillerato, Formación Profesional y Enseñanza de Idiomas
Centro: Universidad de Salamanca.
Curso: 2023/24

Descripción del proyecto

Este prototipo tiene la finalidad de simular el funcionamiento de un sensor de velocidad o radar de tramo.


El sistema consiste principalmente en dos sensores de ultrasonidos utilizados como detectores de paso. Cuando el coche pasa a menos de 50 centimetros del primer sensor se activa un led indicando que ha detectado el paso y activa un cronometro que se detiene cuando el segundo sensor detecta el paso del coche a menos de 50 centimetros de distancia. 

Una vez que conocemos el tiempo que ha tardado en recorrer los 14 cm que separan ambos sensores podemos calcular mediante la ecuación vista en la clase de Fisica y Quimica de velocidad es igual a espacio entre tiempo.

Y una vez calculada la velocidad la mostramos por la pantalla LCD 16x2.


Alumnos para los que está dirigido

Este proyecto se puede adaptar perfectamente para las asignaturas de Tecnología y Tecnología y Digitalización de 3º y 4º de ESO.

Aprendizaje Transversales

Este proyecto puede utilizarse para el aprendizaje transversal con asignaturas como Educación Fisica en la que los alumnos pueden medir su velocidad corriendo y con la asignatura de Fisica y Quimica para el calculo de velocidades.

Componentes

  • Placa de Arduino ELEGOO UNO R3 
  • Protoboard
  • Pantalla LCD 16x2
  • Potenciómetro de 10 K
  • Diodo LED rojo
  • Diodo LED azul          
  • 3 resistencias 220Ω
  • 2 sensores de ultrasonidos
  • Cables para circuito de diferentes longitudes
  • Cable puerto USB


Esquema 




Código

// include the library code:
#include <LiquidCrystal.h>
// Definición de pines para los sensores de ultrasonidos
const int triggerPinInicial = 3;
const int echoPinInicial = 2;
const int LedPasoInicial = 4;

const int triggerPinFinal = 13;
const int echoPinFinal = 12;
const int LedPasoFinal = 11;
// pines pantalla
const int rs = 10, en = 9, d4 = 8, d5 = 7, d6 = 6, d7 = 5;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

// Variables para el cronómetro
unsigned long startTime = 0;
unsigned long endTime = 0;
unsigned long elapsedTime;

//variables para medir distancia
boolean pasoInicial=false;
boolean pasoFinal=false;

float distanciaInicial;
float distanciaFinal;
float speed;

// Constante para la distancia de activación del cronómetro (en centímetros)
const int activationDistance = 50;

// Constante para la distancia entre los sensores (en centímetros)
const int sensorSeparation = 14;

void setup() {
  // Inicializar los pines de los sensores de ultrasonidos
  pinMode(triggerPinInicial, OUTPUT);
  pinMode(echoPinInicial, INPUT);
  pinMode(triggerPinFinal, OUTPUT);
  pinMode(echoPinFinal, INPUT);

  // Inicializar el puerto serie
  Serial.begin(9600);
  // set up the LCD's number of columns and rows:

  lcd.begin(16, 2);

  // Print a message to the LCD.

  lcd.print("Velocidad:");
}

void loop() {
  //Si no se ha detectado el primer paso
  if(pasoInicial==false){
    // Medir la distancia con el primer sensor
    distanciaInicial = measureDistance(triggerPinInicial, echoPinInicial);
    Serial.print("La distanciaInicial es: ");
    Serial.print(distanciaInicial);
    Serial.print("\n");
    //Si la distancia Inicial es menor que la distancia de activación
    if (distanciaInicial <= activationDistance) {
      digitalWrite(LedPasoInicial, HIGH); //encendmos el Led de paso inicial
      pasoInicial = true; //activamos la variable de paso inicial
      //activamos el reloj
      if (startTime == 0) {
        startTime = millis();
        Serial.println("Cronómetro activado");
      }
    }else{
      digitalWrite(LedPasoInicial, LOW); //apagamos el Led de paso inicial
    }
  }
  //Si no se ha detectado el segundo paso
  if(pasoInicial==true && pasoFinal==false){
    // Medir la distancia con el segundo sensor si no se ha registrado el segundo paso
    distanciaFinal = measureDistance(triggerPinFinal, echoPinFinal);
    Serial.print("La distanciaFinal es: ");
    Serial.print(distanciaFinal);
    Serial.print("\n");
    //Si la distancia Final es menor que la distancia de activación
    if (distanciaFinal <= activationDistance) {
      digitalWrite(LedPasoFinal, HIGH); //encendmos el Led de paso Final
      pasoFinal = true; //activamos la variable de paso Final
      //detenemos el reloj
      if (startTime != 0) {
        endTime = millis();
        elapsedTime = endTime - startTime;
        speed = calculateSpeed(elapsedTime);
        Serial.print("Velocidad: ");
        Serial.print(speed);
        Serial.println(" km/h");
        // set the cursor to column 0, line 1
        // (note: line 1 is the second row, since counting begins with 0):
        lcd.setCursor(0, 1);
        // print the number of seconds since reset:
        lcd.print(speed);
        lcd.print(" km/h    ");
        // Reiniciar el cronómetro
        startTime = 0;
        endTime=0;
        speed= 0;
        pasoInicial = false;
        pasoFinal = false;
        digitalWrite(LedPasoInicial, LOW);
        digitalWrite(LedPasoFinal, LOW);
        delay(5000);
        lcd.setCursor(0, 1);
        lcd.print("Esperando...");
      }
    }else{
      digitalWrite(LedPasoInicial, LOW); //apagamos el Led de paso inicial
    }
  }
 
}

float measureDistance(int triggerPin, int echoPin) {
  // Generar un pulso corto para activar el sensor
  digitalWrite(triggerPin, LOW);
  delayMicroseconds(2);
  digitalWrite(triggerPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(triggerPin, LOW);

  // Medir la duración del pulso de eco
  float duration = pulseIn(echoPin, HIGH);

  // Calcular la distancia en centímetros
  float distance = duration * 0.034 / 2;

  return distance;
}

float calculateSpeed(unsigned long elapsedTime) {
  // Calcular la velocidad en cm/s
  Serial.println("El tiempo es");
  Serial.println(elapsedTime);
  float speed = (sensorSeparation) / (elapsedTime / 1000.0);
  speed= speed *0.036; //velocidad en km/h
  return speed;
}