Prototipo de Sistema de Alerta de nivel de sueño basado en ...
94
UNIVERSIDAD ANDRÉS BELLO Facultad de Ingeniería Escuela de Industrias Prototipo de Sistema de Alerta de nivel de sueño basado en medición de concentración y relajación utilizando Neurosky Mindset Tesis para optar al grado “Licenciado en Ciencias de la Ingeniería” y título “Ingeniero en Automatización y Robótica” Autor: Sergio Andrés Valenzuela Espinoza Profesor Guía: Néstor Palominos González Santiago de Chile, 2017
Transcript of Prototipo de Sistema de Alerta de nivel de sueño basado en ...
UNIVERSIDAD ANDRÉS BELLO
Facultad de Ingeniería
Escuela de Industrias
Prototipo de Sistema de Alerta de nivel de sueño basado en medición de concentración y relajación utilizando Neurosky Mindset
Tesis para optar al grado “Licenciado en Ciencias de la Ingeniería” y título
“Ingeniero en Automatización y Robótica”
Autor:
Sergio Andrés Valenzuela Espinoza
Profesor Guía: Néstor Palominos González
Santiago de Chile, 2017
1
UNIVERSIDAD ANDRÉS BELLO
Facultad de Ingeniería
Escuela de Industrias
INGENIERÍA EN AUTOMATIZACIÓN Y ROBÓTICA
DECLARACIÓN DE ORIGINALIDAD Y PROPIEDAD
Yo, Sergio Andrés Valenzuela Espinoza, declaro que este documento no
incorpora material de otros autores sin identificar debidamente la fuente.
Santiago, diciembre del 2017.
_____________________________
Firma del alumno
2
Dedicado a mi familia y a todos los que creyeron que me graduaría en menos de 7 años.
3
Agradecimientos.
Agradecimientos especiales a mis familiares que me permitieron hospedarme en
Santiago para estudiar durante todos estos años.
A mis padres por el apoyo y la paciencia.
A mis compañeros y amigos que me motivaron a graduarme.
Al profesor Néstor Palominos por su apoyo y por facilitarme las herramientas
necesarias para poder terminar este proyecto.
4
Índice General
Agradecimientos. ................................................................................................ 3 Índice de figuras. ................................................................................................. 6 Índice de tablas. .................................................................................................. 7 Resumen ............................................................................................................ 9 Abstract ............................................................................................................. 10 Antecedentes Generales .................................................................................. 11
Introducción ................................................................................................... 11 Objetivos ........................................................................................................ 13
Objetivo General ........................................................................................ 13 Objetivos Específicos ................................................................................. 14
Marco teórico .................................................................................................... 15 Neurosky ....................................................................................................... 15 Estado del arte y justificación ........................................................................ 17
Dispositivos EEG de bajo costo. ................................................................ 19 Prueba del dispositivo. ................................................................................... 20
Desarrollo del Prototipo .................................................................................... 26 Carta Gantt .................................................................................................... 26 Diagramas de la implementación .................................................................. 27
Diagrama Global ........................................................................................ 27 Diagrama GPS ........................................................................................... 28 Diagrama Lector RFID................................................................................ 29 Diagrama de flujo de la implementación .................................................... 30
Selección de Hardware .................................................................................. 31 Raspberry PI 3 ........................................................................................... 31 GPS ............................................................................................................ 33 Módulo 3G .................................................................................................. 34 Lector RFID ................................................................................................ 34
5
Fuente de energía ...................................................................................... 35 Buzzer de alarma ....................................................................................... 35 Pantalla ...................................................................................................... 36
Etapa de Software ......................................................................................... 37 Preparación de Raspberry PI ..................................................................... 37 Configuración de Raspberry PI .................................................................. 38 Desarrollo del código del prototipo ............................................................. 45
Algoritmo de monitoreo de fatiga ............................................................ 45 Obtención de coordenadas del GPS ....................................................... 48 Lectura ID por RFID ................................................................................ 50
Muestreo de datos ...................................................................................... 52 Conexión a Microsoft Azure .................................................................... 52
Ingreso al Portal ................................................................................... 53 Creación de Recursos ......................................................................... 54
Configuración base de datos. ................................................................. 56 Creación de tablas. .............................................................................. 56 Prueba base de datos. ......................................................................... 58
Dashboard .............................................................................................. 61 Streaming de datos. ............................................................................. 62
Armado del código final .............................................................................. 69 Viabilidad económica ........................................................................................ 71 Pruebas de validación y análisis. ...................................................................... 73
Prueba básica. ............................................................................................... 73 Prueba de funcionamiento ............................................................................. 78
Verificando alarma alta. .............................................................................. 78 Verificando alarma critica. .......................................................................... 80
Análisis de resultados. ................................................................................... 82 Conclusiones .................................................................................................... 83 Bibliografía ........................................................................................................ 84 Anexos .............................................................................................................. 86
6
Código del prototipo....................................................................................... 86 Dashboard de monitoreo ............................................................................... 91 Especificaciones dispositivo NeuroSky MindWave utilizado .......................... 93
Índice de figuras.
Figura 1:Datos de accidentados entre 2012 y 2016. [Conacet, 2017] .............. 11 Figura 2:Partes del Neurosky Mindset. ............................................................. 16 Figura 3:Sistema de detección de fatiga basado en procesamiento de imágenes. ......................................................................................................... 19 Figura 4:Neurosky Dongle RF y layout. ............................................................ 21 Figura 5:ID del Neurosky ubicado al lado de la batería. ................................... 22 Figura 6: Datos entregados por el Neurosky en consola. ................................. 25 Figura 7: Diagrama Global. ............................................................................... 27 Figura 8: Conexión entre Raspberry pi y GPS. ................................................. 28 Figura 9: Conexión entre Raspberry pi y lector RFID. ...................................... 29 Figura 10: Diagrama de flujo. ............................................................................ 30 Figura 11: Componentes Raspberry Pi 3. ......................................................... 31 Figura 12: Pinout puertos GPIO Raspberry Pi. ................................................. 32 Figura 13: Modulo GPS GY-GPS6MV2. ........................................................... 33 Figura 14: Modem Huawei E173. ...................................................................... 34 Figura 15: Pinout RFID-RC522. ........................................................................ 34 Figura 16: Adaptador USB para automóvil. ...................................................... 35 Figura 17: Buzzer piezo-eléctrico. ..................................................................... 35 Figura 18: Pantalla LCD. ................................................................................... 36 Figura 19: : Página de descarga. [RASPBERRY PI FOUNDATION, 2017]. ..... 37 Figura 20: Instalación de ROM en micro SD. [Sourceforge, 2017] .................. 38 Figura 21: Archivo config.txt modificado. .......................................................... 39 Figura 22: Archivo cmdline.txt modificado. ....................................................... 40 Figura 23: Consola de configuración de Raspberry pi. ..................................... 41 Figura 24: Selección de características a habilitar. ........................................... 42 Figura 25: Prueba de librería pyodbc. ............................................................... 43 Figura 26: Comunicación serial con el GPS. .................................................... 44 Figura 27: Datos de Atención y Relajación obtenidos. ...................................... 45 Figura 28: Pseudo código de funcionamiento del algoritmo. ............................ 47 Figura 29: Lectura de latitud y longitud en la consola. ...................................... 49 Figura 30: Lectura del TAG ID en consola. ....................................................... 51
7
Figura 31: Logo Azure. [Microsoft, Logo Azure, 2017] ...................................... 52 Figura 32: Login del Portal de Azure. ................................................................ 53 Figura 33:: Menú de recursos de Azure. ........................................................... 54 Figura 34: Creación Base de datos SQL. ......................................................... 55 Figura 35: Conexión a base de datos Azure. .................................................... 56 Figura 36: Creación de tablas en la base de datos. .......................................... 57 Figura 37: Mensaje Código de prueba de base de datos SQL. ........................ 59 Figura 38: Valores obtenidos de la base de datos SQL por Query. .................. 60 Figura 39: Dashboard Power BI. [Microsoft, Power BI, 2017]. .......................... 61 Figura 40: Selección de API en Power BI. ........................................................ 62 Figura 41: Configuración de variables y URL de la API. ................................... 63 Figura 42: Respuesta de recepción de datos. .................................................. 65 Figura 43: Menú de creación de Dashboards. .................................................. 66 Figura 44: Selección de la fuente de datos. ...................................................... 67 Figura 45: Muestra de datos obtenidos por Streaming. .................................... 68 Figura 46: Script ejecutado al inicio de sistema. ............................................... 70 Figura 47: Tamaño de base de datos después del experimento. ..................... 74 Figura 48: Tabla de datos obtenida usando Power BI. ..................................... 75 Figura 49: Trayecto realizado mostrado en Power BI. ...................................... 76 Figura 50: Valores de atención y relajación de la prueba. ................................ 77 Figura 51: Alarmas de estado alto a través del viaje. ....................................... 78 Figura 52: Puntos de alarma alta en la carretera. ............................................. 79 Figura 53: Valores de relajación y atención en nivel alto de alerta. .................. 79 Figura 54: Alarmas de estado critico a través del viaje. .................................... 80 Figura 55: Puntos de alarma critica en la carretera. ......................................... 81 Figura 56: Valores de relajación y atención en nivel crítico de alerta. .............. 81
Índice de tablas.
Tabla 1: Bytes utilizados por el Neurosky para comunicarse. ........................... 22 Tabla 2: Carta Gantt ......................................................................................... 26 Tabla 3: Lista de componentes. ........................................................................ 72
8
9
Resumen
El siguiente proyecto se presenta como un prototipo experimental para un
sistema de monitoreo en tiempo real de la actividad cerebral de conductores con
el fin de detectar el nivel de sueño y atención en la ruta durante la conducción de
un vehículo, como por ejemplo buses o camiones.
Dicho sistema se llevará a cabo obteniendo los valores del estado de atención y
relajación del conductor mediante el sensor Neurosky con la función de registrar
las señales EEG.
El sistema se encargará de estimar el nivel de sueño del conductor en base a los
niveles de atención y relajación y las veces que parpadea en cierto tiempo, al
llegar a un nivel preocupante el sistema emitirá una pequeña alarma y alertará al
conductor de la situación, de la misma forma, al llegar a un estado crítico de
sueño el sistema emitirá una alarma a mayor nivel y sugerirá al conductor
descansar antes de seguir con su trabajo.
El prototipo contará con el microcomputador Raspberry Pi en el control que se
encargará de procesar los datos del Neurosky y además de enviar los datos
obtenidos además de las coordenadas de GPS a un servidor mediante una red
3G para el monitoreo remoto y verificación de estado del conductor.
Las pruebas del prototipo se llevaron a cabo realizando un trayecto en vehículo
por la ruta 5 Sur entre San Carlos, Ñuble y Santiago, con casi 400 Km de ruta y
más de 4 horas de viaje para verificar si se activan las alarmas correspondientes
y si el sistema es capaz de registrar todos los datos necesarios durante el viaje.
Los resultados arrojaron los valores de alerta alta y baja correspondientes,
además de que creo un registro completo de todos los datos obtenidos en el
trayecto, salvo por pequeños problemas de comunicación con la base de datos
por problemas de señal en la carretera.
Palabras Clave: Neurosky, EEG, Monitoreo, Conductor, Sueño.
10
Abstract
The following project is presented as an experimental prototype for a system of
real-time monitoring of the brain activity of drivers in order to detect the level of
sleep and attention on the route during the driving of a vehicle, whether buses or
trucks.
Said system will be carried out by obtaining the values of the driver's attention and
relaxation state by means of the Neurosky sensor with the function of registering
the EEG signals.
The system will be responsible for estimating the level of sleep of the driver based
on the levels of attention and relaxation and the times that blink at a certain time,
when reaching a worrying level the system will emit a small alarm and alert the
driver of the situation, In the same way, upon reaching a critical state of sleep, the
system will issue an alarm at a higher level and suggest the driver rest before
continuing with his work.
The prototype will have the Raspberry Pi microcomputer in the control that will be
responsible for processing the Neurosky data and in addition to sending, the data
obtained in addition to the GPS coordinates to a server through a 3G network for
remote monitoring and verification of driver status.
The tests of the prototype were carried out making a vehicle trip on “Ruta 5
Sur”between San Carlos, Ñuble and Santiago, with almost 400 km of route and
more than 4 hours of travel to verify if the corresponding alarms are activated and
if the system is able to record all the necessary data during the trip.
The results showed the corresponding high and low alert values, as well as
creating a complete record of all the data obtained in the journey, except for small
communication problems with the database due to signal problems on the road.
Keywords: Neurosky, EEG, Monitoring, Conductor, Sleep.
11
Antecedentes Generales
Introducción
Durante la mayoría de los largos viajes por la carretera, los conductores pueden
verse afectados por la pérdida de atención, los cuales pueden encontrarse con
problemas de sueño y el resultado de esto puede llevar a los accidentes de
tránsito. Los conductores distraídos no pueden observar el flujo del tráfico y las
señales de tránsito y los accidentes ocurren a causa de esto, además ir hablando
por teléfono, así también el ir comiendo o la fatiga y la somnolencia de los largos
trayectos en carretera plantean una posibilidad de generar accidentes.
Según los datos de Conaset, el año 2016 se registraron un total de 854
accidentes a causa de fatiga, cansancio o sueño, dejando un total de 29 fallecidos
y más de 800 lesionados, sin contar con los daños materiales provocados a causa
de los accidentes.
Figura 1: Datos de accidentados entre 2012 y 2016. [Conacet, 2017]
12
Con el pasar de los años y con la modernización de los automóviles las empresas
han ido desarrollando diversos sistemas de monitoreo para prevenir los
accidentes de tránsito, estos se enfocan principalmente en la detección de la pista
por donde va el vehículo y las señales de tránsito mediante cámaras y visión
artificial donde también se comenzó hace un par de años este método para
detectar la fatiga y somnolencia en los conductores mediante el monitoreo de las
expresiones faciales y el parpadeo de este.
Un método prometedor es el uso de las señales registradas de los electrodos del
cuero cabelludo que miden patrones de actividad eléctrica cambiante en el
cerebro mientras que alguien va de un estado del estado de alerta completo a la
fatiga ya la somnolencia. El proceso de registro de estas señales se conoce como
electroencefalografía (EEG).
A lo largo de los años la electroencefalografía ha sido un procedimiento realizado
específicamente en las clínicas u hospitales, sin embargo, estos dispositivos de
EEG de grado médico no son prácticos para la detección diaria de somnolencia
del conductor, ya que requieren el uso de equipos costosos y la preparación
complicada de la piel con gel conductor para un monitoreo eficaz.
Recientemente han salido al mercado dispositivos como Emotiv Epoc+ EEG
(Milton, 2009) y el MindFlex (Neurosky, MindFlex, 2009) que detectan simples
señales de EEG , y han sido diseñados con fines de entretenimiento. Ambos
dispositivos utilizan un solo “electrodo seco” para registrar la potencia de la señal
EEG en bandas de frecuencia seleccionadas. Esto difiere del EEG de grado
médico que utiliza electrodos múltiples, unidos con gel conductor y adhesivo,
para registrar la potencia de la señal del EEG en múltiples lugares a lo largo del
cuero cabelludo del sujeto. Junto con los dispositivos EEG como el Mind Flex, los
13
fabricantes también ofrecen auriculares EEG de bajo costo que son cómodos y
compactos. Estos ofrecen una capacidad de grabación de EEG muy limitada,
pero son sencillos y baratos, requiriendo mínimo entrenamiento especializado.
Esto los convierte en un objetivo atractivo para los esfuerzos de investigación en
sistemas eficaces de detección de la somnolencia del conductor mediante EEG.
Uno de estos auriculares EEG de bajo costo es el NeuroSky Mindset.
El NeuroSky Mindset [Neurosky, Neurosky Mindwave, 2010] usado en esta tesis,
es un dispositivo con conexión RF con un solo electrodo de sensor. Estos
dispositivos no tienen la precisión de un EEG clínico, sin embargo, pueden
detectar patrones generales en la actividad cerebral. Estos dispositivos son
pequeños y baratos. Su tamaño y el uso general de los sensores secos los hace
más prácticos que los equipos de EEG clínicos para la detección de la
somnolencia del conductor.
Objetivos
Con el fin de desarrollar y probar el sistema descrito anteriormente, se
implementaran los siguientes objetivos:
Objetivo General
Desarrollar un prototipo de sistema de proceso de ondas cerebrales adquiridas
con el casco Neurosky Mindset que detecte el estado de atención y relajación
de un conductor y evitar eventuales accidentes ocasionados por la fatiga o por el
desvío de atención al volante, enviando alertas al conductor, así como, crear un
servidor de monitoreo remoto sobre el conductor y su estado
14
Objetivos Específicos
- Generar un enlace entre la Raspberry Pi y el Neurosky mediante un
módulo RF.
- Desarrollar un algoritmo basado en la obtención de datos del EEG que sea
capaz de mostrar los datos de atención y relajación en Linux.
- Crear una base de datos que registre los valores de atención y relajación.
- Implementar una alarma para los niveles de estado de alerta y estado
crítico de los niveles de sueño del conductor.
- Crear un sistema que identifique al usuario mediante un TAG RFID.
- Conectar la Raspberry Pi con un módulo GPS y 3G.
- Generar un servidor que administre los datos recolectados y las
coordenadas GPS para que sea accesible en la web para su monitoreo
remoto.
- Desarrollar pruebas del prototipo recorriendo una autopista y obteniendo
muestras de más de 100 km de recorrido.
15
Marco teórico
Neurosky
Neurosky Mindset utiliza la tecnología RF para enviar datos al host de hardware
para su análisis. Dado que el dispositivo utiliza un sensor seco, no requiere
solución salina o gel para asegurar una conectividad adecuada con la superficie
de la frente y señales de EEG sin ruido. El contacto con el electrodo de sensor
seco se consigue por la presión del electrodo contra la frente del sujeto y se
mantiene en su lugar por el auricular. Tiene filtros patentados para eliminar el
ruido del movimiento muscular y la interferencia eléctrica. También incluye un
filtro de muesca para eliminar el ruido de 60 Hz de una fuente de alimentación.
Dado que no hay cables que unen el electrodo a un dispositivo de análisis, la
interferencia debida a la longitud del hilo del electrodo se reduce
considerablemente.
El Neurosky Mindset puede muestrear datos en hasta 512 muestras por segundo
(Neurosky, Recorder log files format, 2014). Además de los datos de EEG sin
procesar, el Mindset puede procesar ondas delta (0.5 - 2.75Hz), theta (3.5 -
6.75Hz), low alpha (7.5 - 9.25Hz), high alfa (10 - 11.75Hz), low beta 13 - 16,75
Hz), high beta (18 - 29,75 Hz), low gamma (31 - 39,75 Hz) y media gamma (41 -
49,75 Hz), así como resistencia al parpadeo. También permite procesar los
niveles de atención y meditación que están destinadas a identificar cuando un
sujeto está prestando atención o está relajado. Estas señales de atención y
meditación se crean utilizando datos de las otras bandas de frecuencias (por
ejemplo, alfa, beta, gamma, etc.). Estas señales no son señales estándar de EEG,
y no representan bandas de frecuencia específicas.
16
El casco para funciona necesita solamente una batería de 1.5 volts, lo que le da
una autonomía de aproximadamente 8 horas. Su peso es de 80 g, lo que lo hace
un dispositivo liviano y fácil de llevar puesto durante mucho tiempo y cuenta con
dimensiones de 225 mm de alto x 155 mm de ancho x 92mm de largo.
Figura 2: Partes del Neurosky Mindset.
17
Estado del arte y justificación
A la fecha existen diversos sistemas comerciales que pueden detectar cambios
en los patrones de conducción de los conductores que presentan un estado de
fatiga o somnolencia, como el Ford Driver Alert (Ford Motor Company, 2011), el
Mercedes Attention Assist (Mercedes Benz, 2008) o el Volkswagen Driver Alert
System (Volkswagen, 2012). Cada uno de estos sistemas monitorea los cambios
en la conducción mostrados por los conductores somnolientos como movimientos
bruscos de la dirección o la deriva fuera de carriles. Cuando esto ocurre, se
produce una advertencia audible y visual. El sistema de alerta de conductor de
Ford incluso incluye escenarios en los que, si la advertencia se ignora durante
demasiado tiempo, sólo se puede interrumpir deteniendo y saliendo del coche. El
sistema danés "Anti Sleep Pilot" (Coxworth, 2011) no solo monitorea los patrones
de conducción, sino que requiere que el conductor empuje un botón en el
dispositivo lo más rápido posible cuando se indique para verificar que el tiempo
de respuesta del conductor es adecuado.
Otros sistemas como el Eyetracker de Fraunhofer (Fraunhofer Institute, 2010) o
el Sistema de Monitoreo de Conductor de Toyota (Williams, 2008) monitorean los
ojos del conductor para confirmar que están mirando la carretera. El conductor
puede ser advertido si no está mirando la carretera cuando un obstáculo está por
delante. El conductor también es advertido si sus ojos se cierran por un período
de tiempo.
Cada uno de estos sistemas tiene sus pros y sus contras. Los sistemas de
detección de conducción erráticos pueden controlar todas las formas de
conducción errática, que incluye la conducción distraída. Su desventaja es un
tiempo de respuesta lento para que por el momento la conducción se ha vuelto
errática; Puede ser demasiado tarde para evitar que ocurra un accidente. Los
sistemas de monitoreo del conductor tienen el potencial de detectar la
18
somnolencia del conductor antes de que ocurra un accidente, pero dependen de
poder monitorear los ojos del conductor para determinar si están abiertos.
Para aplicaciones en el mundo real, la luz del sol puede interferir con la
iluminación infrarroja, las reflexiones de los anteojos pueden crear puntos
brillantes confusos cerca de los ojos y las gafas de sol tienden a alterar la luz
infrarroja y hacer que las pupilas parezcan muy débiles. Un dispositivo basado
en EEG puede ser capaz de detectar el inicio del sueño antes de que la
conducción errática haya comenzado, y tiene el beneficio adicional de no requerir
una visión sin obstáculos de los ojos del conductor (Yanchao Dong, Zhencheng
Hu, Keiichi Uchimura, & Nobuki Murayama, 2011).
El año 2016 se mostró en Chile un dispositivo detector de sueño en choferes
mediante reconocimiento facial que estaba enfocado en el parpadeo y las
expresiones del conductor para determinar su estado de sueño (GPSTEC, 2016).
El dispositivo es confiable pero muy limitado en la precisión y exactitud del
sistema de visión utilizado para determinar el cierre del ojo al parpadear, además
de alertar al momento de que el conductor ya está dormido, siendo ya demasiado
tarde para prevenir accidentes.
19
Figura 3: Sistema de detección de fatiga basado en procesamiento de imágenes. [GPSTEC, 2016].
Dispositivos EEG de bajo costo.
Los dispositivos EEG de bajo coste no han estado en el mercado durante mucho
tiempo y relativamente poca investigación se ha hecho sobre ellos. En la mayoría
de los casos, estos dispositivos EEG de bajo coste demostraron ser sustitutos
adecuados para los dispositivos de EEG de grado médico para cierto análisis de
señal de bajo nivel. Dado que suelen tener menos sensores que el equipo de
grado médico, no hacen un buen trabajo de localización de señales específicas
dentro del cerebro.
En una prueba con un dispositivo EEG de bajo costo (Crowley, Sliney, Pitt, &
Murphy, 2010), se realizaron dos pruebas psicológicas para inducir el estrés y
correlacionar los resultados con las señales de meditación y de meditación
registradas en la Neurosky Mindset. Al confiar en las tendencias de la señal,
fueron capaces de detectar cuándo cambiaron las emociones de un sujeto. En
20
otra prueba, se recogió datos de múltiples bio-sensores, incluyendo un Neurosky
Mindset, y comparó su capacidad para evaluar la carga cognitiva. La señal de
atención del dispositivo se le dio una clasificación de tercer mejor predictor de
alta carga cognitiva después de flujo de calor y electrocardiograma (ECG) a
través de los experimentos cognitivos realizados.
Prueba del dispositivo.
Un problema a la hora de desarrollar el algoritmo de control y monitoreo fue el
escaso soporte del modelo RF de Neurosky en la plataforma Linux, ya que la
mayoría de las librerías existentes dan soporte al modelo por bluetooth.
Para resolver este problema se procedió a crear una librería utilizando el manual
del dongle RF proporcionado para página oficial de Neurosky [Neurosky,
Neurosky Developers, 2011].
Dado que la comunicación se basa principalmente en el envío y recepción de un
par de bytes como comandos AT entre el dongle y el Neurosky a través de un
puerto serial, se espera que el canal de comunicación sea fiable. Por lo tanto, los
comandos no requerirán bytes de sincronización o un checksum.
21
Figura 4: Neurosky Dongle RF y layout.
Lo primero para proceder con la parte de la conexión del dispositivo es conocer
el “Global Headset ID”, que es Un ID único de 2 bytes que está programado en
cada módulo de auricular. Esto permite 65536 identificadores únicos de
auriculares globales, lo que reduce la posibilidad de que los dos auriculares
utilizados al mismo tiempo en una ubicación determinada tengan el mismo ID.
22
Figura 5: ID del Neurosky ubicado al lado de la batería.
Luego de ubicar el ID del dispositivo y utilizando una librería publicada por Alan
Thomas [Thomas, 2012], se procedió a declarar los bytes para realizar la
comunicación entre los dispositivos, los cuales son:
Tabla 1: Bytes utilizados por el Neurosky para comunicarse.
23
# Byte codes
CONNECT = '\xc0'
DISCONNECT = '\xc1'
AUTOCONNECT = '\xc2'
SYNC = '\xaa'
EXCODE = '\x55'
POOR_SIGNAL = '\x02'
ATTENTION = '\x04'
MEDITATION = '\x05'
BLINK = '\x16'
HEADSET_CONNECTED = '\xd0'
HEADSET_NOT_FOUND = '\xd1'
HEADSET_DISCONNECTED = '\xd2'
REQUEST_DENIED = '\xd3'
STANDBY_SCAN = '\xd4'
RAW_VALUE = '\x80'
# Status codes
STATUS_CONNECTED = 'connected'
STATUS_SCANNING = 'scanning'
STATUS_STANDBY = 'standby'
Bytes declarados en la librería de Python.
24
Teniendo ya lista la librería se procedió a crear un pequeño código para probar
el funcionamiento de este midiendo los niveles de atención y relajación para así
proceder al desarrollo del algoritmo de monitoreo de conductores.
import mindwave, time
headset = mindwave.Headset('/dev/ttyUSB0', 'DC40')
time.sleep(2)
headset.connect()
print "Conectando..."
while headset.status != 'connected':
time.sleep(0.5)
if headset.status == 'standby':
headset.connect()
print "Volviendo a conectar..."
print "Conectado!."
while True:
time.sleep(.5)
a = headset.attention
m = headset.meditation
print "Atencion: %s, Meditacion: %s" % (headset.attention, headset.meditation)
if a < 30 and m > 70:
print "Alerta"
if a < 10 and m < 90:
print "Critico"
Código de ejemplo.
25
Al ejecutar el código de ejemplo se pudo observar en la consola que
efectivamente el casco Neurosky entregaba los valores de meditación y
relajación entre los rangos de 0 como mínimo y 100 como máximo, por lo que al
verificar su funcionamiento se procede a la creación del prototipo y se finaliza la
fase de investigación.
Figura 6: Datos entregados por el Neurosky en consola.
26
Desarrollo del Prototipo
Carta Gantt
Mes - Semana Abril Mayo Junio Julio
Actividad / Semana 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16
Definición de proyecto y bibliografía
Estructuración formal de contenidos
Justificación y planteamiento de Objetivos
Organización formal de proyecto
Investigación Marco Teórico
Mes - Semana Agosto Septiembre Octubre Noviembre
Actividad / Semana 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
Desarrollo de Software
Conexión de módulos y pruebas de
funcionamiento
Pruebas de respuesta y validación
Análisis de resultados y conclusiones
Cierre formal y entrega
Tabla 2: Carta Gantt
27
Diagramas de la implementación
Diagrama Global
El casco Neurosky se conectará directamente a la Raspberry Pi 3 mediante un
dongle RF instalado en un puerto USB de esta última. A su vez la Raspberry Pi
también ira conectada a un módulo GPS mediante comunicación serial mediante
el uso de los pines TX y RX.
Para la fuente de alimentación de la Raspberry Pi se utilizará un adaptador USB
para el automóvil, y a su vez esta alimentará a los demás periféricos como el
dongle RF y el módulo GPS. Cabe destacar que el casco Neurosky se alimenta
por una pila de 1.5 v, por lo que no es necesario realizar un cableado adicional
para alimentarlo.
Figura 7: Diagrama Global.
28
Diagrama GPS
El modulo GPS usara el puerto serial GPIO de la Raspberry pi (/dev/ttyAMA0),
en los cuales se usarán los puertos de 3.3 volts, RX, TX y GROUND.
Figura 8: Conexión entre Raspberry pi y GPS.
29
Diagrama Lector RFID
Este módulo se comunica a través de SPI, por lo cual es necesario utilizar los
pines MISO,MOSI, SDA ,SCK y un pin RST necesario del módulo.
También necesitara de los pines de alimentación de 3.3 volts GND.
Figura 9: Conexión entre Raspberry pi y lector RFID.
30
Diagrama de flujo de la implementación
Al encender el vehículo, también comenzará a trabajar la Raspberry pi que
procederá a solicitar al conductor que se autentifique mediante una tarjeta RFID
que se utilizará para tener un registro del chofer y su actividad al volante.
Al autentificarse el conductor, inmediatamente comenzara a correr el programa
de censado de la actividad cerebral. Cuando el sistema detecte perdida de
atención o un alto nivel de relajación, este comenzara a emitir alertas visuales y
sonoras al conductor para que retome la atención en la pista o se detenga a
descansar.
Como se tienen los datos de la actividad cerebral del chofer y su identificación
mediante la tarjeta RFID, es posible enviar sus datos a un servidor para que
desde un lugar remoto se pueda monitorear su actividad.
Figura 10: Diagrama de flujo.
31
Selección de Hardware
Al seleccionar el hardware a utilizar en este proyecto se pensó en la eficiencia
del mismo y los precios no muy elevados, además de la fácil accesibilidad para
el usuario común. A continuación, se describen los componentes utilizados.
Raspberry PI 3
La Raspberry PI es una pequeña placa que aloja un chip Broadcom BCM2835
con un procesador ARM de hasta 1.2 GHz de velocidad. Su bajo precio y tamaño
reducido la hacen perfecta para realizar proyectos en dispositivos móviles.
Figura 11: Componentes Raspberry Pi 3.
32
Además de los puertos USB de la Raspberry pi también se utilizarán los pines
GPIO para la comunicación con dispositivos por medio del protocolo serial.
Figura 12: Pinout puertos GPIO Raspberry Pi.
33
GPS
El modulo utilizado para obtener las coordenadas GPS será el modelo “GY-
GPS6MV2” que se comunicará a la Raspberry PI. El modelo se alimenta con 3.3
volts y se comunica por protocolo serial a 9600 baudios.
El uso de este modelo se debe a su bajo costo, de no más de $10.000 pesos y a
su gran efectividad al momento de obtener los datos de localización por GPS.
Figura 13: Modulo GPS GY-GPS6MV2.
34
Módulo 3G
Para la conectividad se utilizó el modem “Huawei E173”, el cual al contar con una
SIM 3G será el medio por el cual se transmitirán los datos al servidor.
Figura 14: Modem Huawei E173.
Lector RFID
Para el proceso de autentificación se utilizará el lector RFID “RC522” el cual
utiliza un sistema de modulación y demodulación de 13.56MHz, frecuencia que
en la actualidad utiliza la tecnología RFID. Tiene la capacidad de leer y grabar
datos en las tarjetas RFID al acercarse a una distancia de no más de 10
centímetros. Se alimente con 3.3 volts y se comunica por medio del protocolo SPI
(Serial Peripheral Interface).
Figura 15: Pinout RFID-RC522.
35
Fuente de energía
El prototipo al ir dentro del vehículo solo será necesario alimentarlo por USB
mediante el puerto del encendedor con un adaptador genérico, el cual entregará
un voltaje de 5 volts y una corriente de salida de 2.1 Amperes.
Figura 16: Adaptador USB para automóvil.
Buzzer de alarma
Para emitir el sonido de alarma solo será necesario utilizar un buzzer piezo-
eléctrico genérico de 5 volts.
Figura 17: Buzzer piezo-eléctrico.
36
Pantalla
Para el muestreo de datos en la cabina se utilizará una pantalla LCD touch
genérica de 5”. Esta pantalla se alimenta con 5 volts.
Figura 18: Pantalla LCD.
37
Etapa de Software
Preparación de Raspberry PI
Al comenzar a trabajar con la Raspberry Pi lo primero a hacer es cargar el sistema
operativo a la tarjeta de memoria. La ROM utilizada para esta Raspberry pi fue
Raspbian, ya que viene optimizada para su trabajo en Raspberry pi.
Figura 19: : Página de descarga. [RASPBERRY PI FOUNDATION, 2017].
Lo siguiente después de descargar la rom es grabarla en una memoria micro sd
para poder bootear el sistema operativo desde esta, para lo cual se utiliza el
programa “Win32DiskImager” para realizar este proceso.
38
Figura 20: Instalación de ROM en micro SD. [Sourceforge, 2017]
Configuración de Raspberry PI
Luego de iniciar el sistema se observa un problema recurrente al momento de
iniciar la Raspberry pi por primera vez, y este es que el puerto serial de los pines
GPIO, que se utilizara para el GPS, está inutilizable debido a un conflicto con el
modulo bluetooth que utiliza el mismo puerto.
Este problema se soluciona modificando 2 archivos: cmdline.txt y config.txt.
Para modificar cmdline.txt lo primero es ingresar en la terminal y escribir el
siguiente comando indicando la ruta del archivo:
sudo nano /boot/config.txt
Al modificar este archivo se debe agregar las siguientes líneas:
- “dtoverlay=pi3-disable-bt-overlay”
- “enable_uart=1”
- “dtoverlay=pi3-miniuart-bt”
39
Figura 21: Archivo config.txt modificado.
De la misma forma se procede a modificar el archivo cmdline.txt con el siguiente
comando:
sudo nano /boot/cmdline.txt
En este archivo se elimina la línea “console=serial0,115200”, dejando el archivo
de la siguiente manera:
40
Figura 22: Archivo cmdline.txt modificado.
Al tener los 2 archivos modificados es necesario ingresar a la consola
nuevamente e ingresar el siguiente comando para habilitar la comunicación serial
y de paso también se activará la comunicación del protocolo SPI que utilizará el
lector RFID.
sudo raspi-config
41
Este comando es utilizado para ingresar a la consola de configuración de la
Raspberry pi, permitiendo habilitar y deshabilitar módulos, cambiar hora,
contraseña, entre otras cosas. Para habilitar las características de serial y SPI
hay que dirigirse a la opción 5 “Interfacing Options”, que es la cual permite
configurar la conexión entre los módulos y los periféricos.
Figura 23: Consola de configuración de Raspberry pi.
42
Aparecerán un numero de opciones a lo cual se deberá seleccionar las
requeridas y habilitarlas para su uso.
Figura 24: Selección de características a habilitar.
Luego se necesita reiniciar para que los cambios hagan efecto con el siguiente
comando:
sudo reboot
Al reiniciar la Raspberry pi esta ya está lista para usar los periféricos necesarios.
Lo siguiente es instalar los programas y librerías necesarias para realizar el
software.
43
Lo primero a instalar es MySQL, ya que será necesario para trabajar con las
bases de datos que manejará el sistema. Para instalar MySQL se ingresa en
siguiente comando en la consola:
sudo apt-get install mysql-server mysql-client php5-mysql
Como se trabajará con bases de datos por medio de un script en Python también
será necesario instalar la librería de MySQL para Python con el siguiente
comando:
sudo pip install pyodbc
Para verificar que la instalación de la librería se realizó de forma correcta, basta
con ingresar a la consola de Python e importar la librería y visualizando que no
entrega ningún error se concluye que la instalación no presento errores.
Figura 25: Prueba de librería pyodbc.
44
Otra librería necesaria es la que se utilizara para obtener las coordenadas del
GPS, por lo cual se instalara con el siguiente comando:
sudo pip install pynmea2
Cabe destacar el comando “pip”( Pip Installs Packages) es un sistema de gestión
de paquetes que se utiliza para instalar paquetes destinados a Python de manera
fácil y rápida.
Luego de conectar el modulo GPS y habiendo habilitando el puerto serie de las
entradas GPIO se procede a realizar una prueba de la librería.
Al hacer correr un simple script de lectura serial se puede verificar la
comunicación con el modulo GPS, por lo que ya está listo para su trabajo.
Figura 26: Comunicación serial con el GPS.
45
Desarrollo del código del prototipo
Algoritmo de monitoreo de fatiga
Antes de partir con el desarrollo del algoritmo en sí, previamente fue necesario
realizar pruebas en personas con el fin de tratar de obtener algún patrón o señal
que diera indicios de fatiga o somnolencia.
Para esto se registraron los niveles de atención y relajación de una persona por
10 minutos mientras debía observar un video de un recorrido en carretera.
Figura 27: Datos de Atención y Relajación obtenidos.
Al revisar los resultados se pudo observar que cuando la persona presentaba
valores de atención inferior a 30 y relajación mayor a 75 eran los momentos en
que esta presentaba algún tipo de distracción o desvío de atención de lo que
estaba realizando, por lo que se intentara crear un sistema de alarmas basado
en esos valores obtenidos como una alerta crítica y unos valores un poco más
bajos para una alarma alta.
46
Según un estudio realizado en 2008 (García, y otros, 2008), se observaba que
durante el estado de somnolencia la persona realizaba un parpadeo menos
regular. Sabiendo eso es posible mejorar el sistema de monitoreo, ya que el
casco Neurosky también permite obtener la intensidad y frecuencia del parpadeo
de una persona.
Según un artículo, una persona en estado normal parpadea cada 3 segundos,
danto un total de entre 15 o 20 parpadeos por minuto. [Salazar, 2015].
Sabiendo todo esto, se propone realizar un algoritmo básico de predicción de
niveles de sueño utilizando los parámetros anteriormente estudiados:
47
Figura 28: Esquema de funcionamiento del algoritmo.
48
Obtención de coordenadas del GPS
Al utilizar la librería “pynmea2” se simplifica la tarea de obtener las coordenadas
de latitud y longitud, ya que por lo general es necesario descomponer los valores
de la trama “GPRMC” que entrega el GPS y dividir por 60 los decimales de latitud
y longitud para obtener los valores correctos.
Para obtener los valores de latitud y longitud con la librería se empleará el
siguiente código:
import serial
import pynmea2
ser = serial.Serial('/dev/ttyAMA0',9600)
while 1:
data = ser.readline()
if (data.startswith("$GPRMC")):
msg = pynmea2.parse(data)
print("latitud", msg.latitude)
print("longitud", msg.longitude )
Código de obtención de coordenadas GPS.
49
Con el uso de la librería al se realiza una lectura al puerto serial donde está
conectado el modulo GPS y al recibir la lectura de la trama “$GPRMC” este
decodificara los valores de latitud y longitud.
Figura 29: Lectura de latitud y longitud en la consola.
Como se puede observar en la imagen anterior se obtienen los valores de latitud
y longitud ya transformados para utilizarlos en algún visualizador de mapas.
50
Lectura ID por RFID
Para poder utilizar el módulo RC552 primero es necesario instalar la librería
publicada por Mario Gómez [Gómez, 2014]. Esta librería permite obtener el TAG
ID de la tarjeta RFID además de leer todos los sectores de memoria de esta, de
la misma manera también se puede realizar grabado de información en dichos
sectores con la misma librería.
Para este prototipo solo es necesario realizar la lectura del TAG ID para realizar
la identificación de un conductor, por lo que el código necesario para esto es el
siguiente:
import RPi.GPIO as GPIO
import MFRC522
continue_reading = True
def end_read(signal,frame):
global continue_reading
continue_reading = False
signal.signal(signal.SIGINT, end_read)
MIFAREReader = MFRC522.MFRC522()
while continue_reading:
(status,TagType) = MIFAREReader.MFRC522_Request(MIFAREReader.PICC_REQIDL)
if status == MIFAREReader.MI_OK:
print "Tarjeta detectada"
(status,uid) = MIFAREReader.MFRC522_Anticoll()
if status == MIFAREReader.MI_OK:
print "ID Tarjeta:
"+str(uid[0])+","+str(uid[1])+","+str(uid[2])+","+str(uid[3])
Código de lectura TAG ID.
51
Figura 30: Lectura del TAG ID en consola.
Cabe señalar que este prototipo tiene pensado 2 tipos de consumidores finales:
el usuario común y la empresa para el monitoreo de sus conductores, como
conductores de transportes, minería y servicio de buses.
Esta función de lectura del TAG ID está orientada como usuario a alguna
empresa, para así poder tener un registro de qué conductor se está monitoreando.
52
Muestreo de datos
Conexión a Microsoft Azure
Azure es una plataforma de Microsoft basada en el sistema Cloud. Proporciona
servicios tales como computación, analítica, almacenamiento, redes e
implementación de máquinas virtuales. Dicha plataforma está enfocada hacia
empresas o desarrolladores que utilizan esta plataforma para la gestión y
respaldo de datos, así también como para el desarrollo de aplicaciones web y
móviles.
Figura 31: Logo Azure. [Microsoft, Logo Azure, 2017]
Esta plataforma será utilizada para el almacenamiento de los datos obtenidos por
la Raspberry pi. Esto se realizará mediante el uso de un servidor SQL creado
dentro de la plataforma y que se vinculará con el prototipo a través del código en
Python de una manera sencilla.
53
Ingreso al Portal
Para poder hacer uso de los servicios de la plataforma es necesario registrarse.
La plataforma es de acceso público, pero para utilizar los recursos como la
creación de bases de datos y máquinas virtuales es necesario parar una
suscripción.
Otra manera de utilizar los servicios es por medio de correos de instituciones
como colegios o universidades. Para este proyecto se utilizará el correo
institucional proporcionado por la universidad.
Al ingresar el correo en el portal de Azure, este inmediatamente re direccionara
a la página del portal de la universidad para ingresar las credenciales de
autentificación.
Figura 32: Login del Portal de Azure.
54
Creación de Recursos
Una vez ingresado al portal, lo siguiente es crear el servidor SQL y la base de
datos para su uso. Esto se hace seleccionado el botón “New” en el extremo
superior izquierdo y posteriormente seleccionando SQL Database”
Figura 33:: Menú de recursos de Azure.
55
Como se está haciendo uso de una “cuenta estudiantil” no todas las funciones
de Azure estarán disponibles, pero para el desarrollo de este prototipo
solamente será necesario utilizar el servicio de servidor SQL.
Al seleccionar la opción “SQL Database” se nos pedirá un nombre para la base
datos así también como la creación y configuración del servidor.
Figura 34: Creación Base de datos SQL.
56
Configuración base de datos.
Creación de tablas.
Después de tener creados el servidor y la base de datos, lo siguiente a realizar
será la creación de las tablas donde irán siendo archivados los valores que se
vallan obteniendo.
Para la creación de tablas se utilizará el programa “Microsoft SQL Server
Management Studio (SSMS)” que es una herramienta grafica gratuita para la
administración de bases de datos SQL.
Para conectarse a la base de datos de Azure en necesario utilizar los valores con
los que se crearon el servidor SQL como nombre del servidor, nombre de usuario
y contraseña.
Figura 35: Conexión a base de datos Azure.
57
Una vez habiéndose conectado con el servidor SQL habrá que dirigirse a la
sección de la base de datos creada, en este caso la base de datos “Neuro”, y en
la opción de tablas hacer doble click y crear una nueva tabla.
Una vez creada la tabla se procederá a agregar los valores y el tipo de dato que
se enviará desde la Raspberry pi hacia el servidor.
Figura 36: Creación de tablas en la base de datos.
58
Como tipo de dato para todas las variables se utilizó “nvarchar” ya que este
permite el ingreso de caracteres UNICODE, esto quiere decir que se puede
ingresar casi cualquier carácter de cualquier idioma, previniendo así que
entregue valores nulos seleccionando cualquier otro tipo de datos en concreto
que entre en conflicto con un tipo de numero o letra.
Prueba base de datos.
Para realizar la prueba del funcionamiento de la base de datos se utilizará la
librería “pyodbc” previamente instalada. La principal característica de esta librería,
al ser distribuida por Microsoft, es que permite conectarse a base de datos de
“Microsoft SQL” cosa que la mayoría de otras librerías rechazan la conexión.
Para la prueba se utilizará un código de ejemplo que rellenará datos en la tabla
anteriormente creada.
import pyodbc, time
from datetime import datetime
id = 5555111
con = 64
rel = 42
lat = -31.455
long = -70.145
now = datetime.strftime(datetime.now(), "%Y-%m-%dT%H:%M:%S%Z")
alarma = 'alarma baja'
con =
pyodbc.connect("DRIVER={FreeTDS};SERVER=datosneuro.database.windows.net;PORT=14
33;DATABASE=Neuro;UID=admin1234;PWD=Password;TDS_Version=8.0;")
cursor = conn.cursor()
59
print("Base de datos conectada")
cursor.execute("insert into Prototipo(ID, Atencion, Relajacion, Latitud,
Longitud, Fecha, Alarma) values (?, ?, ?, ? , ?, ?, ?)",id, con, rel, lat, long,
now, alarma)
print("Datos registrados Correctamente")
conn.commit()
Código de prueba base de datos SQL.
Este código insertara datos puestos al azar simulando ser los valores que se
obtendrán directamente del prototipo final.
Al correr el código en consola esta entrega el siguiente mensaje:
Figura 37: Mensaje Código de prueba de base de datos SQL.
Habiendo obtenido el mensaje de que los datos se registraron correctamente, lo
siguiente es verificar la base de datos para ver si efectivamente se agregaron
datos y que estos no presenten problemas en su formato.
60
Para obtener los datos de la tabla hay que volver al programa “Microsoft SQL
Server Management Studio” y seleccionar la opción “New Query” o apretar “CTRL
+ N” para realizar un query o pregunta a la base de datos.
Para obtener los datos mediante un query se ingresa el siguiente comando:
SELECT * FROM dbo.Prototipo
Al ingresar el comando el programa entregará las columnas de la tabla junto con
los valores ingresados en el código, por lo que se verifica que todo funciona
correctamente.
Figura 38: Valores obtenidos de la base de datos SQL por Query.
Teniendo ya en funcionamiento el servidor SQL lo siguiente será crear un
Dashboard que estará vinculado con el servidor y al que será posible conectarse
de manera remota para poder monitorear los datos en tiempo real.
61
Dashboard
Para poder visualizar los datos de manera remota se dispondrá de un dashboard,
que es una interfaz que representa ciertos datos de manera gráfica e interactiva
para una mejor administración de la información.
Para crear el Dashboard de este proyecto se utilizará “Power BI”, que es una
herramienta de Microsoft orientada al análisis empresarial de datos para la
creación de reportes e informes con un alto detalle grafico que además se
publican directamente en una web. Se decidió utilizar esta herramienta ya que se
puede conectar de manera directa con la base de datos SQL de Azure además
de monitorear los datos más importantes como lo son la atención y la relajación
en tiempo real.
Figura 39: Dashboard Power BI. [Microsoft, Power BI, 2017].
Otro dato por el cual también se optó por usar Power BI es que, al igual que Azure
al ser de Microsoft, utilizando el correo institucional de la universidad se puede
utilizar todos los servicios sin necesidad de pagar por subscripciones.
62
Streaming de datos.
Una de las maneras en la que se utilizara Power BI será mediante el streaming
de los datos de manera directa desde la Raspberry pi, utilizando la API “REST”
que utiliza el protocolo HTTP para enviar datos directamente ya sea en formato
XML o JSON.
Para utilizar la API hay que ingresar al portal de Power BI y en la sección de “My
Workspace”, seleccionar “Create” en el extremo superior derecho; donde se
desplegaran 4 opciones y habrá que seleccionar “Streaming dataset” y
posteriormente se mostrara la opción “API” que se utilizará.
Figura 40: Selección de API en Power BI.
Luego de eso se lo siguiente será configurar el conjunto de datos, indicando las
variables y tipo de datos que se transmitirán desde la Raspberry pi hacia Power
BI. Una vez terminado eso, el programa entregará una URL la cual será la
dirección hacia donde se enviarán los datos
63
Figura 41: Configuración de variables y URL de la API.
Una vez obtenida la URL, lo siguiente será proceder escribiendo el código que
realice la comunicación entre la Raspberry pi y Power BI para el streaming de los
datos.
64
El código utilizado para el envío de datos utilizando la API
es el siguiente:
import urllib, urllib2, time
from datetime import datetime
id = 5555111
con = 64
rel = 42
lat = -31.455
long = -70.145
now = datetime.strftime(datetime.now(), "%Y-%m-%dT%H:%M:%S%Z")
alarma = 'alarma baja'
REST_API_URL = "https://api.powerbi.com/beta/6fd48f41-af81-45a5-9c1e-
e3990bc27e7c/datasets/a1e03590-2aba-40f0-85b4-
18f04fe93222/rows?key=hpBrVKYsprzpots63GBl1zzLsreXI9ZPzfokisTLxgfNQMfxTKhebNc3%
2BkCYgBhBw8eH23SYQMasoSSkUzkaLw%3D%3D"
while True:
try:
data = '[{{ "ID": "{0}", "Atencio": "{1}", "Relajacion": "{2}",
"Latitud": "{3}", "Longitud": "{4}","Fecha": "{5}", "Alarma":
"{6}" }}]'.format(id, con, rel, lat, long, now, alarma)
req = urllib2.Request(REST_API_URL, data)
response = urllib2.urlopen(req)
print("POST request to Power BI with data:{0}".format(data))
print("Response: HTTP {0} {1}\n".format(response.getcode(),
response.read()))
65
time.sleep(1)
except urllib2.HTTPError as e:
print("HTTP Error: {0} - {1}".format(e.code, e.reason))
except urllib2.URLError as e:
print("URL Error: {0}".format(e.reason))
except Exception as e:
print("General Exception: {0}".format(e))
Código del streaming de datos hacia Power BI.
Para hacer correr este código también se utilizaron variables de ejemplo para su
prueba. Al momento de realizar un envió de datos de manera exitosa, la consola
muestra el mensaje de respuesta “HTTP 200”, que es el mensaje que indica la
respuesta estándar para peticiones correctas y dando a conocer que el código
funciona.
Figura 42: Respuesta de recepción de datos.
66
Lo siguiente es observar en la plataforma de Power BI los datos que están siendo
transmitidos, para lo que hay que dirigirse al workspace y crear un nuevo
Dashboard para su visualización.
Figura 43: Menú de creación de Dashboards.
Una vez creado el Dashboard habrá que seleccionar la fuente de datos, por lo
que habrá que seleccionar “Add title” y posteriormente seleccionar “Custom
Streaming Data” y seleccionar el conjunto de datos creado anteriormente.
67
Figura 44: Selección de la fuente de datos.
Luego de seleccionar el conjunto de datos y las variables a mostrar se puede
obtener un Dashboard simple en el cual se muestran las variables de atención y
68
relajación necesarias para una simple prueba, por lo que la parte del streaming
de datos del proyecto está funcionando perfectamente.
Figura 45: Muestra de datos obtenidos por Streaming.
69
Armado del código final
Después de realizar las pruebas de todo el código por separado, lo siguiente será
juntar todas las partes en un único script capaz de realizar todas las funciones ya
probadas.
El código final realizara una transmisión de datos en paralelo directamente hacia
la API de Power BI y a la base de datos SQL de Microsoft Azure para tener un
backup de los datos y revisarlos al momento que sea.
El sistema comenzará la transmisión de datos al momento de que el módulo RFID
detecte una tarjeta y sin que esta sea removida, ya que la tarjeta corresponde al
ID del conductor. Si la tarjeta es removida el sistema emitirá una alerta y no se
iniciará hasta que se introduzca la tarjeta nuevamente.
También se necesitará que el código comience al momento de que se encienda
la Raspberry pi, por lo que será necesario crear un archivo ejecutable con formato
“.sh” y agregarlo a la ruta de inicio automático de la Raspberry. En el caso de la
versión del sistema operativo utilizado la ruta será la siguiente:
/home/pi/.config/lxsession/LXDE-pi
El archivo ejecutable deberá incluir el siguiente código:
#!/bin/sh
lxterminal -e sudo python /home/pi/EEG-Driver.py
$SHELL
70
El comando “lxterminal” corresponde a la consola de Linux que utiliza esta versión
de la Raspberry pi y el “-e” significa que ejecutara en consola la siguiente
operación de le sigue, en este caso, iniciar el código del prototipo.
La line “$SHELL” es utilizada para que al momento de iniciarse el código la
ventana de la consola no se cierre y continúe realizando el muestreo en primer
plano.
Luego de crear el archivo habrá que darle los derechos necesarios para que el
sistema operativo lo reconozca como un ejecutable, para lo cual se utiliza el
siguiente comando:
sudo chmod 755 /home/pi/.config/lxsession/LXDE-pi/EEG.SH
Teniendo todo listo solo falta modificar el archivo “autostart” ubicado en la misma
carpeta y agregar al final del archivo el siguiente comando para iniciar el script:
@sh /home/pi/.config/lxsession/LXDE-pi/EEG.sh
Al guardar el archivo y reiniciar se puede ver que el script ahora se inicia de forma
automática cuando el sistema inicia el escritorio.
Figura 46: Script ejecutado al inicio de sistema.
71
Viabilidad económica
Al tratarse de un prototipo que trata de llegar a un gran número de usuarios como
los del mundo automovilístico, se trató de desarrollar un sistema de bajo costo y
con módulos y componentes disponibles en el mercado.
Los módulos como el lector RFID, GPS y el Neurosky fueron importados
directamente dese China para abaratar costos.
La placa Raspberry pi, tarjeta SD y cables se consiguieron en tiendas de Santiago
a un bajo costo.
A continuación, se mostrará una tabla con la cantidad de materiales y sus
respectivos precios en dólares (USD) para tener una referencia internacional
considerando los módulos que se importaron.
No se considerarán en la tabla los precios de los programas utilizados, ya que la
mayoría fueron de uso libre y para otros se utilizó la cuenta de estudiante de la
universidad para obtener uso gratuito de estos.
72
Item Cantidad Precio unitario ($USD)
Precio total ($USD)
Neurosky
Mindset
1 $116 $116
Raspberry PI 1 $50 $50
Módulo RFID 1 $4 $4
GPS 1 $5,7 $5,7
Módulo 3G/4G 1 $23,10 $23,10
Memoria Micro
SD
1 $9,5 $9,5
Buzzer 1 $1,5 $1,5
Pantalla 1 $40 $40
Cables varios --- $10 $10
Total $259,8
Tabla 3: Lista de componentes.
73
Pruebas de validación y análisis.
Las pruebas de campo se realizaron en un vehículo particular moviéndose por la
ruta 5 sur, moviéndose desde San Carlos, Ñuble hasta Santiago.
Se realizaron 2 tipos de pruebas, la prueba básica se centraba en verificar que el
sistema fuera grabando los datos obtenidos continuamente sin ningún tipo de
errores, y la prueba de funcionamiento en la que se verificaba si el algoritmo
llevaba a cabo las alertas correspondientes en base a los estados de atención y
relajación.
Prueba básica.
Al momento de hacer el grabado de los datos y del muestreo en la Raspberry pi
se utilizó un tiempo de segundos entre cada dato para no saturar la base SQL y
la Raspberry pi. Utilizando ese tiempo de muestreo realizado sobre un viaje de
alrededor de 4 horas se obtuvieron un total de 1068 columnas de datos.
Una de las principales preocupaciones antes de realizar las pruebas era sobre el
tamaño de los registros obtenidos y si la base de datos sería capaz de soportarlos,
ya que solo se contaban con 32 MB para esta prueba, pero al revisar el tamaño
final después de las pruebas se observe que con 5 horas de muestreo continuo
solamente se utilizó un 18.8% total, con lo que se estima que el sistema puede
funcionar de forma continua con un mínimo de 15 horas seguidas sin interrupción.
74
Figura 47: Tamaño de base de datos después del experimento.
Para visualizar los datos obtenidos se utilizó Power BI, ya que además de poder
observar la base de datos también se pueden graficar los valores para una mayor
comprensión.
75
Figura 48: Tabla de datos obtenida usando Power BI.
76
Como se pudo observar en la figura anterior, al tener las coordenadas de latitud
y longitud es posible graficar el trayecto recorrido por lo que se utilizó la opción
de mapeo de Power Bi para verificar que las coordenadas concuerden con las
del trayecto realizado.
Figura 49: Trayecto realizado mostrado en Power BI.
77
Lo último a verificar es si los valores de atención y relajación los legibles y
concuerdan con los rangos de 0 a 100 que entregaba el Neurosky por medio de
la librería, para lo que en Power BI se procederá a graficar los datos en base a
las horas de los registros para ver si hay concordancia.
Figura 50: Valores de atención y relajación de la prueba.
Al observar los datos se pueden ver unos espacios en los que se interrumpe la
transmisión de datos y se concluyó que corresponden a fallas de señal del
módulo 3G cuando se desplazaba por la carretera. En total se contabilizaron 8
errores de este tipo, pero no supone un problema para el sistema en tiempo real,
ya que esto solo corresponde a los datos que se almacenan en la base de datos
SQL para su análisis y el sistema en si continúa corriendo en tiempo real.
78
Prueba de funcionamiento
Luego de realizar las pruebas básicas lo siguiente es verificar si se generaron las
alertas correspondientes de los estados de sueño, para lo que se filtrarán los
valores de las columnas para poder observar mejor los resultados.
Verificando alarma alta.
Al observar la tabla filtrada se observa que se obtuvieron 41 alarmas de estado
alto a través de todo el viaje.
Figura 51: Alarmas de estado alto a través del viaje.
79
Al poner los datos sobre un mapa se puede determinar los lugares donde se
produjeron las alarmas
Figura 52: Puntos de alarma alta en la carretera.
También al sobreponer los valores de atención y relajación en un gráfico se
puede observar la relación entre el aumento de la relajación y el descenso de la
atención.
Figura 53: Valores de relajación y atención en nivel alto de alerta.
80
Verificando alarma critica.
Al igual que como se hizo con los eventos de alarma alta se procedió a filtrar los
datos en base a las alarmas de estado alto, con lo cual se obtuvieron 19 alarmas.
Figura 54: Alarmas de estado critico a través del viaje.
Al poner los datos sobre un mapa de observan los sectores en carretera donde
ocurrieron las alarmas de estado crítico.
81
Figura 55: Puntos de alarma critica en la carretera.
También graficando los valores de atención y relajación se pudieron obtener los
siguientes gráficos donde se relaciona el aumento de relajación y el descenso
de atención en los eventos de alarma critica.
Figura 56: Valores de relajación y atención en nivel crítico de alerta.
82
Análisis de resultados.
Los resultados de las pruebas muestran que en determinadas condiciones hay
problemas con la comunicación a la base de datos, ya que por diversas zonas de
la carretera el módulo 3G perdía la señal y los datos no eran subidos
correctamente al servidor generando espacios vacíos entre la trama de datos.
Dejando de lado el tema de las pequeñas interrupciones por perdida de señal se
observo una continuidad en el registro de los datos, sin generar valores aleatorios
o erróneos, con lo que se determinó que, mejorando los temas de comunicación,
el sistema de bases de datos de Azure es óptimo para el trabajo realizado
Con respecto al análisis de los datos se observó que el algoritmo generaba las
alertas en base a los rangos de señal esperados sin arrojar falsas alarmas y
acordes al estado apreciable visualmente del conductor.
En general el sistema en si cumplió con las expectativas de rendimiento
esperadas y los objetivos propuestos con anterioridad.
83
Conclusiones
A partir de lo observado en el desarrollo de este prototipo se deduce que el uso
de dispositivos EEG como el Neurosky Mindset puede ser utilizado para detectar
la somnolencia de un conductor. Aun con solo contar con 1 electrodo para realizar
el censado el dispositivo.
Sobre el tema de las bases de datos y las plataformas de Microsoft, como lo son
Azure y Power BI, estas demostraron una robustez absoluta al momento de
administrar los datos sin presentar demora alguna mientras se procesaban y
almacenaban los datos para su muestreo.
Respecto a la perdida de señal en túneles, se puede mejorar el proyecto
considerando un sistema de almacenamiento local que funcione en paralelo y
que rellene las ventanas faltantes de información.
El proyecto en sí es escalable a futuro, pudiéndose mejorar características como
el algoritmo de detección de sueño, ya que con un estudio más exhaustivo se
podría detectar los patrones de somnolencia analizando las ondas cerebrales
directamente con otro casco que posea más electrodos y permita un mejor
análisis. También a futuro será posible crear una interfaz de usuario más
“amigable” al conductor y abordar otros medios de conectividad para no tener un
delay considerable o perdida de comunicación con los datos.
84
Bibliografía
Coxworth, B. (2011). Anti Sleep Pilot detects drowsy drivers. Obtenido de
http://newatlas.com/anti-sleep-pilot-monitors-driver-fatigue/17439/
Crowley, K., Sliney, A., Pitt, I., & Murphy, D. (2010). Evaluating a Brain-
Computer Interface to Categorise Human Emotional Response.
Ford Motor Company. (2011). Ford Driver Alert. Obtenido de
http://www.tch.co.uk/about/why-choose-ford/lane-keeping-aid/
Fraunhofer Institute. (2010). Eyetracker System Monitor. Obtenido de
https://www.fraunhofer.de/en/press/research-news/2010/10/eye-tracker-
driver-drowsiness.html
García, J., Rogado, E., Barea,, R., Bergasa,, L., López, E., Ocaña, M., &
Schleicher, D. (2008). Sistema detector de fatiga en la conducción.
Gómez, M. (2014). MFRC522-python. Obtenido de
https://github.com/mxgxw/MFRC522-python
GPSTEC. (2016). GPSTEC. Obtenido de http://gpstec.cl/sistema-detector-de-
somnolencia-para-la-mineria-en-chile/
Mercedes Benz. (2008). Attention Assist. Obtenido de
https://techcenter.mercedes-benz.com/es_ES/attention_assist/detail.html
Microsoft. (2017). Logo Azure.
Microsoft. (2017). Power BI. Obtenido de https://powerbi.microsoft.com
Milton, U. (2009). Force Trainer. Obtenido de
http://starwarsscience.com//#/the_force_trainer/%20Uncle%20Milton
85
Neurosky. (2009). MindFlex. Obtenido de
https://store.neurosky.com/products/mindflex
Neurosky. (2010). Neurosky Mindwave. Obtenido de
https://store.neurosky.com/pages/mindwave
Neurosky. (2011). Neurosky Developers. Obtenido de
http://developer.neurosky.com/docs/lib/exe/fetch.php?media=app_notes:
mindwave_rf_external.pdf
Neurosky. (2014). Recorder log files format. Obtenido de
http://support.neurosky.com/kb/applications/recorder-log-files-format
RASPBERRY PI FOUNDATION. (2017). Centro de descarga Raspbian.
Obtenido de https://www.raspberrypi.org/downloads/raspbian/
Salazar, K. H. (2015). ¿Cuántas veces parpadea una persona por minuto?
Obtenido de
http://www.laprensalibre.cr/Noticias/detalle/42907/414/cuantas-veces-
parpadea-una-persona-por-minuto
Sourceforge. (2017). Win32DiskImager. Obtenido de
https://sourceforge.net/projects/win32diskimager/
Thomas, A. C. (2012). GitHub. Obtenido de
https://github.com/BarkleyUS/mindwave-python
Volkswagen. (2012). Driver Alert Sistem. Obtenido de
http://www.volkswagen.co.uk/technology/car-saftey/driver-alert-system
Williams, M. (2008). PCWorld. Obtenido de Toyota Cars to Monitor Driver’s
Eyes for Safety: http://www.pcworld.com/article/141603/article.html
Yanchao Dong, Zhencheng Hu, Keiichi Uchimura, & Nobuki Murayama. (2011).
Driver Inattention Monitoring System for.
86
Anexos
Código del prototipo
#!/usr/bin/env python
#!/usr/bin/python
# -*- coding: utf8 -*-
# Se declaran las librerias.
import mindwave, time, serial
import urllib, urllib2
from datetime import datetime
import pyodbc
import pynmea2
import subprocess
import RPi.GPIO as GPIO
import MFRC522
import signal
# Se declaran los pines 14 y 15 GPIO como TX0 y RX0 respectivanmente.
bashCommand1= "raspi-gpio set 14 a0 "
output = subprocess.check_output(['bash','-c', bashCommand1])
bashCommand2= "raspi-gpio set 15 a0 "
output = subprocess.check_output(['bash','-c', bashCommand2])
87
# Se configuran las variables del lector RFID.
continue_reading = True
def end_read(signal,frame):
global continue_reading
continue_reading = False
GPIO.cleanup()
signal.signal(signal.SIGINT, end_read)
MIFAREReader = MFRC522.MFRC522()
# Se declara el puerto serial del GPS.
ser = serial.Serial('/dev/ttyAMA0',9600)
# Se declara el Dongle RF y el casco Neurosky.
headset = mindwave.Headset('/dev/ttyUSB0', 'DC40')
time.sleep(0.5)
alarma= ''
# Se declara el Link al API de Power Bi para su visualizacion en tiempo real.
REST_API_URL = "https://api.powerbi.com/beta/6fd48f41-af81-45a5-9c1e-
e3990bc27e7c/datasets/a1e03590-2aba-40f0-85b4-
18f04fe93222/rows?key=hpBrVKYsprzpots63GBl1zzLsreXI9ZPzfokisTLxgfNQMfxTKhebNc3%
2BkCYgBhBw8eH23SYQMasoSSkUzkaLw%3D%3D"
#Se inicia la conexion al módulo RF
headset.connect()
print("Conectando...")
while headset.status != 'connected':
time.sleep(0.5)
if headset.status == 'standby':
headset.connect()
print("Volviendo a conectar...")
88
print("Conectado!.")
# Se ejecutará el programa mientras de detecte una tarjeta RFID.
while continue_reading:
# Se escanea la tarjeta
(status,TagType) = MIFAREReader.MFRC522_Request(MIFAREReader.PICC_REQIDL)
# Se obtiene el Tag ID de la tarjeta.
(status,uid) = MIFAREReader.MFRC522_Anticoll()
# Si se tiene el tag, continua.
if status == MIFAREReader.MI_OK:
id = str(uid[0])+","+str(uid[1])+","+str(uid[2])+","+str(uid[3])
# Se escanea el GPS y si encuentra la trama "GPRMC" continua con el
codigo.
gprmc = ser.readline()
if (gprmc.startswith("$GPRMC")):
try:
# Se obtienen las variables como latitud, longitud,
atencion y relajacion e intencidad de parpadeo.
msg = pynmea2.parse(gprmc)
lat = msg.latitude
long = msg.longitude
now = datetime.strftime(datetime.now(),
"%Y-%m-%dT%H:%M:%S%Z")
xa = headset.attention
xm = headset.meditation
xb = headset.blink
89
# Se crea un contador de parpadeos.
conP = 0
# Si se detecta un parpadeo con intencidad entre 25 a 100
el contador aumenta.
if xb >= 25 and <= 100:
conP = conP + 1
# Se crea un reset para que cada 60 segundos el contador
de parpadeo vuelva a 0.
reset = time.time() + 60
while time.time() < endtime:
conP = 0
# Basandose en los valores sensados se declaran las
alarmas.
if xa <= 40 and xm >= 65 and conP < 15:
alarma = "Estado Alto"
if xa <= 30 and xm >= 70 and conP < 15:
alarma = "Estado Crítico"
# Se envian los datos via streaming a Power BI.
data = '[{{ "ID": "{0}", "Atencion": "{1}", "Relajacion":
"{2}", "Latitud": "{3}", "Longitud": "{4}","Fecha": "{5}", "Alarma":
"{6}" }}]'.format(id, xa, xm, lat, long, now, alarma)
# Se inicia la comunicacion con la base de datos SQL de
Azure y se envian los datos para guardarlos en las tablas.
conn =
pyodbc.connect("DRIVER={FreeTDS};SERVER=datosneuro.database.windows.net;PORT=14
33;DATABASE=Neuro;UID=admin1234;PWD=password;TDS_Version=8.0;")
cursor = conn.cursor()
print("Base de datos conectada")
90
cursor.execute("insert into Prototipo(ID, Atencion,
Relajacion, Latitud, Longitud, Fecha, Alarma) values
(?, ?, ?, ? , ?, ?, ?)",id, xa, xm, lat, long, now, alarma)
conn.commit()
# Se configura en formato en el que se enviaran los datos a
Power BI.
req = urllib2.Request(REST_API_URL, data)
response = urllib2.urlopen(req)
print("POST request to Power BI with data:{0}".format(data))
print("Response: HTTP {0} {1}\n".format(response.getcode(),
response.read()))
# Excepciones en caso de errores de transmicion de datos.
time.sleep(1)
except urllib2.HTTPError as e:
print("HTTP Error: {0} - {1}".format(e.code, e.reason))
except urllib2.URLError as e:
print("URL Error: {0}".format(e.reason))
except Exception as e:
print("General Exception: {0}".format(e))
# Si no encuentra la tarjeta o detecta un tag invalido envia una alerta.
else:
print "Inserte Tarjeta"
91
Dashboard de monitoreo
92
93
Especificaciones dispositivo NeuroSky MindWave utilizado
(Neurosky, Neurosky Developers, 2011)
