INFRACCION. Detector de excesos de velocidad de vehículos

Construya una “detector de velocidad” que use inteligencia artificial para identificar vehículos, un sensor de radar para medir la velocidad y un módulo celular para reportar datos a la nube.

Historia

Para mi familia, uno de los efectos secundarios positivos de vivir a través de una pandemia global fue la creación de actividades para llenar el vacío que normalmente ocupan las prácticas de fútbol y las reuniones de Mujers Scouts.

Sí, en realidad tuvimos que interactuar entre nosotros.

Entonces nos enfocamos en caminar. Mucho. Hicimos viajes arbitrarios como dejar el auto para mantenimiento y regresar a casa por la ciudad (un viaje más largo con niños llorones por vecindarios que nunca había visitado antes).

Así, para disgusto de mis hijos, comenzó nuestro regimiento de paseos familiares por el barrio. Lo que mis hijos llaman cariñosamente “marchas de la muerte”.

Sin embargo, una cosa que comencé a notar fue la conducción imprudente en algunas calles del vecindario. Con multitudes de personas en situaciones similares, caminando y cruzando intersecciones concurridas, pensé que sería genial dejar de asumir comportamientos imprudentes al conducir y comenzar a medir la frecuencia de exceso de velocidad en algunas carreteras cercanas.

¡Así que hice algo al respecto!

Este tutorial cubre la construcción de una “trampa de velocidad” portátil que utiliza el aprendizaje automático para identificar vehículos, un sensor de radar Doppler para medir la velocidad y un módulo celular para reportar datos a la nube.

No pretendía identificar automóviles individuales o capturar números de matrículas, sino más bien agregar datos que la ciudad podría usar para planificar los esfuerzos de mitigación del tráfico.

Montaje de una trampa de velocidad

Al comenzar un nuevo proyecto, sigo vagamente el consejo de Alec Baldwin de su infame escena en Glengarry Glen Ross:

SIEMPRE. SER. CLAUSURA. O … en realidad, una especie de prueba que cualquier hardware o componente de servicio debe pasar:

  • ge: ¿Estoy trabajando con tecnología madura y confiable?
  • asic: ¿Son fáciles de usar las API y los ejemplos de código?
  • ost: ¿Es un precio razonable del componente?

Echemos un breve vistazo a los componentes de hardware de esta compilación y cómo se comparan con mi prueba ABC :

Raspberry Pi 4 y PiCamera

He creado algunos proyectos de Raspberry Pi recientemente , así que estaba decidido a cambiarme a una MCU de bajo consumo para este proyecto.

Para identificar vehículos, ¡por supuesto que tendría una cámara! El PiCamera Module v2 fue una elección obvia debido a su calidad, el puerto del módulo de cámara compatible en el RPi y una API fácil de usar.

Sensor de radar

Me complació encontrarme con el sensor de radar Doppler OPS243-A de OmniPreSense como una solución para determinar la velocidad de los vehículos detectados.

Este dispositivo de $ 249 ha existido durante años, proporciona una interfaz en serie y una API madura para acceder a datos de velocidad de hasta ~ 150 mph.

Pantalla simple

Dado que la Raspberry Pi se ejecutaría en un estado “sin cabeza”, quería tener algunos comentarios activos mientras funciona. Elegí usar una pantalla simple de siete segmentos para informar sobre los resultados de la inferencia y los datos de velocidad recopilados.

Datos móviles (¡y energía!)

Al hacer que un proyecto de IoT sea portátil, hay dos consideraciones principales:

  • ¿Cómo vas a alimentar esta cosa?
  • ¿Cómo vas a sacar los datos?

Para resolver el problema de energía, utilicé una batería USB-C de 30, 000 mAh. En otro proyecto, pude obtener 41 horas de tiempo de ejecución no optimizado de una Raspberry Pi con este banco de energía, que es ideal para este proyecto.

Para resolver el problema de los datos, opté por la Blues Wireless Notecard. Notecard (y su compañero Notecarrier-Pi HAT) brindan no solo acceso a datos celulares, sino también integración con el servicio en la nube Blues Wireless, Notehub.io, para transmitir de forma segura los datos recopilados a mi aplicación en la nube para fines de informes.

Poniendolo todo junto

Con todas las piezas del rompecabezas en la mano, estaba listo para comenzar mi construcción. Afortunadamente, a pesar de que hay una buena cantidad de piezas, casi todo fue plug-and-play.

Por ejemplo:

  • El módulo OPS243 se conecta al RPi a través de USB.
  • La PiCamera se conecta al puerto del módulo de cámara RPi dedicado.
  • El Notecarrier-Pi HAT se conecta a través del encabezado de 40 pines provisto.

