Proyecto 2, Sistemas de Asistencia al conductor

Sistemas de seguridad e iluminación vehicular NRC 20636

Sosa Sánchez Luis Miguel 201963213 Castillo Perez Leonardo 201640706 Camela Rubin de Celis David
201905862

Resumen—En este documento se hablará sobre el Accidentes de tráfico en

desarrollo de los sistemas de seguridad para la asistencia al México
conductor, en el caso específico, se trata de un detector de
alcohol y freno automático por visión artificial. 600000

Abstract—This document will talk about the development
of safety systems for driver assistance, in the specific case, it
is an alcohol detector and automatic braking by artificial
vision.
I. INTRODUCCIÓN
¿Qué es un detector de alcohol?
El Detector de Alcohol en Aliento ha sido propuesto para
medir alcohol en aliento humano. Los resultados se utilizan en
el diagnóstico de intoxicación por alcohol. El Detector de
Alcohol en Aliento es un examen rápido de filtrado semi-
cuantitativo. Indica la relativa Concentración de Alcohol en la
Sangre (CAS) a niveles de corte 0.02%, 0.04%, 0.05%, 0.06%,
0.08% ó 0.10. Cada detector contiene cristales que detectan un
nivel específico de corte de CAS. El alcohol reacciona con los
cristales del detector produciéndose un cambio de color. El
cambio de color depende de la cantidad de alcohol en el
aliento. Si el examen es positivo, la cantidad de alcohol en el
aliento será mayor o igual al nivel de corte del detector. [1]
¿Qué es la visión artificial?
Accidentes
400000
200000
0
2013-2022
El Reglamento de Tránsito vigente en la Ciudad de
México, estipula en su artículo 50: queda prohibido
conducir vehículos motorizados cuando se tenga una
cantidad de alcohol en la sangre superior a 0.8 gramos por
litro o de alcohol en aire espirado superior a 0.4
miligramos por litro, así como bajo el influjo de
narcóticos, estupefacientes o psicotrópicos al conducir.
[5]
Los conductores de vehículos destinados al servicio
de transporte público de pasajeros, transporte escolar o de
personal, vehículos de emergencia, de transporte de carga,
no deben presentar ninguna cantidad de alcohol en la
sangre o en aire espirado. [5]

La visión artificial es un campo de la IA que permite que II. DESARROLLO

las computadoras y los sistemas obtengan información
significativa de imágenes digitales, videos y otras entradas En esta práctica, se realizó la medición del nivel de
visuales, y tomen acciones o hagan recomendaciones basadas alcohol para determinar si se encuentra en el límite legal
en esa información. [2] o no.
¿Qué es la asistencia al conductor?
Los sistemas de seguridad de asistencia a la conducción
tienen como objetivo principal ayudar al conductor con el
objetivo de reducir el impacto de una colisión o incluso evitar
un accidente. [3]

En México, cada año mueren 24 mil personas en Fig.1. Sensor de gas MQ3.
accidentes automovilísticos relacionados con el consumo de
alcohol. México ocupa el 7º lugar mundial en muertes por esta El código utilizado con el Arduino Uno es el
causa. [4] siguiente:

TABLA I
ACCIDENTES DE TRANSITO EN LOS ÚLTIMOS 10
AÑOS.

Año Accidentes Año Accidentes

2013 385,722 2014 380,573

2015 380,573 2016 382,066

2017 367,789 2018 365,281

2019 362,729 2020 301,678 Fig.2. Código utilizado en el Arduino Uno.

2021 340,415 2022 377,231

 Para poder ajustar el umbral de detección en el código, se void handleJpgLo() {
tomó la información del reglamento de tránsito de la ciudad de
if
México, el cual establece el límite máximo de 0.4mg/L.
(!esp32cam::Camera.changeResolution(loRes))
{
Serial.println("SET-LO-RES FAIL");
}
serveJpg();
}

