RADAR DE VELOCIDAD CON ARDUINO
MIEMBROS DEL GRUPO
- Álvaro Barrio Luquero
- Sergio García Rosell
- Alberto Martín Amengual
INTRODUCCIÓN
Para este proyecto final de la asignatura de Diseño de sistema empotrados se ha desarrollado un radar de velocidad portátil, que va a calcular tanto la velocidad de cualquier objeto que pase frente a él como la distancia a la que pasa de este. Esto se ha conseguido gracias a la compra de dos sensores de ultrasonidos. Cuenta con un set de botones con los que se puede programar un límite de velocidad, para en caso de rebasarlo, activar una alarma sonora aparte de luminosa. También cuenta con un regulador con el que podemos ajustar el rango de actuación del radar, y cómo no, una pantalla LCD que muestra la información que necesitamos. Además, gracias que se alimenta mediante conexión USB, se puede conectar a un enchufe o a otros dispositivos como una batería externa y usarlo en cualquier parte.
LISTA DE MATERIALES
| Material | Cantidad | Precio |
| Placa de Arduino | 1 | – |
| Protoboards | 3 | – |
| Módulos de ultrasonidos HC-SR04 | 2 | 8,95€ |
| Potenciómetro | 1 | 3€ |
| Zumbador | 1 | 0,6€ |
| Modulo LCD 16×2 | 1 | – |
| Leds | 3 | – |
| Resistencias | 7 | – |
| Pulsadores | 3 | 2,47€ |
| Cables y Puentes | 46 | – |
HARDWARE
A continuación, se va a explicar por grupos la implementación de cada una de las partes de este proyecto:
–Módulos de ultrasonidos
Disponemos de dos sensores de ultrasonido colocados a una distancia de 11 metros entre ellos para poder calcular con exactitud tanto la distancia a la que pasa el vehículo móvil como la velocidad con la que circula. En este caso de cara al hardware los sensores están conectados a la placa de arduino mediante 4 cables, (VCC, TRIG, ECHO Y (el tierra)GRN) El VCC va conectado al pin de 5 voltios de la placa de arduino, el TRIG y el ECHO van conectados a los puertos digitales y el GRN (tierra) va conectado directamente con el GRN(tierra) de la placa de arduino.
–Pantalla LCD
Para la pantalla LCD disponemos de un módulo adaptador de LCD a I2C para poder reducir el cableado de nuestra pantalla LCD a 4 cables. El primero de los cables es el VCC que como para los sensores de ultrasonido se colocara sobre el pin de 5 voltios. El cable GRN que iría conectado al pin de tierra. Por último tenemos los cables SDA y SCL que irían directamente conectados con los puertos analógicos A4 y A5 respectivamente.
-Set de botones
El set de botones está construido sobre una protoboard casi a medida. En total tenemos 3 botones colocados en fila y junto a cada uno de ellos un led de color verde, formando una fila de leds paralela a la fila de botones. Cada led va conectado por la parte del ánodo y con una resistencia de por medio a los pines digitales de la placa, uno al pin 8, otro al pin 9 y otro al pin 10. Y por la parte del cátodo van al bus negativo de la protoboard.
En el caso de los botones, cada uno tiene uno de sus contactos positivos conectado al bus positivo de la protoboard, y uno de los contactos negativos conectado al bus negativo de la protoboard con una resistencia entre medias y con un punto de medición entre dicha resistencia y el contacto negativo del pulsador que se conecta directamente a los pines digitales de la placa, uno al pin 11, otro al pin 12 y otro al pin 13. Por último, tenemos 2 cables que parten de los buses positivo y negativo y que irán conectados de forma indirecta al pin de 5 voltios y al pin de tierra de la placa para alimentar todo el módulo.
-Alarma y limitador de rango
Como método de aviso cuando un objeto pasa la velocidad máxima limitada por el set de botones explicada anteriormente, se ha diseñado una alarma utilizando un zumbador utilizando los conocimientos aprendidos en la primera práctica de esta asignatura, además se encenderá un led de color rojo también como aviso. También se ha añadido un regulador de rango utilizando un potenciómetro para delimitar la distancia a la que como máximo el radar va a detectar objetos.
El zumbador está conectado a la placa de Arduino mediante el pin digital 6, el led y su resistencia correspondientes se conectan a la placa de Arduino mediante el pin digital 7, y el potenciómetro se conecta a la placa por el puerto analógico A3 y al pin de 5V. Y, por último, mediante un cuidadoso sistema de cableado reducido se agrupan tanto el zumbador como el led como el potenciómetro para conectarlos al pin de tierra. La implementación de todos estos elementos se ha realizado en una protoboard de tamaño reducido 10×17.
-Circuito
Una vez vista cada una de las partes de este proyecto se puede pasar a conectarlo todo a la placa de Arduino creando el circuito final.
CÓDIGO
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
//--- PARÁMETROS CONFIGURABLES ---//
const int LIMITE1 = 100;
const int LIMITE2 = 500;
const int LIMITE3 = 1000;
const int RANGO_MIN = 10;
const int RANGO_MAX = 200;
//--------------------------------//
LiquidCrystal_I2C lcd(0x27,16,2); //LCD 2x16 controlado por I2C.
byte customChar[] = {B01110,B01110,B01110,B01110,B01110,B01110,B01110,B01110};
const int trigger1 = 2; // Trigger del sensor 1 en pin digital 2.
const int echo1 = 3; // Echo del sensor 1 en pin digital 3.
const int trigger2 = 4; // Trigger del sensor 2 en pin digital 4.
const int echo2 = 5; // Trigger del sensor 2 en pin digital 5.
const int distanciaSensores = 11; // Distancia entre los sensores (cm).
const int potenciometro = A3; // Potenciometro en pin analógico 3.
const int zumbador_alarma = 6; // Zumbador de alarma en pin digital 6.
const int led_alarma = 7; // Led de alarma en pin digital 7.
const int boton1 = 11; // Boton 1 en pin digital 11.
const int led1 = 8; // Led 1 en pin digital 8.
const int boton2 = 12; // Boton 2 en pin digital 12.
const int led2 = 9; // Led 2 en pin digital 9.
const int boton3 = 13; // Boton 3 en pin digital 13.
const int led3 = 10; // Led 3 en pin digital 10.
int rango_dist; // Rango de actuación (cm).
float tPulso1; // Tiempo que tarda en ir y volver un pulso del sensor 1 (μs).
float dist1; // Distancia a la que detecta movimiento el sensor 1 (cm).
float tiempo1; // Momento de tiempo en el que detecta movimiento el sensor 1 (ms).
float tPulso2; // Tiempo que tarda en ir y volver un pulso del sensor 2 (μs).
float dist2; // Distancia a la que detecta movimiento el sensor 2 (cm).
float tiempo2; // Momento de tiempo en el que detecta movimiento el sensor 2 (ms).
float distMedia; // Distancia media a la que se pasa del radar (cm).
float tiempoFinal; // Tiempo que se tarda en llegar del sensor 1 al sensor 2 (s).
float velocidad; // Velocidad calculada (cm/s).
int limite_velocidad=-1; // Límite de velocidad que hará saltar la alarma (cm/s). Sin límite -> -1.
void setup() {
Serial.begin(9600);
// SENSOR 1
pinMode(trigger1, OUTPUT); // Trigger1 configurado como salida.
pinMode(echo1, INPUT); // Echo1 configurado como entrada.
digitalWrite(trigger1, LOW); // Se inicializa sin emitir pulso.
// SENSOR 2
pinMode(trigger2, OUTPUT); // Trigger2 configurado como salida.
pinMode(echo2, INPUT); // Echo2 configurado como entrada.
digitalWrite(trigger2, LOW); // Se inicializa sin emitir pulso.
// POTENCIÓMETRO
pinMode(potenciometro, INPUT); // Potenciómetro configurado como entrada.
// ALARMA
pinMode(zumbador_alarma, OUTPUT); // Zumbador de alarma configurado como salida.
noTone(zumbador_alarma);
pinMode(led_alarma, OUTPUT); // Led de alarma configurado como salida.
// LEDS
pinMode(led1,OUTPUT); //
pinMode(led2,OUTPUT); // Leds configurados como salida.
pinMode(led3,OUTPUT); //
//BOTONES
pinMode(boton1,INPUT); //
pinMode(boton2,INPUT); // Botones configurados como entrada.
pinMode(boton3,INPUT); //
// LCD I2C
lcd.init(); // El controlador I2C inicia el LCD.
lcd.backlight(); // El controlador I2C enciende la luz de fondo del LCD.
// INTRO LCD
lcd.createChar(0,customChar);
for (int i=0; i<8; i++) {
lcd.setCursor(i,1);
lcd.write(0);
delay(10);
lcd.setCursor(i,0);
lcd.write(0);
delay(10);
lcd.setCursor(15-i,1);
lcd.write(0);
delay(10);
lcd.setCursor(15-i,0);
lcd.write(0);
delay(10);
}
lcd.clear();
for (int i=8; i<16; i++) {
lcd.setCursor(i,1);
lcd.write(0);
delay(10);
lcd.setCursor(i,0);
lcd.write(0);
delay(10);
lcd.setCursor(15-i,1);
lcd.write(0);
delay(10);
lcd.setCursor(15-i,0);
lcd.write(0);
delay(10);
}
lcd.clear();
delayMicroseconds(2);
}
void loop() {
rango_dist = map(analogRead(potenciometro), 0, 1023, RANGO_MIN, RANGO_MAX); // Lectura del rango de actuación a partir del valor del potenciómetro con sus valores remapeados entre 10 y 200 (cm).
lcd.print("Esperando..."); //
lcd.setCursor(0,1); //
lcd.print("Rango: "); // Pantalla de espera
lcd.print(rango_dist); //
lcd.print(" cm "); //
lcd.setCursor(0,0); //
if ((digitalRead(boton1)==HIGH)&&(digitalRead(led1)==LOW)) { // Si se pulsa el botón 1 y el led 1 está apagado.
limite_velocidad = LIMITE1;
digitalWrite(led1, HIGH);
digitalWrite(led2, LOW);
digitalWrite(led3, LOW);
delay(500);
}
if ((digitalRead(boton1)==HIGH)&&(digitalRead(led1)==HIGH)) { // Si se pulsa el botón 1 y el led 1 está encendido.
limite_velocidad = -1;
digitalWrite(led1,LOW);
delay(500);
}
if ((digitalRead(boton2)==HIGH)&&(digitalRead(led2)==LOW)) { // Si se pulsa el botón 2 y el led 2 está apagado.
limite_velocidad = LIMITE2;
digitalWrite(led1, LOW);
digitalWrite(led2, HIGH);
digitalWrite(led3, LOW);
delay(500);
}
if ((digitalRead(boton2)==HIGH)&&(digitalRead(led2)==HIGH)) { // Si se pulsa el botón 2 y el led 2 está encendido.
limite_velocidad = -1;
digitalWrite(led2,LOW);
delay(500);
}
if ((digitalRead(boton3)==HIGH)&&(digitalRead(led3)==LOW)) { // Si se pulsa el botón 3 y el led 3 está apagado.
limite_velocidad = LIMITE3;
digitalWrite(led1, LOW);
digitalWrite(led2, LOW);
digitalWrite(led3, HIGH);
delay(500);
}
if ((digitalRead(boton3)==HIGH)&&(digitalRead(led3)==HIGH)) { // Si se pulsa el botón 3 y el led 3 está encendido.
limite_velocidad = -1;
digitalWrite(led3,LOW);
delay(500);
}
digitalWrite(trigger1, HIGH); //
delayMicroseconds(10); // Se envía un pulso de 10us por el sensor 1.
digitalWrite(trigger1, LOW); //
tPulso1 = pulseIn(echo1, HIGH); // Se obtiene el tiempo que tarda en ir y volver un pulso del sensor 1 (μs).
dist1 = tPulso1/59; // Se calcula la distancia a partir del tiempo ida-vuelta de un pulso (cm).
if ((dist1<rango_dist)) {
tiempo1 = millis(); // Se obtiene el momento de tiempo en el que detecta movimiento el sensor 1 (ms).
do {
digitalWrite(trigger2, HIGH); //
delayMicroseconds(10); // Se envía un pulso de 10us por el sensor 2.
digitalWrite(trigger2, LOW); //
tPulso2 = pulseIn(echo2, HIGH); // Se obtiene el tiempo que tarda en ir y volver un pulso del sensor 2 (μs).
dist2 = tPulso2/59; // Se calcula la distancia a partir del tiempo ida-vuelta de un pulso (cm).
} while (dist2>=rango_dist);
tiempo2 = millis(); // Se obtiene el momento de tiempo en el que detecta movimiento el sensor 2 (ms).
tiempoFinal = (tiempo2-tiempo1)/1000; // Tiempo que se tarda en pasar entre el sensor 1 y sensor 2 (s).
distMedia = (dist1+dist2)/2; // Distancia media a la que se pasa del radar (cm).
velocidad = distanciaSensores/tiempoFinal; // Velocidad calculada (cm/s).
lcd.clear();
lcd.print("Dist: ");
lcd.print(distMedia);
lcd.print(" cm");
lcd.setCursor(0,1);
lcd.print("Vel: ");
lcd.print(velocidad);
lcd.print(" cm/s");
if ((velocidad > limite_velocidad)&&(limite_velocidad>-1)) { // Si hay límite establecido (>-1) y la velocidad es superior a ese límite.
digitalWrite(led_alarma, HIGH); //
for (int i=0; i<20; i++) { // Alarma encendida
tone(zumbador_alarma,500, 50); //
delay(100);
}
noTone(zumbador_alarma); // Alarma apagada
digitalWrite(led_alarma, LOW); //
delay(2000);
}
else {
delay(5000);
}
lcd.clear(); // Se limpia la pantalla y se vuelve a la pantalla de espera.
}
}
PROBLEMAS Y SOLUCIONES
Durante el desarrollo de esta practica hemos tenido diversos problemas. El más claro es el no poder quedar para desarrollar la practica de manera física, sino que uno de los integrantes ha tenido que llevar el peso de construir el hardware con ayuda de los otros dos integrantes mediante videollamadas, videos o fotos, lo que provoca una perdida de aprendizaje por parte de los otros dos integrantes, ya que no es lo mismo realizarlo de manera física a realizarlo de manera telematica.
-Problemas con el Hardware
De cara al hardware tuvimos un problema con el LCD ya que no sabíamos para que servia el bus I2C que venia soldado y usábamos muchos cables para conectar la pantalla LCD a la placa de Arduino. Una vez aprendido a conectar el I2C se vio reflejado en la reducción de cableado, lo que hacia que fuera mas fácil y cómodo seguir implementando mas partes del hardware.
-Problemas con el Software
Otro de los problemas que nos ha surgido ha sido a la hora de desarrollar el software, queríamos haber implementado una animación en la pantalla LCD para cuando se iniciara el proyecto y estuviera esperando a que pasara algún vehículo móvil por alguno de los sensores, pero debido a la dificultad de la implementación decidimos prescindir de ella.
Como último problema que ha ocurrido durante el desarrollo de la practica ha sido la implementación de los pulsadores debido a que cuando implementamos el código por primera vez a la hora de probarlo, por muy corta que fuera la pulsación dejaba pasar corriente y le daba tiempo tanto a activar como desactivar los limitadores de velocidad, por lo que al pulsar un pulsador podía activarse o no. La solución que le dimos fue incluir un delay de medio segundo para evitar que se activara y desactivara de una pulsada.
intente hacerlo con esp32 y la pantalla lcd queda en espera siempre, alguna sugerencia
Medidas de la caja porfavor
necesitamos las medidas de la caja que has usado porfavor
Como instalo el software??