La única excepción fue la pantalla de siete segmentos, que conecté a los encabezados de paso en el Notecarrier-Pi HAT:

Encendí la pantalla de siete segmentos a través del pin de 3.3v, conectado a tierra y los GPIO 2 y 3 en el RPi a los pines SDA y SCL respectivamente en la pantalla.

Mi versión de prueba de preproducción terminó pareciendo este lío de hardware de espagueti:

Aprendizaje automático en el borde

Sí, podría haber simplificado drásticamente este proyecto simplemente capturando la velocidad de cualquier objeto registrado por el módulo OPS243. Sin embargo, correríamos el riesgo de capturar la velocidad de las bicicletas, los corredores e incluso los animales que cruzan la calle. Sin mencionar la limitación de las capacidades futuras de hacer referencias cruzadas en los comportamientos de conducción según el tipo de vehículo, etc.

Entonces, ¿qué mejor uso del aprendizaje automático para identificar vehículos antes de rastrear la velocidad? ¡Y qué mejor momento para aprender más sobre la plataforma ML emergente, Edge Impulse!

Aquí hay una descripción general de cómo abordé el aprendizaje automático con Edge Impulse:

Basura dentro basura fuera

Si sé algo sobre el aprendizaje automático, es que sus resultados solo serán tan buenos como el modelo que proporcione.

Por ejemplo, si espera que una red neuronal pueda identificar a cualquier gato después de proporcionarle un par de imágenes de un Sphynx sin pelo, lo pasará mal.

Por lo tanto, el paso cero de la creación de un modelo ML basado en imágenes es asegurarse de tener una selección adecuada de imágenes con las que entrenar el modelo.

Como estaba tratando de identificar los vehículos que circulaban por la carretera, comencé descargando ~ 100 fotos genéricas de automóviles, camiones, camionetas y bicicletas en la carretera. Luego pasé una hora tomando algunas fotos del “mundo real” que imitan lo que mi Raspberry Pi iba a tener que procesar.

Por ejemplo:

 

Impulso de borde FTW

Edge Impulse permite a los desarrolladores de todo tipo utilizar el aprendizaje automático en dispositivos informáticos de borde de bajo consumo, sin ser un experto en ML.

Para mi propósito, necesitaba Edge Impulse para identificar uno o más objetos en un marco dado (de hecho, simplifiqué los vehículos a “automóvil” y “bicicleta”). Esto se conoce como “detección de objetos” y es un caso de uso de AA muy común.

Para comenzar con Edge Impulse, creé una cuenta gratuita y me dirigieron a crear mi primer proyecto en Edge Impulse Studio.

Configuré un nuevo proyecto eligiendo un tipo de proyecto de Imágenes y luego clasifiqué varios objetos (ya que cualquier fotograma de video podría contener uno o más vehículos):

A continuación, cargué todas las imágenes de mi vehículo en la pestaña Adquisición de datos . De forma predeterminada, Edge Impulse los segmenta automáticamente en imágenes de entrenamiento frente a imágenes de prueba (es importante asignar suficientes imágenes para probar su modelo).

Finalmente, navegué a la cola de etiquetado para asignar una etiqueta a cada objeto en cada imagen que subí. (Vea la imagen del vehículo policial de arriba para ver un ejemplo).

¡El resto del trabajo de Edge Impulse Studio fue solo apuntar y hacer clic! De hecho, en lugar de que yo siga hablando de ello, es mejor que siga las instrucciones proporcionadas en este video tutorial de Edge Impulse (está en ingles):

Cuando todo estuvo dicho y hecho, el modelo logró una puntuación de precisión del 87%. Satisfactorio para mi caso de uso y sorprendente teniendo en cuenta que solo proporcioné unas 150 imágenes para entrenar el modelo.

Uso del modelo Edge Impulse

Con la construcción del modelo Edge Impulse ML completa, llegó el momento de implementar el modelo en la Raspberry Pi.

NOTA: Edge Impulse declara explícitamente soporte solo para Raspberry Pi 4. ¡Su kilometraje puede variar si prueba esto en un modelo RPi más antiguo!

Primero, instalé Edge Impulse para Linux en el RPi con los siguientes comandos:

curl -sL https://deb.nodesource.com/setup_12.x | sudo bash –
sudo apt install -y gcc g++ make build-essential nodejs sox gstreamer1.0-tools gstreamer1.0-plugins-good gstreamer1.0-plugins-base gstreamer1.0-plugins-base-apps
npm config set user root && sudo npm install edge-impulse-linux -g –unsafe-perm

Para verificar que la instalación se realizó correctamente, ejecuté el edge-impulse-linuxcomando para iniciar sesión en Edge Impulse y registrar mi RPi como dispositivo.