void handleJpgHi() {
if
(!esp32cam::Camera.changeResolution(hiRes))
Fig.3. Calibración de mediciones (Arduino Uno). {
Serial.println("SET-HI-RES FAIL");
Ahora se procederá a probar los distintos tipos de
alcohol propuestos en los requisitos de la practica (etanol, }
cerveza, vodka, etc.). serveJpg();
}
Para la segunda parte del trabajo, el código utilizado
para el módulo ESP32-CAM es el siguiente:
#include <WiFi.h> void handleJpgMid() {
#include <esp32cam.h> //Download This if
Library: (!esp32cam::Camera.changeResolution(midRes)
) {
const char* WIFI_SSID = "Estudio"; //Set Your Serial.println("SET-MID-RES FAIL");
Wifi SSID/Name }
const char* WIFI_PASS = "00679794"; //Set serveJpg();
Your Wifi Password }

WebServer server(80);
void setup() {
Serial.begin(115200);
static auto loRes = Serial.println();
esp32cam::Resolution::find(320, 240); {
static auto midRes = using namespace esp32cam;
esp32cam::Resolution::find(350, 530); Config cfg;
static auto hiRes = cfg.setPins(pins::AiThinker);
esp32cam::Resolution::find(800, 600); cfg.setResolution(hiRes);
void serveJpg() { cfg.setBufferCount(2);
auto frame = esp32cam::capture(); cfg.setJpeg(80);
if (frame == nullptr) {
Serial.println("CAPTURE FAIL"); bool ok = Camera.begin(cfg);
server.send(503, "", ""); Serial.println(ok ? "CAMERA OK" :
return; "CAMERA FAIL");
} }
Serial.printf("CAPTURE OK %dx%d %db\n", WiFi.persistent(false);
frame->getWidth(), frame->getHeight(), WiFi.mode(WIFI_STA);
static_cast<int>(frame- WiFi.begin(WIFI_SSID, WIFI_PASS);
>size())); while (WiFi.status() != WL_CONNECTED) {
delay(500);
server.setContentLength(frame->size()); }
server.send(200, "image/jpeg"); Serial.print("http://");
WiFiClient client = server.client(); Serial.println(WiFi.localIP());
frame->writeTo(client); Serial.println(" /cam-lo.jpg");
} Serial.println(" /cam-hi.jpg");
Serial.println(" /cam-mid.jpg");
 Serial.begin(9600); //Here Baudrate is
server.on("/cam-lo.jpg", handleJpgLo); Important. You need to set same baudrate in
server.on("/cam-hi.jpg", handleJpgHi); python program.
server.on("/cam-mid.jpg", handleJpgMid);
// configure the sensors
server.begin(); qtr.setTypeRC();
} qtr.setSensorPins((const uint8_t[]){ 13,
14, 27, 26, 25, 33 }, SensorCount);
void loop() { qtr.setEmitterPin(32);
server.handleClient();
} //output pin declare
pinMode(RPWM, OUTPUT);
Ahora el código utilizado para la tarjeta de desarrollo
ESP32 de 38 pines: pinMode(LPWM, OUTPUT);
#include <Arduino.h>
#include <QTRSensors.h> // Setup PWM channels
ledcSetup(R, 5000, 8); // Channel 0 for
QTRSensors qtr; Motor A, 5 kHz frequency, 8-bit resolution
ledcAttachPin(RPWM, R);
const uint8_t SensorCount = 6; ledcSetup(L, 5000, 8); // Channel 0 for
uint16_t sensorValues[SensorCount]; Motor A, 5 kHz frequency, 8-bit resolution
ledcAttachPin(LPWM, L);
const int trigPin = 15;
const int echoPin = 4; pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
//define sound speed in cm/uS pinMode(IN3, OUTPUT);
#define SOUND_SPEED 0.034 pinMode(IN4, OUTPUT);
#define CM_TO_INCH 0.393701
pinMode(trigPin, OUTPUT); // Sets the
long duration; trigPin as an Output
float distanceCm; pinMode(echoPin, INPUT); // Sets the
echoPin as an Input
//initial Speed of the Bot
int Speed = 160; digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
/*FOR RIGHT MOTOR*/
int RPWM = 5; digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
/*FOR LEFT MOTOR*/ }
int LPWM = 23;
int Sflag = 0; void loop() {
if (Serial.available() > 0) {
//declare channel for pwm Output
#define R 0 int angle = Serial.parseInt();
#define L 1 if (angle == 1) {
while (1) {
//Define in1/in2/in3/in4 pin int angle = Serial.parseInt();
int IN1 = 18; if (angle == 2) break;
int IN2 = 19; stop();
int IN3 = 21; }
int IN4 = 22; } else {
lfr();
int threshold = 1000; }
} else {
void setup() { lfr();
 } if (sensorValues[2] > threshold ||
} sensorValues[3] > threshold) break;
void lfr() { }
} else if (sensorValues[1] > threshold)
// Clears the trigPin {
digitalWrite(trigPin, LOW); //Serial.println("lfr");
delayMicroseconds(2); ledcWrite(R, 0);
// Sets the trigPin on HIGH state for 10 ledcWrite(L, 170);
micro seconds
digitalWrite(trigPin, HIGH); digitalWrite(IN1, HIGH);
delayMicroseconds(10); digitalWrite(IN2, LOW);
digitalWrite(trigPin, LOW);
digitalWrite(IN3, HIGH);
// Reads the echoPin, returns the sound wave digitalWrite(IN4, LOW);
travel time in microseconds } else if (sensorValues[4] > threshold)
duration = pulseIn(echoPin, HIGH); {
//Serial.println("lfr");
// Calculate the distance ledcWrite(R, 170);
distanceCm = duration * SOUND_SPEED / 2; ledcWrite(L, 0);
read();
digitalWrite(IN1, HIGH);
if (distanceCm <= 20) { digitalWrite(IN2, LOW);
stop();
delay(2000); digitalWrite(IN3, HIGH);
} else { digitalWrite(IN4, LOW);
if (sensorValues[0] > threshold) { } else if (sensorValues[2] > threshold
while (1) { || sensorValues[3] > threshold) {
//Serial.println("lfr"); //Serial.println("lfr");
ledcWrite(R, 200); ledcWrite(R, Speed);
ledcWrite(L, 200); ledcWrite(L, Speed);

digitalWrite(IN1, LOW); digitalWrite(IN1, HIGH);

digitalWrite(IN2, HIGH); digitalWrite(IN2, LOW);

digitalWrite(IN3, HIGH); digitalWrite(IN3, HIGH);

digitalWrite(IN4, LOW); digitalWrite(IN4, LOW);
read(); }
if (sensorValues[2] > threshold || }
sensorValues[3] > threshold) break; }
}
void stop() {
} else if (sensorValues[5] > threshold) { //Serial.println("Stop");
while (1) { ledcWrite(R, Speed);
//Serial.println("lfr"); ledcWrite(L, Speed);
ledcWrite(R, 200);
ledcWrite(L, 200); digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW); digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
digitalWrite(IN3, LOW); }
digitalWrite(IN4, HIGH);
read(); void read() {
// read raw sensor values
 qtr.read(sensorValues);

// print the sensor values as numbers from 0

to 2500, where 0 means maximum
// reflectance and 2500 means minimum
reflectance
for (uint8_t i = 0; i < SensorCount; i++) {
Serial.print(sensorValues[i]);
Serial.print('\t');
}
} Fig.6. Configuración de red del módulo ESP32-CAM en Arduino IDE.

