IoT4Car

Acerca de este proyecto

Antecedentes

Al conducir su vehículo, mirando su tablero, ¿alguna vez pensó en recolectar las lecturas del medidor y hacer algún análisis? Estos datos pueden contener tesoros ocultos. Para las personas, puede reflejar sus hábitos de conducción, puede indicarle su velocidad, su promedio de millas por galón, cuántos semáforos tiene y su tiempo de espera en cada cruce. Para las empresas, estos datos son fundamentales para el monitoreo en tiempo real en la gestión de flotas. El estado del vehículo, la distribución de la carga de trabajo, la eficiencia de la gasolina e incluso la ubicación del vehículo se pueden retroalimentar a un sistema de control central a través de la nube. Las empresas pueden utilizar el aprendizaje automático para introducir los datos en un modelo de formación para predecir el coste e incluso analizar las características del conductor. Como IoT se está extendiendo ampliamente, las aplicaciones anteriores no estarán muy lejos. Con las placas Arduino MKR, dirigidas a las aplicaciones de IoT, puede construir un dispositivo que hable con su automóvil y cargue datos telemétricos en la nube por su cuenta. ¿No es genial?

Hablar con un vehículo

Necesitamos una interfaz para acceder al sistema del vehículo. ¿Dónde podemos piratear el coche? La respuesta es la interfaz OBD-II.

¿Qué es OBD-II?

El diagnóstico a bordo (OBD) es el sistema de autodiagnóstico integrado de un vehículo, a través del cual podemos comunicarnos con nuestros automóviles. Se introdujo por primera vez en Estados Unidos en 1994 y se convirtió en un requisito en todos los vehículos estadounidenses de 1996 y posteriores. Otros países, incluidos Canadá, partes de la Unión Europea, Japón, Australia y Brasil adoptaron una legislación similar. OBD-II (segunda generación) tiene cinco protocolos de señalización, y la red de área del controlador (bus CAN) es uno de ellos. Se requiere que el bus CAN se implemente en todos los automóviles de EE. UU. Desde 2008. Hay una gran introducción de OBDII proporcionada por CSS Electronics en Youtube. En este proyecto, accederemos a los datos a través de las interfaces OBD-II de 16 pines.

Mi controlador

Arduino es una excelente plataforma para aficionados, creadores y profesionales. Tiene una variedad de tableros dirigidos a diferentes aplicaciones. Aquí utilizo la placa Arduino MKR WiFi 1000 debido a su capacidad WiFi. También puedes usar otras tablas que te gusten. Recomendaría Arduino MKR GSM 1400, simplemente porque GSM cubre áreas mucho más amplias que WiFi. Pero no te preocupes, incluso con WiFi podemos tener acceso a internet en las carreteras. Te mostraré la solución.

El tablero de interpretación

Aunque Arduino en sí tiene muchas E / S y numerosas bibliotecas, todavía necesitamos una placa que pueda traducir los protocolos OBD a un lenguaje que Arduino pueda reconocer. La placa que utilizo es la placa SparkFun OBD-II UART.

Esta placa le permite interactuar con el bus OBD-II de su automóvil. Le proporciona una interfaz en serie utilizando el conjunto de comandos ELM327 y es compatible con todos los principales estándares OBD-II, como CAN. La placa contiene un chip STN1110, que es un intérprete de OBD a UART que se puede usar para convertir mensajes entre cualquiera de los protocolos OBD-II actualmente en uso y UART.

Sin embargo, cabe señalar que la placa de interpretación tiene un voltaje de E / S de 5 V, lo que puede dañar la E / S de la placa Arduino MKR, si se conectan directamente. Arduino MKR WiFI 1000 funciona a un voltaje más bajo y su voltaje de E / S es de 3.3 V. Por lo tanto, se necesita un cambiador de nivel para convertir la señal de 5 V a 3.3 V y viceversa. A continuación se muestra la imagen del cambio de nivel que utilizo.

Conéctelo

Conectar el circuito es bastante fácil. Simplemente conecta tu Arduino MRK pin 13 Rx y pin 14 Tx, a la placa OBD-II UART Tx y pines Rx a través de la palanca de cambios de nivel. Por supuesto, debe conectar la tierra de las dos placas juntas.