A continuación, necesitaba tener instalado Edge Impulse Linux Python SDK:

sudo apt-get install libatlas-base-dev libportaudio0 libportaudio2 libportaudiocpp0 portaudio19-dev
pip3 install edge_impulse_linux -i https://pypi.python.org/simple

Con las dependencias de Edge Impulse instaladas (redoble de batería, por favor … 🥁) descargué mi archivo de modelo usando este comando:

edge-impulse-linux-runner –download model.eim

Todo el Codez de Python

Con mi hardware ensamblado y el modelo ML en su lugar, ¡era hora de escribir algo de Python!

NOTA: Si desea omitir el juego por juego, puede encontrar el proyecto de Python completo en GitHub .

Decidí segmentar mi código Python en cinco tareas discretas:

  • Utilice el modelo Edge Impulse ML para identificar un vehículo;
  • Mida inmediatamente la velocidad de ese vehículo;
  • Muestra la velocidad en la pantalla de siete segmentos;
  • Envíe el evento por celular a la nube;
  • Cree un panel de control basado en la nube para generar informes.

Veamos cómo se resolvieron estos problemas.

1. Edge Impulse con Python

Con Edge Impulse Python SDK instalado, utilizar el modelo ML no podría haber sido mucho más fácil. Al tomar prestado el código Python de muestra proporcionado por el equipo de Edge Impulse, pude armar una solución que tomaba fotogramas de video y generaba un resultado de inferencia.

Durante las pruebas, se volvió divertido ver el procesamiento, ya que se tardaba <400 ms en ejecutar cada inferencia.

Found 0 bounding boxes (383 ms.)
Found 0 bounding boxes (385 ms.)
Found 1 bounding boxes (384 ms.)

Cuando se encontró una coincidencia, las API de Edge Impulse devolvieron una variedad de elementos de datos, pero los únicos que me importaron fueron labely valueque me dicen el tipo de vehículo (es decir, automóvil vs bicicleta) y el% de confianza de la coincidencia.

Found 1 bounding boxes (377 ms.)
what is it? car – and how confident? 64

En mi caso, estaba dispuesto a apostar que un nivel de confianza> = 60% era suficiente para continuar con el siguiente paso.

2. Verifique la velocidad

En este punto, mi programa podía estar razonablemente seguro de que estaba mirando un vehículo, por lo que ahora era el momento de verificar la velocidad desde el módulo de radar doppler OPS243. Refactoricé un código Python de muestra proporcionado por el equipo de OmniPreSense para recopilar la velocidad informada por el módulo OPS243:

def ops_get_speed():
“””
capture speed reading from OPS module
“””
while True:
speed_available = False
Ops_rx_bytes = ser.readline()
Ops_rx_bytes_length = len(Ops_rx_bytes)
if Ops_rx_bytes_length != 0:
Ops_rx_str = str(Ops_rx_bytes)
if Ops_rx_str.find(‘{‘) == -1:
try:
Ops_rx_float = float(Ops_rx_bytes)
speed_available = True
except ValueError:
print(“Unable to convert to a number the string: ” + Ops_rx_str)
speed_available = False

if speed_available == True:
speed_rnd = round(Ops_rx_float)
return float(speed_rnd)

Este código simplemente informa la última lectura, que debería correlacionarse casi perfectamente en el tiempo con el vehículo identificado por el modelo ML.

Para determinar si el vehículo está acelerando o no, quería poder establecer mediante programación el límite de velocidad para cualquier calle en la que estuviera. Para hacer esto, utilicé la capacidad de variables de entorno de Notehub.io para sincronizar datos desde el servidor a mi Notecard.

Esto me permitió ajustar los límites de velocidad sobre la marcha usando solo un navegador web y Notehub.io:

Estas variables se pueden configurar por dispositivo, proyecto o flota.

3. Muestra la velocidad

Como se trataba de un RPi sin cabeza, me puse un poco nervioso de que mi Pi pudiera estar encerrado y no hacer nada en realidad . Sin embargo, al usar una pantalla simple de siete segmentos, al menos pude verificar que mi programa se estaba ejecutando, mostrando una velocidad cada vez que pasaba un automóvil.

Usando la biblioteca HT16K33 proporcionada por Adafruit, fueron solo un par de líneas de código para inicializar la pantalla:

disp_i2c = busio.I2C(board.SCL, board.SDA)
display = segments.Seg7x4(disp_i2c)

Luego, imprimir números en la pantalla simplemente significaba borrar los valores anteriores y completar los nuevos números:

display.fill(0)
display.print(speed)

4. Celular a la nube

El paso final de la codificación fue tomar estos elementos de datos acumulados y empaquetarlos para una entrega segura por celular a mi aplicación en la nube.

La Notecard de Blues Wireless lo hizo excepcionalmente simple. Como módulo celular prepago con servicio global y una API fácil de “JSON-in, JSON-out”, Notecard hace que el celular sea accesible para todos los desarrolladores.

Por ejemplo, aquí hay un ejemplo de envío de un “evento” de exceso de velocidad con Python desde Notecard al servicio Blues Wireless, Notehub.io:

rsp = note.add(nCard,
file=”speed.qo”,
body={
“timestamp”: timestamp,
“confidence”: confidence,
“lat”: lat,
“lng”: lon,
“speed”: current_speed,
“speed_limit”: speed_limit,
“is_speeding”: is_speeding
})

Notehub.io luego le permite transmitir datos de forma segura a la aplicación en la nube de su elección. Ya sea que haya invertido en AWS, Azure, Google Cloud o una de las innumerables plataformas de IoT en la nube, Notehub.io ofrece opciones de integración.

Para inicializar la Notecard, emití algunos comandos (que lo asocian con mi proyecto creado en Notehub.io):

# initialize the Blues Wireless Notecard (blues.io)
productUID = keys.PRODUCT_UID
port = I2C(“/dev/i2c-1″)
nCard = notecard.OpenI2C(port, 0, 0)

# associate Notecard with a project on Notehub.io
rsp = hub.set(nCard,
product=productUID,
mode=”periodic”,
outbound=10,
inbound=10)

Luego, cada vez que quiero enviar un evento capturado (conocido como una “Nota” en el mundo de Blues Wireless) a Notehub.io, uso la API fluida proporcionada por la biblioteca note-python para emitir el note.addcomando que se muestra arriba.

NOTA: Nuevamente, puede encontrar el proyecto Python completo en GitHub.

5. Informes basados ​​en la nube

Con los datos enviados desde mi Raspberry Pi por celular a Notehub.io, el siguiente paso fue sincronizar de forma segura estos datos con mi aplicación en la nube.

Para este proyecto, elegí Ubidots, ya que es una gran plataforma para visualizar datos de IoT de una manera de apuntar y hacer clic.

Mientras seguía el tutorial de enrutamiento de Blues Wireless Ubidots, configuré una ruta Notehub.io para entregar datos a Ubidots.

NOTA: Blues Wireless también ofrece numerosos tutoriales de enrutamiento para otras plataformas de IoT en la nube.

Dentro de Ubidots, utilicé su interfaz de usuario sencilla para agregar numerosos widgets a un solo informe de panel.

Despliegue

  • Hardware ensamblado? ✅
  • ¿Modelo de AA implementado? ✅
  • ¿Código de Python escrito? ✅
  • ¿Probar la sincronización de datos con mi nube? ✅

¡Hora del gran despliegue!

Me tomé un tiempo para limpiar mi ensamblaje de hardware para hacer la implementación un poco más hermosa:

Luego implementé el dispositivo en algunas calles del vecindario que personalmente sentí que tienen conductores que son un poco demasiado agresivos.

¿Y los resultados? Encontré lo que esperaba: un porcentaje significativo de autos a alta velocidad a pocos metros de donde frecuentan los peatones.

Notablemente:

  • El 50% de los coches iban a exceso de velocidad (calculé el “exceso de velocidad” como> = 5 mph por encima del límite de velocidad).
  • La velocidad máxima se registró en 54 mph en una zona de 30 mph. ¡Ay!
  • El automóvil promedio en realidad aceleraba a 35.45 mph.

Conclusión (más consejos y trucos)

¿En general? ¡Éxito! Gracias a la facilidad de uso de Edge Impulse, Ubidots y Notecard, tuve muy pocos problemas para configurar e implementar este proyecto.

Algunos consejos y trucos que cualquier persona que intente replicar este proyecto debería considerar:

  • Optimice su modelo de aprendizaje automático proporcionándole tantas imágenes del mundo real como sea posible.
  • Si ejecuta una Raspberry Pi “fuera de la red”, asegúrese de optimizar el uso de energía .
  • ¡Prueba, prueba, prueba! La posición de la cámara en relación con la carretera o los vehículos es fundamental.

¿Buscas algunos pasos a seguir?

Y si eres un conductor loco, ¡ten cuidado con este dispositivo en una calle cercana!

Bajar los códigos:

https://github.com/rdlauer/pispeedtrap

https://github.com/blues/note-python

Acerca de Rob Lauer 1 Article
Rob es líder de relaciones con desarrolladores en Blues Wireless (blues.io). Rob, un hacker y creador de corazón, ha pasado un tiempo como ingeniero de stack con un amor por la web abierta.

Be the first to comment

Leave a Reply

Tu dirección de correo no será publicada.


*