Para la parte de transmisión de video, se utilizó Python

para poder reproducir en tiempo real la información capturada
por el módulo ESP32_CAM (se utilizó para validar la correcta
conexión).

Fig.7. Código en Python IDLE para el ESP32 y ESP32-CAM.

Fig.4. Código para verificar el funcionamiento del ESP32-CAM en Python IDLE

Shell.

Fig.5. Vista en vivo del módulo ESP32-CAM en Python IDLE Shell.

Fig.8. Código en Python IDLE para el ESP32 y ESP32-CAM.

 Fig.11. Diagrama de funcionamiento del vehículo.

-
Fig.9. Código en Python IDLE para el ESP32 y ESP32-CAM.

Fig.12. Diagrama de funcionamiento del vehículo.

Para poder realizar la conexión del equipo (servidor) y la

cámara, se utilizo un teléfono celular como Router para que, con
ello, los dispositivos se encuentren dentro de la misma red de área
local.
Fig.10. Conexión del sensor MQ3 en Arduino Uno.

III. RESULTADOS
Para el detector de alcohol se tiene lo siguiente:

Sustancia Concentración Nivel

(lectura
analógica
del
sensor)

Cerveza 4.5% 210

Fig.10. Conexión del ESP32 y el módulo L298N. Alcohol 70% 278