Para facilitar la depuración y la demostración, también conecté una pantalla LCD 1602 a Arduino para mostrar los datos en tiempo real. El cableado de LCD a Arduino se puede encontrar en este tutorial y, por lo tanto, no se detallará aquí.

A continuación se muestra la imagen de la conexión de la placa de pruebas. Las líneas verdes son para los cables que conectan el Arduino y la placa OBD-II UART, mientras que las líneas amarillas son para los cables que conectan el Arduino y la pantalla LCD. El esquema también está disponible en el archivo adjunto.

La conexión real es un poco complicada debido al área limitada de la placa de pruebas, pero sigue el esquema anterior. Incluí el cable micro USB y ODB-II a DB9 en la imagen.

Serie1 no serie

Muy bien, es hora de programar nuestra placa Arduino MKR. Dado que mi placa Arduino MKR habla con la placa de interpretación a través de UART, no es necesario instalar bibliotecas de terceros. Enviar comandos a la placa de interpretación es simplemente como comunicarse con Serial Monitor. Lo único que quiero enfatizar es que el puerto serial asociado con el Pin 13 y el Pin 14 es Serial 1 ! Placa Arduino MKR Puerto serie se refiere a su puerto USB que se utiliza para comunicarse con su computadora. No olvide inicializar Serie 1 puerto en la función setup ().

  Serial1.begin (9600);  

Y usa Serie 1 para enviar el comando al tablero de interpretación.

  Serial1.println (mensaje);  

Mensajes

Como ves, utilizo la variable "mensaje" para almacenar los comandos. Los comandos OBD se componen de códigos hexadecimales escritos en caracteres ASCII. Los dos primeros números hexadecimales se refieren al modo de servicio que se utilizará. Hay 10 servicios de diagnóstico descritos en el último estándar OBD-II SAE J1979. Dado que estamos interesados ​​en la supervisión en tiempo real, solo usaremos 01 código para mostrar datos actuales en este proyecto.

Cualquier número hexadecimal después del modo de servicio representa el ID de parámetro (PID) para lograr funciones especiales. A continuación se muestra la captura de pantalla de los PID en el modo de servicio 01. Puede encontrar más información en Wikipedia.

En este proyecto, demostraré cómo obtener la velocidad del automóvil, las RPM del motor, el nivel de combustible y la temperatura del refrigerante del motor. Los comandos OBD para estas cuatro funciones son:

• 010D // velocidad del coche

• 010C // RPM del motor

• 012F // nivel de combustible

• 0105 // temperatura del refrigerante.

Decodifica los datos