medicinal

Ron 40% 231

Para la visión artificial se tiene lo siguiente:

Fig.17. Prototipo del auto.

Fig.13. Visión artificial en tiempo real detectando señales de alto.

Fig.18. Prototipo del auto.

Fig.14. Visión artificial en tiempo real detectando un vehículo.

Fig.19. Prototipo del auto.

IV. CONCLUISON GENERAL

Fig.15. Visión artificial en tiempo real detectando un vehículo.
Durante la actividad pudimos desarrollar un
vehículo con la capacidad de frenar
automáticamente bajo ciertas condiciones
establecidas en los requisitos (que se detenga cuando
algo pase frente al vehículo, que se detenga cuando
vea una señal de alto, que siga la marcha cuando
detecte otro vehículo).
La implementación del prototipo se realizo con
la tarjeta de desarrollo ESP32, el módulo de cámara
ESP32- CAM, y los scripts de detección de objetos
Fig.16. Visión artificial en tiempo real detectando una señal de alto. en Python, además del entrenamiento del perceptrón
mediante la utilidad open source YOLOv3. Todo
Video del prototipo en acción: esto nos permitió aplicar el conocimiento y
habilidades obtenidos durante el transcurso de la
https://www.youtube.com/watch?v=dTXJbqFHNu0 carrera.
 En cuanto al delay que se tiene para la
comunicación entre el ESP32 y ESP32-CAM see
recomienda utilizar una tarjeta de desarrollo como la
Raspberry Pi 4 de por lo menos 4GB de memoria RAM o
también la tarjeta Orange Pi 5 con 32GB de memoria y
procesador de 64-bits.
IIV. CONCLUISONES INVIDUALES
Luis: los sistemas de asistencia al conductor son
tecnologías diseñadas para mejorar la seguridad y
comodidad de los conductores al ofrecer apoyo en la
conducción. Estas tecnologías utilizan sensores, cámaras
y otros dispositivos para recopilar información sobre el
entorno del vehículo y ayudar al conductor en diversas
tareas.
David: los sistemas de asistencia al conductor
pueden ayudar a prevenir accidentes al proporcionar
alertas y asistencia en situaciones de riesgo. Por ejemplo,
sistemas como el frenado automático de emergencia o la
asistencia de mantenimiento de carril pueden ayudar a
evitar colisiones.
Leonardo: al ayudar a prevenir accidentes, los
sistemas de asistencia al conductor contribuyen a la
reducción de costos asociados con lesiones, reparaciones
de vehículos y seguros, lo que beneficia tanto a los
conductores como a las compañías de seguros.
IIIV. REFERENCIAS
[1] Alcoholímetro. (2019). Gobierno de
México. Recuperado 9 de noviembre de 2023, de
https://www.gob.mx/cms/uploads/attachment/file/5
66152/Triptico_Alcohol_y_Accidentes_2019.pdf
[2] De Estadística Y Geografía, I. N. (s. f.).
Banco de Indicadores.
https://www.inegi.org.mx/app/indicadores/?ind=10
06000039&tm=6#D1006000039
[3] Detector de Alcohol en Aliento. (2010).
Misión. Recuperado 7 de noviembre de 2023, de
http://biolore.com.co/wp-
content/uploads/2019/08/Inserto_C031-
011_Alcohol_en_Aliento.pdf
[4]¿Qué es la visión artificial? | IBM. (s. f.).
https://www.ibm.com/mx-es/topics/computer-
vision
[5] Sistemas de asistencia al conductor: ¿Qué
son y cómo funcionan? (2012, 22 noviembre).
coches.net. Recuperado 7 de noviembre de 2023,
de https://www.coches.net/noticias/sistemas-ayuda-
conductor
[6]Admin. (2023, 2 octubre). [DIY] AlcoholíMetro
arduino, Sensor de alcohol MQ-3 + código. Arduino
Spain. https://arduino-spain.site/alcoholimetro-mq3/
[7]CUBIT. (2023, 31 octubre). ESP32-CAM Car
Project: Traffic Sign Detection and Control || CUBIT
[Vídeo]. YouTube.
https://www.youtube.com/watch?v=GhEA6oAf2Wc