Una vez que se envían los comandos, la placa Arduino MKR escuchará el puerto Serie 1 para cualquier respuesta. Es mejor poner un retraso de 200 ms después de enviar los comandos. Utilizo el siguiente código para recibir respuesta.

  void getResponse (void) {while (Serial1.available ()> 0) {// Comience verificando si hemos recibido el carácter de fin de mensaje ('\ r'). if (Serial1.peek () =='\ r') {// llega al final del mensaje, borra el búfer Serial inChar =Serial1.read (); rxData [rxIndex] ='\ 0'; // Restablece el índice del búfer para que el siguiente carácter vuelva al principio de la cadena rxIndex =0; } // Si no obtuvimos el final del carácter del mensaje, simplemente agregue el nuevo carácter a la cadena else {// Obtenga el nuevo carácter del puerto serial:inChar =Serial1.read (); // agregue el nuevo carácter a la cadena y aumente la variable de índice:rxData [rxIndex ++] =inChar; }}}  

La respuesta del tablero de interpretación sigue el formato

"> 1 datos de PID repetidos"

Por ejemplo, en la captura de pantalla anterior, envío "010D" para obtener la velocidad del automóvil. La respuesta es "> 1 0D 00". Los primeros 5 caracteres muestran que el automóvil recibe el comando y repite el PID 0x0D. Los dos últimos dígitos devuelven los datos de velocidad 0x00.

Luego envío "010C" para obtener las RPM del motor, la respuesta "> 1 0C" muestra el reconocimiento del comando, el dato 0x098C es 4 veces el valor de las RPM del motor en hexadecimal. 0x098C / 4 =611 dec, por lo que las RPM del motor son 611 rpm.

Después de eso, envío el comando "012F" para obtener el nivel de combustible y obtengo los datos 0x1D. El nivel de combustible se calcula como 0x1D / 255 * 100 =11% dec.

El comando final es "0105", que me da la temperatura del refrigerante 0x79. La temperatura real es 0x79 - 40 =81 grados C dec. Luego, la secuencia de comandos se repite.

Como puede ver, la línea de respuesta tiene espacios entre dos dígitos hexadecimales, y los primeros 5 dígitos simplemente repiten los comandos. Por lo tanto, los datos reales comienzan desde el sexto carácter (el primero comienza desde el índice 0).

En la programación y depuración, un monitor en serie es útil, pero cuando se trata de una aplicación real, una pantalla LCD es más portátil y cumple con los requisitos de energía de IoT. Simplemente reemplace el monitor en serie con una pantalla LCD, puede monitorear los datos de su automóvil en tiempo real. A continuación se muestra la foto del uso del proyecto en mi propio automóvil.

Nube nuestros datos

La ventaja del Arduino MKR sobre UNO es su accesibilidad a Internet. Apuntando a la aplicación de IoT, Arduino MKR hará que las industrias sean más inteligentes y conectadas. En las aplicaciones automotrices, MKR WiFi 1000 puede no ser la mejor placa ya que la señal WiFi es rara en un ambiente al aire libre, pero uso mi teléfono celular como un punto de acceso personal, por lo que no es un problema.

Hay muchas otras plataformas en la nube para almacenar, ver y postprocesar los datos. Puedes elegir lo que quieras. Usaré dweet.io y freeboard.io como ejemplo. Dweet.io proporciona una API a la que puede enviar datos. Freeboard.io tiene identificadores para tomar los datos de dweet.io y visualizarlos. Hay varios tutoriales para configurar dweet.io y freebboard.io, así que no voy a dar más detalles. Si está interesado, aquí hay algunos ejemplos, ejemplo 1, ejemplo 2.

El código de inserción de datos se muestra a continuación como una ilustración de cómo crear comandos dweet.

  void httpRequest () {client.stop (); // crea una cadena de datos para enviar a francobordo if (client.connect (server, 80)) {Serial.println ("Connected"); Cadena de datos ="POST / dweet / para / mkr1000? RPM ="; data.concat (vRPM); // cargar datos de RPM del motor.concat ("&Speed ​​="); data.concat (vSpeed); // sube los datos de velocidad del coche.concat ("&Fuel ="); data.concat (vFuel); // cargar datos de nivel de combustible.concat ("&Temp ="); data.concat (vTemp); // cargar la temperatura del refrigerante client.println (data); client.println ("Host:https://www.dweet.io"); client.println ("Conexión:cerrar"); // fin de la conexión client.println (); } else {lcd.clear (); lcd.setCursor (0,0); lcd.println ("Error de conexión"); }}  

En freeboard.io, necesitamos crear un nuevo panel, y dentro de este panel, crear una nueva fuente de datos. Vincula esta fuente de datos a tu elemento dweet.io que definiste en el código. En mi caso, es mkr1000. Crearemos un nuevo widget Gauge que usaremos para mostrar los datos. Asígnele un nombre y vincúlelo a una de nuestras variables. A continuación se muestra una captura de pantalla de mi panel de control. Muestra VELOCIDAD, RPM, NIVEL DE COMBUSTIBLE y TEMPERATURA DEL REFRIGERANTE.

Conclusión

Probé las tablas en mi propio coche y funciona bien. Estoy trabajando en el diseño de una PCB que incluya todas las funciones en un circuito integrado. Con suerte, escribiré más tutoriales en el futuro. También puedo incluir una demostración en video. Lo siento esta vez, no pude grabar videos además de conducir mi auto. ¡Y también debe tener cuidado al depurar su código mientras conduce por la calle!

La placa WiFi Arduino MKR es lo suficientemente buena para esta aplicación. Si tengo más placas, creo que podría probar la placa MKR GSM 1400. Siéntase libre de usar otros tableros de IoT con este tutorial y cuénteme sus comentarios.

Trabajar en el proyecto es divertido y educativo. Disfruto de la sensación de depurar un problema. También es un placer compartir lo que sé en la web. Gracias por leer. Avíseme si tiene alguna pregunta o comentario.

 / ** OBDII-UART-Serial versión 9 * Este programa hablará con el vehículo usando el OBDII -UART, * y mostrar los resultados en la pantalla LCD, y cargarlos en la plataforma IoT de francobordo * * Autor:zhaoshentech * Actualizado:2018-08-27 * * actualizaciones:* v3:modificó la función getResponse () para que el búfer reciba la respuesta correcta. * agregue getRPM () para obtener las RPM del motor del vehículo. * v4:agregue la función getSpeed ​​() para obtener la velocidad del vehículo * v5:agregue el módulo LCD y muestre la velocidad y las RPM en el LCD * v6:es la versión wifi * v7:es la versión sin wifi ni en serie. Elimine la inicialización en serie, * para que la placa pueda funcionar sin una computadora. * V8:es la versión sin wifi ni en serie. Agregue el nivel de combustible y la temperatura del refrigerante. * Reorganice la ubicación de la pantalla. * V9:es la versión wifi, sin serie. Velocidad de subida, RPM, nivel de combustible y temperatura del refrigerante * * Conexión del circuito LCD:* LCD RS pin a digital pin 12 * LCD Habilitar pin a digital pin 11 * LCD D4 pin a digital 5 * LCD D5 pin a digital 4 * LCD Pin D6 a pin digital 3 * Pin D7 de LCD a pin digital 2 * Pin R / W de LCD a tierra * Medidor de potencial de 10 K:* termina a + 5V y tierra * Limpiaparabrisas a pin VO de LCD (pin 3) * ///// //////////////////////////////////////////////////// ////// Relacionados con WiFi //////////////////////////////////////////// ///////////////#include#includechar ssid [] ="SU SSID WIFI"; // wifi IDchar pass [] ="TU WIFI PSWD"; // wifi passwordchar server [] ="www.dweet.io"; // francobordo y dweet Settingsunsigned long lastConnectionTime =0; // rastrear la última conexión timeconst unsigned long post postInterval =10L * 1000L; // publicar datos cada 10 segundosWiFiClient client; // Inicializa el wifi clientint status =WL_IDLE_STATUS; // el estado de la radio WiFi // incluye la biblioteca LDC # include  const int rs =12, en =11, d4 =5, d5 =4, d6 =3, d7 =2; LiquidCrystal lcd (rs, en, d4, d5, d6, d7); // Este es un búfer de caracteres que almacenará los datos del puerto serie:char rxData [20]; char rxIndex =0; char inChar =0; String message; // Variables para mantener la velocidad y los datos de RPM:int vSpeed ​​=0; int vRPM =0; int vFuel =0; int vTemp =0; void setup () {// Configure el número de columnas y filas de la pantalla LCD:lcd.begin ( 16,2); lcd.clear (); // verifica la presencia del escudo:if (WiFi.status () ==WL_NO_SHIELD) {lcd.println ("WiFi no listo"); mientras (verdadero); } // intenta conectarse a la red WiFi:while (status! =WL_CONNECTED) {lcd.clear (); lcd.setCursor (0, 0); lcd.println ("Conectando WiFi ..."); status =WiFi.begin (ssid, pass); // esperar 5 segundos para la conexión:delay (5000); } lcd.setCursor (0, 1); lcd.println ("¡Conectado!"); // Serial1 es el puerto actual para hablar con el vehículo Serial1.begin (9600); resetBuffer ();} bucle vacío () {while (status! =WL_CONNECTED) {lcd.clear (); lcd.setCursor (0,0); // Conectarse a la red Wi-Fi WPA / WPA2 Serial.println ("Conectando a Wifi"); lcd.println ("Conectar WiFi ..."); status =WiFi.begin (ssid, pass); // esperar 10 segundos por el retraso de la conexión (5000); } getSpeed ​​(); getRPM (); getFuel (); getCoolTemp (); if (millis () - lastConnectionTime> postInterval) {httpRequest (); lastConnectionTime =millis (); }} // getRPM data envía el comando "010C" al puerto Serial1 // y llama a getResponse () para recolectar los datos. Luego imprime // los datos de RPM en Serial Monitor.void getRPM (void) {message ="010C"; Serial1.println (mensaje); retraso (200); // limpia la línea actual para (int i =8; i <16; ++ i) {lcd.setCursor (i, 0); // 0 fila, i columna lcd.write (''); } lcd.setCursor (8,0); // primera fila segunda mitad en la pantalla LCD // esperar respuesta getResponse (); // La respuesta de RPM dividida por 4 da el valor correcto. vRPM =((strtol (&rxData [6], 0,16) * 256) + strtol (&rxData [9], 0,16)) / 4; lcd.print (vRPM); lcd.print ("rpm");} void getSpeed ​​(void) {mensaje ="010D"; Serial1.println (mensaje); retraso (200); // limpia la línea actual:for (int i =0; i <8; ++ i) {lcd.setCursor (i, 0); // 0 fila, i columna lcd.write (''); } lcd.setCursor (0,0); // primera fila primera mitad de la pantalla LCD // espera la respuesta del coche getResponse (); vVelocidad =strtol (&rxData [6], 0, 16); // en la unidad de km / h vSpeed ​​=vSpeed ​​* 0.621371; // en la unidad de mph lcd.print (vSpeed); lcd.print ("mph");} void getFuel (void) {mensaje ="012F"; Serial1.println (mensaje); retraso (200); // limpia la línea actual:for (int i =0; i <8; i ++) {lcd.setCursor (i, 1); // 1ª fila, i columna lcd.write (''); } lcd.setCursor (0, 1); // segunda fila primera mitad en la pantalla LCD // esperar la respuesta del coche getResponse (); vFuel =strtol (&rxData [6], 0, 16); // en la escala de 255 // vFuel =244; // depurar el uso vFuel =1.0 * vFuel / 255 * 100; // en la escala de 100 lcd.print (vFuel); lcd.print ("%"); //Serial.println(vFuel); // depurar el uso} void getCoolTemp (void) {message ="0105"; Serial1.println (mensaje); retraso (200); // limpia la línea actual:for (int i =8; i <16; i ++) {lcd.setCursor (i, 1); // 1ª fila, i columna lcd.write (''); } lcd.setCursor (8, 1); // segunda fila segunda mitad en la pantalla LCD // esperar la respuesta del coche getResponse (); vTemp =strtol (&rxData [6], 0, 16); // en la unidad de C pero con un desplazamiento de 40 grados vTemp =vTemp - 40; // compensado por 0 lcd.print (vTemp); // imprime el grado C lcd.write (0xDF); lcd.print ("C");} // La función getResponse recopila los datos entrantes de la UART en el búfer rxData // y sale cuando se transfiere la respuesta. Una vez que se detecta la cadena de retorno de carro //, el búfer rxData termina en nulo (para que podamos tratarlo como una cadena) // y el índice rxData se restablece a 0 para que se pueda copiar la siguiente cadena. ) {while (Serial1.available ()> 0) {// Comience verificando si hemos recibido el carácter de fin de mensaje ('\ r'). if (Serial1.peek () =='\ r') {// llega al final del mensaje, borra el búfer Serial inChar =Serial1.read (); rxData [rxIndex] ='\ 0'; // Restablece el índice del búfer para que el siguiente carácter vuelva al principio de la cadena rxIndex =0; } // Si no obtuvimos el final del carácter del mensaje, simplemente agregue el nuevo carácter a la cadena else {// Obtenga el nuevo carácter del puerto serial:inChar =Serial1.read (); // agregue el nuevo carácter a la cadena y aumente la variable de índice:rxData [rxIndex ++] =inChar; }}} void resetBuffer (void) {for (int i =0; i <20; i ++) {rxData [i] =0; }} void httpRequest () {client.stop (); // crea una cadena de datos para enviar a francobordo if (client.connect (server, 80)) {Serial.println ("Connected"); Cadena de datos ="POST / dweet / para / mkr1000? RPM ="; data.concat (vRPM); // cargar datos de RPM del motor.concat ("&Speed ​​="); data.concat (vSpeed); // sube los datos de velocidad del coche.concat ("&Fuel ="); data.concat (vFuel); // cargar datos de nivel de combustible.concat ("&Temp ="); data.concat (vTemp); // cargar la temperatura del refrigerante client.println (data); client.println ("Host:https://www.dweet.io"); client.println ("Conexión:cerrar"); // fin de la conexión client.println (); } else {lcd.clear (); lcd.setCursor (0,0); lcd.println ("Error de conexión"); }}