Geo6Mv2 GPS for Android

Muy buenas a todos!!!

En este Blog ya hemos visto usar el módulo NEO6MV2 GPS en dos modos diferentes, NEO6MV2 GPS serial y representando la ubicación en un programa escrito en Python y OpenStreetMaps.

Pero ahora toca salir al exterior y probar el el modulo NEO6Mv2, para esto tenemos Geo6Mv2 for Android un pequeño programa para teléfonos Android con el que nos podemos conectar vía Wifi y ver los datos recibidos en nuestro terminal Android.

Además podemos marcar los puntos que necesitemos y la misma aplicación trazará una linea entre los diferentes puntos.

Configuración de Geo6Mv2:

En su configuración podremos cambiar ciertos parámetros como:

• 
  Use Marks: Opción para usar marcadores sobre la pantalla.
• Big Icon mark: Icono de marcación grande o pequeño.
• Short Mark description: Para cambiar el titulo que aparecera en los marcadores
• Minimun distance to update: Distancia mínima a la que el sensor actualizará la posición. Ideal para mejorar la precisión entre puntos. Si la última posición es mayor a ese valor se creará un nuevo punto en el mapa.
• Custom zoom: Zoom con el que se inicia el programa y cualdo se pulse sobre el botón "Centrar.
• Show data input: Muestra en la pantalla principal los datos que recibe directamente desde el módulo NEO6MV2.
• Show coordinates with one tap: Para mostrar las coordenadas al pulsar sobre el mapa.
• Start point: Latitud y longitud en los que aparece el mapa al iniciar el programa.

También podemos copiar esas coordenadas en el portapapeles y copiarlas donde queramos. Para esto haremos una pulsación larga sobre las coordenadas que aparecen en la parte inferior de la pantalla principal:

Con una interfaz sencilla capaz de mostrar todos los datos recibidos por este sensor de posicionamiento.

La librería que se utiliza es "TinyGPSPlus.h" de Mikal. La librería TinyGPSPlus se puede descargar desde el mismo gestor de bibliotecas del que dispone el IDE de Arduino.

Con la librería instalada, descargamos el programa para el ESP8266 geo6mv2-for-android desde GitHub. En este caso la placa que vamos será un NodeMCU 1.0, aunque puede servir cualquier ESP8266 al que le podamos añadir una entrada serial extra con la librería "SoftwareSerial.h". Este es el diagrama de conexiones.

Recuerda que los pines D3(tx) y D4(rx) corresponden a los GPIO 2(tx) y 0(rx). Esto suele crear confusión a la hora de definir los pines. Revisa la hoja de datos de tu placa para evitar posibles errores.

Configuración Geo6mv2-for-android.ino

Unicamente tenemos que configurar la conexión wifi a la que nos vamos a conectar completando los parámetros YOUR_SSID y WIFI_PASSWORD.

const char* ssid = "YOUR_SSID";
const char* password =  "WIFI_PASSWORD";

• Wifi en red local
• Android en modo punto de acceso (AP)

Red Local:

Este es el router wifi o punto de acceso que tenemos normalmente en casa, el inconveniente es que solo nos podemos mover en el rango que nos permita el router. En este caso YOUR_SSID y PASSWORD serán las mismas que utilizas para conectar cualquier dispositivo Wifi.

Android en modo punto de acceso (AP):

Esta es la mejor opción para exteriores. Se encuentra en la configuración del propio teléfono, su acceso dependerá de la versión de Android que estemos usando.

Ya en la pantalla de configuración nos muestra el SSID y pulsando sobre Hotspot password nos mostrará el password de la red.

Copiamos estos datos en YOUR_SSID y WIFI_PASSWORD y ya tenemos los datos de la red para exteriores.

Nota:

En algunos modelos de Android es necesario desactivar el Wifi "normal" antes de empezar con la conexión con Arduino

Subir el programa al ESP8266 NodeMCU:

Si ya has configurado la red wifi el último paso es subir el programa al ESP8266 seleccionando el puerto donde este conectado COM X para Windows o /dev/ttyUSBX si usas Linux.

Con la placa y el puerto seleccionado, pulsamos sobre el botón "cargar".

En cualquiera de los dos casos, red local o punto de acceso, cuando abrimos el monitor serial del IDE de Arduino nos aparece la IP a la que nos tenemos que conectar desde el dispositivo Android: 

Primera conexión

La primera conexión que realiza el módulo puede demorar más de un minuto dependiendo de la cobertura que tengamos. Recuerda que si estas en un interior poner el módulo cerca de una ventana para mejorar la recepción.

Abrimos el programa que ya tenemos descargado en nuestro dispositivo Android y pulsamos sobre el menú en la opción "Start Wifi y se abrirá la siguiente pantalla: 

 

Y pulsamos sobre el botón "Connect!

Ahora solo hay que esperar a que el módulo Neo6MV2 tenga los suficientes satélites para que podamos fijar la posición. 

Como al iniciar el programa aparecemos en Madrid, este valor se puede cambiar para iniciar en la localización que más nos guste. Pulsamos sobre "Add mark" para fijar la posición que recibimos desde el ESP8266 y seguidamente pulsamos "Center" para central la última marcha creada.

Podemos crear todas las marcas que necesitemos y al pulsar sobre ellas si abrirá una ficha con los datos de la posición.

Aquí tienes los programas para probar el módulo NEO6MV2 GPS:

Descargar Geo6MV2 GPS for Android desde GitHub Arduino

Descargar Geo6MV2 for Android desde Play Store Android

Saludos!!!

MPU6050 Acelerómetro y Giroscopio con Arduino

Muy buenas a todos!!!

Vamos a ver que funcionalidades tiene el sensor MPU6050 el cual integra un acelerómetro de 3 ejes un giroscopio de 3 ejes y un sensor de temperatura, aunque este último no es muy preciso.

Antes de empezar vamos a destacar algunos de los términos que se usan con este sensor:

¿Que mide el acelerómetro?

Como su nombre indica, un acelerómetro mide la aceleración que es una magnitud vectorial, es decir, magnitud el cambio de velocidad, y la dirección, hacia donde se realiza el cambio.

A grandes rasgos hay tres tipos de aceleración:

• 
  Aceleración positiva: La velocidad de un objeto aumenta en el tiempo.
• Aceleración negativa: La velocidad de un objeto disminuye con el tiempo.
• Aceleración centrípeta: La dirección cambia a una velocidad constante.

¿Que mide el giroscopio?

Un giroscopio es un dispositivo que mide la velocidad angular o tasa de rotación de un objeto en los ejes X, Y y Z. La velocidad angular se expresa en grados por segundo (°/s) o radianes por segundo (rad/s).

El MPU6050, está basado en tecnología Micro-Electro-Mechanical Systems más conocido como MEMS . Esta tecnología utilizan un pequeño elemento vibrante que, al girar, experimenta una fuerza llamada efecto Coriolis. Esta fuerza es detectada y convertida en una señal eléctrica, que luego se traduce en una medida de la velocidad angular. Esto nos permite detectar rotaciones en cualquier dirección.

También podemos configurar el rango de medición teniendo en cuenta que rotaciones más rápidas equivalen a una menor precisión.

El rango de medición es configurable con los siguientes valores:

• ±250 °/s
• ±500 °/s
• ±1000 °/s
• ±2000 °/s

Resumen de aceleración y giroscopio en el contexto del MPU6050

El acelerómetro del MPU6050 mide la aceleración en los ejes X, Y, Z. Esto incluye:

• La aceleración debida al movimiento por ejemplo, si mueves el sensor.
• La aceleración debida a la gravedad 9.8 m/s² hacia el centro de la Tierra.

El acelerómetro del MPU6050 mide la velocidad angular en los ejes: X, Y y Z.

• La velocidad angular se expresa en grados por segundo (°/s) o radianes por segundo (rad/s).

Diferencia entre giroscopio y acelerómetro

• Acelerómetro: Mide la aceleración lineal (cambios en la velocidad en línea recta) y la inclinación respecto a la gravedad.
• Giroscopio: Mide la velocidad angular (cambios en la rotación o giro).

La combinación de ambos sensores trabajando juntos para proporcionan una imagen completa del movimiento de un objeto. Por ejemplo:

• El acelerómetro puede decirte si un objeto está inclinado.
• El giroscopio puede decirte si el objeto está girando y a qué velocidad.

Conexiones MPU6050:

• VCC: Alimentación +.
• GND: Alimentación - o masas.
• SCL: Serial Clock pin para la interfaz I2C.
• SDA: Serial Data pin para la interfaz I2C.
• XDA: I2C externo Serial Data para conectar sensores externos como un magnetómetro.
• XCL: I2C externo Serial clock.
• AD0: Cambia de dirección para evitar conflictos: GND -> Dirección 0X68 o +3.3V -> Dirección 0x69.
• INT: Pin de interrupción. El MPU6050 puede programarse para generar interrupciones al detectar ciertos gestos o vibraciones.

Librerías para MPU650:

• MPU6050 by Jeff Rowberg: Una de las más populares y completas. Puedes ver el ejemplo de uso en GitHub.


• Adafruit MPU6050: Otra opción sencilla y bien documentada. ejemplo de uso en GitHub.


• Librería Wire.h incluida con Arduino: Con esta librería leeremos los registros directamente desde el sensor MPU6050

#include <Wire.h>

// Dirección del sensor
const int MPU6050_addr=0x68;


int16_t AccX, AccY, AccZ; 
int16_t GyroX, GyroY, GyroZ;
int16_t Temp;

void setup(){
  
  Wire.begin();
  Wire.beginTransmission(MPU6050_addr);
  Wire.write(0x6B);
  Wire.write(0);
  Wire.endTransmission(true);
  
  Serial.begin(115200);
}

void loop(){
  Wire.beginTransmission(MPU6050_addr);
  Wire.write(0x3B);
  Wire.endTransmission(false);
  Wire.requestFrom(MPU6050_addr,14,true);
  
  AccX=Wire.read()<<8|Wire.read();
  AccY=Wire.read()<<8|Wire.read();
  AccZ=Wire.read()<<8|Wire.read();
  Temp=Wire.read()<<8|Wire.read();
  GyroX=Wire.read()<<8|Wire.read();
  GyroY=Wire.read()<<8|Wire.read();
  GyroZ=Wire.read()<<8|Wire.read();
  
  Serial.print("AccX = "); Serial.print(AccX);
  Serial.print(" || AccY = "); Serial.print(AccY);
  Serial.print(" || AccZ = "); Serial.print(AccZ);
  Serial.print(" || Temp = "); Serial.print(Temp/340.00+36.53);
  Serial.print(" || GyroX = "); Serial.print(GyroX);
  Serial.print(" || GyroY = "); Serial.print(GyroY);
  Serial.print(" || GyroZ = "); Serial.println(GyroZ);
  delay(100);
}

Una vez que subamos el programa al microcontrolador, en el monitor serial, tendremos la siguiente salida:

AccX = 13432 || AccY = -792 || AccZ = 9780 || Temp = 44.06 || GyroX = 911 || GyroY = -10038 || GyroZ = -5514

Problemas con las librerías

Mientras he realizado las pruebas he tenido algunos problemas con las librerías, por lo que al final he usado la obtención de datos usando unicamente la librería "Wire.h". Con estos datos podemos hacer casí cualquier sistema que necesite conocer su posición, movimiento y posición angular tales como...

• Drones: Para estabilizar el vuelo y detectar cambios de orientación.
• Robótica: Para controlar la dirección y el movimiento de robots.
• Realidad virtual: Para rastrear movimientos de la cabeza o manos.
• Navegación: En sistemas de navegación inercial para vehículos.

Hoja de datos del MPU6050

Aquí tienes otros enlaces de este blog relacionados con sensores y Arduino:

Esp8266 y adxl345 acelerómetro de 3 ejes, lectura serial

Arduino: Grabación y lectura de Infrarrojos (IR) y control de 4 reles

Saludos!!

La maqueta de Infotronikblog

Muy Buenas Arduineros y Arduineras!!!

Hace ya un tiempo, cuando empecé a programar, descubrí uno de los programas que más alegrías me ha dado desde que me dedico a esto. La central DCC++...

Hoy traigo al blog lamaquetade.infotronikblog.com una web dedicada al modelismo ferroviario y a la central DCC creada con Arduino.

Aunque no solo esta dedicada a la electrónica sino que también podemos encontrar trucos para la decoración de maquetas como un aplicador de césped electroestático o software dedicado al modelismo ferroviario como Rocrail o JMRI

Aunque el mayor premio se lo llevan la librería para el control de trenes DCC llamada DCCpp LMD y el software para Android con el que controlar esta y otras centrales DCC llamado DCCpp Android Cab.

Veamos algo más sobre este software:

La librería DCCpp LMD

DCCpp LMD es una librería que incluye todo lo necesario para montar una central DCC (Digital Command control) desde las funciones básicas hasta tener pantalla, comunicación Bluetooth y Wifi.

Características principales:

• Flexibilidad: Una central DCCpp LMD es altamente configurable, lo que permite adaptarla a las necesidades específicas de cada maqueta. Puedes personalizar la configuración de las locomotoras, los accesorios, sensores y los diferentes aspectos de las operaciones de tu trenes.
• Escalabilidad: DCCpp LMD cuenta con una amplia variedad de módulos y accesorios disponibles, como módulos S88 para detectar la ocupación de vías, módulos de radiofrecuencia para control remoto y mucho más. Esto te permite ampliar las funcionalidades de tu maqueta según tus necesidades.
• Autonomía: Aunque la comunicación serial es su base, la central DCCpp LMD puede operar de manera autónoma gracias a la adición de una pantalla OLED, un teclado y un encoder rotatorio. Esto te permite controlar tus trenes directamente desde la central sin necesidad de una ordenador o teléfono inteligente.
• Comunicación serial: Al comunicarse a través de serial facilita su integración con otros dispositivos y sistemas. Esto te permite conectar la central a un ordenador, un Arduino o cualquier otro dispositivo con capacidad serial.
• Automatización: La DCCpp LMD se puede programar para realizar secuencias de comandos automáticas, como la simulación de horarios de trenes o la activación de señales.

Y estas son las opciones principales que nos ofrece la central DCCpp LMD con respecto a las locomotoras:

• Direcciones de locomotoras de 2 y 4 bytes.
• Velocidad de 128 pasos.
• Programación en pista principal.
• Control simultaneo de múltiples locomotoras.
• Control de todas las funciones de cabina F0-F28.
• Activación y apagado de todas las direcciones de accesorios 0-2048.
• Programación en vía de programación.
• Pantalla Oled 128*64 I2c.
• Puertos seriales extras.

Ahora que ya hemos visto sus características y funciones principales...

¿Porqué existe DCCpp LMD y por que la uso?

La central DCC+ Base Station creada por Gregg E. Berman hace ya más de 9 años, revoluciono de una manera económica y sencilla el uso de las locomotoras que tienen incorporado un decodificador DCC. 

Estas centrales de tipo comercial, por lo general, tienen un coste elevado que añadido al coste de los decodificadores no hacía que fuera un entretenimiento asequible al bolsillo de cualquier aficionado.

Después de la central DCC++ Base Station todo eso cambio. Era relativamente sencillo conseguir una placa Arduino UNO y un MotorShield, podías encontrar los dos componentes en paginas webs por menos de 10€.

Visto esto y con mi consabida afición a los trenes en miniatura, ya sabes.. - ¿que hay mejor que un tren? - Dos trenes. decidí hacerme con todas las piezas y montar este cacharro y ver si daba lo que prometía... y vaya si lo hizo!!! Locomotoras y accesorios funcionaban al 100%, incluso se le podía añadir un sensor de consumo para prevenir cortocircuitos

No pude resistir el conocer a fondo como funcionaba, cuales eran sus entresijos, como recibía los datos con la comunicación serial y los distribuía entre las diferentes funciones así que termine empapándome de todo lo relacionado con esta central.

Finalmente llego a mi navegador de la mano de LocoDuino el mismo programa, pero en formato librería y paso a llamarse DCCpp. Nunca había tocado una librería... fue otro retro más que tenia que resolver. 

Después de un tiempo había añadido la pantalla Oled y el uso de los demás puertos seriales que tiene disponibles la placa Arduino MEGA. Por que si, para esta central, la placa que mejor se adapta tanto a el hardware como al software es la  placa Arduino MEGA. Sobre el 2020 la librería DCCpp dejo de actualizarse siendo su última versión la número 1.4.2. Una autentica pena la verdad.

Después de esto o incluso mientras otras centrales DCC surgieron de esta idea, la más destacada ahora mismo es la DCCEX. La rama americana de esta central. Ahí me perdí... Es un proyecto enorme en el que contribuyen muchas personas con mucho código que, si bien cubren las necesidades de muchos otros usuarios, para mi eran excesivas. Realmente no necesitaba tanto.

Volví a mi proyecto de la librería DCCpp modificada y pase a llamarla DCCpp LMD. La librería desde la que parte el proyecto, la V1.4.2, ya tiene todas las funciones que necesito, además de ser compatible con el software de gestión de trenes. Partiendo de esa base, fui añadiendo diferentes funciones y funcionalidades, mejorando el código en la medida de lo posible y adaptándola a mi maqueta.

Puedo programar secuencias de eventos, monitorear el consumo de corriente en tiempo real, detección con diferentes tipos de sensores, comunicación Bluetooth y wifi. Esto añadido al programa Rocrail, hace que me pueda pasar tardes enteras "jugando" con los trenes que tienen instalado un decodificador DCC,. Por desgracia no todas mis pequeñas cuentan con uno de estos decodificadores.

Si te gustan los trenes el modelismo y el sistema DCC y quieres descubrir como Arduino es capaz de adaptarse a cualquier entorno visita Lamaquetade.infotronikblog.com

Pantalla de llegada de trenes Adif - Lamaquetade.infotronikblog

Descargar librería DCCpp LMD para el control de locmotoras desde GitHub.

Decodificadores DCC realizados con Arduino en GitHub

Espero que te guste el contenido sobre Arduino y trenes y sobre todo que os guste la web, Saludos y felices fiestas!!!

ESP8266 Como usar LittleFS para guardar información

Antes de seguir con otro proyectos tenemos que detenernos en el apartado de los sistemas de ficheros (FS).

Si aunque no lo parezca, el ESP8266 tiene una memoria interna (Flash) con mucha más capacidad que sus primos Arduinos. Si bien dependiendo del ESP8266 tendremos diferentes capacidades de memoria.

Los más pequeños como el ESP8266-01 con 1MB y el ESP8266-01S que tiene 4MB. Y a partir de aquí casi todos los demás modelos ESP8266 tienen mínimo 4MB.

Esta cantidad de memoria suele ser más que suficiente para nuestros proyectos, pero si necesitas más memoria como por ejemplo para una estación meteorológica desatendida se puede utilizar un módulo al que podemos conectar una memoras SD o microSD.

De esta manera y siguiendo el ejemplo de la estación meteorológica, podríamos almacenar los datos de todo un mes y luego simplemente sacar la tarjeta y volcar los datos a nuestra computadora.

Hasta aquí la idea de tener alrededor de 3 (o más) MB disponibles suena muy bien, ahora, ¿como interactuamos con esta memoria?

Diferentes sistemas de archivos para ESP8266

• SPIFFS: SPI Flash File System, es un sistema de archivos diseñado específicamente para dispositivos embebidos con poca memoria como el ESP8266.
• LittleFS: La alternativa más reciente a SPIFFS, diseñada para ser más eficiente en cuanto al uso de la memoria y más robusta ante errores. Ofrece mejores prestaciones en términos de velocidad y capacidad de recuperación.
• FAT: Un sistema de archivos ampliamente utilizado en dispositivos de almacenamiento masivo. Sin embargo, su implementación en microcontroladores como el ESP8266 puede ser más compleja y consumir más recursos.

Con todos los sistemas de archivos podremos manejar las funciones básicas con archivos:

• Crear
• Abrir
• Leer
• Escribir
• Borrar
• Formatear unidad

Para este ejemplo usaremos LittleFS, tiene algunas mejoras en eficiencia y control de errores que su hermana SPIFFS.

La Librería LittleFS viene incluida cuando instalamos y configuramos las placas esp8266 al IDE de Arduino, así que por esa parte no necesitamos hacer nada más, simplemente cargar la librería como cualquier otra:

#include "LittleFS.h"

Y a partir de aquí veremos las diferentes funciones básicas de LittleFS, empezando por su configuración en el setup(). Al final del mismo tenemos las diferentes funciones que podemos utilizar:

#include "LittleFS.h"

String data = "FS ESP8266 Flash memory test";


void setup() {
  Serial.begin(115200);
  delay(100);
  
  if (!LittleFS.begin()){
    Serial.println("Error montando LittleFS");
    return;
  } 

  Serial.println("\n\nLittleFS se cargo correctamente");

  Create_file("/data.txt", data);
  Read_file("/data.txt");
  Delete_file("/data.txt");
  
  // Add_data_file("/data.txt", data);
  // Read_file("/data.txt");
  // Show_filetree("/");
  // Show_memory();
  // Format_all();
  Serial.println();
}

• char* ConvertStringToCharArray(String S)
  Transforma datos de tipo String a una cadena char (chararray). Esta función se utiliza en conjunto con Create_file y Add_data_file

char* ConvertStringToCharArray(String S)
{
  int ArrayLength = S.length() + 1;
  char CharArray[ArrayLength];
  S.toCharArray(CharArray,ArrayLength);
  return(CharArray);
}

• Create_file("/FILENAME", data);
  Crea el archivo FILENAME y almacena "data" en el.

void Create_file(const char *path, String data)
{
  Serial.println(path);
  File file = LittleFS.open(path, "w");
  if (!file){
    Serial.println("Error open file");
    return;
  }

  if (file.print(data)){
    Serial.println("Writing file...");
  } else {
    Serial.println("Error Writing");
  }
  file.close();
}

• Add_data_file("/FILENAME", data);
  Añade datos al final del archivo FILENAME. El archivo tiene que estar creado previamente.

void Add_data_file(const char *path, String data)
{
  Serial.println(path);
  File file = LittleFS.open(path, "a");
  if (!file){
    Serial.println("Error open file");
    return;
  }

  if (file.print(data)){
    Serial.println("Writing data...");
  } else {
    Serial.println("Error Writing");
  }
  file.close();
}

• Read_file("/FILENAME");
  Lee los datos almacenados en el archivo FILENAME

void Read_file(const char *path)
{
   File file = LittleFS.open(path, "r");
  if (!file){
    Serial.println("Error open file");
    return;
  }

  Serial.println("File content: ");
  while (file.available())
  {
    Serial.write(file.read());
  }
  Serial.println();
  file.close();
}

• Delete_file("/FILENAME");
  Borra el archivo seleccionado

void Delete_file(const char *filename)
{
  if (LittleFS.remove(filename)){
    Serial.print("Removed ");
    Serial.println(filename);
  } else {
    Serial.println("Deleting error");
  }
}

• Format_all();
  Elimina todos los datos de la memoria Flash (Esta acción no se puede deshacer).

void Format_all()
{
  if (!LittleFS.format()){
    Serial.println("Error montando LittleFS");
    return;
  } else {
    Serial.println("All files deleted");
  }
  LittleFS.end();
}

• Show_filetree("/");
  Muestra la árbol de archivos y directorios desde la raíz "/".

void Show_filetree(const char *path)
{
  Dir folder = LittleFS.openDir(path);
  while (folder.next())
  {
    File file = folder.openFile("r");

  Serial.print (" Name: ");
  Serial.print (file.name());
  Serial.print (" Size: ");
  Serial.print (file.size());
  Serial.print (" Folder:");
  Serial.print (file.isDirectory() ? "Yes" : "No");
  Serial.println ();
  file.close();
  }
    Serial.println("End file off filetree");
}

• Show_memory();
  Muestra el uso de memoria y cuanta memoria tenemos disponible

void Show_memory()
{
  FSInfo fs_info;
  LittleFS.info(fs_info);

  Serial.print("Used: ");
  int used = fs_info.usedBytes / 1024;
  Serial.print(used);
 
  Serial.print(" total Kbit: ");
  int total_kbits = (fs_info.totalBytes / 1024);
  Serial.print(total_kbits);
  Serial.print(" Used Kbits Used Memory: " );
  int used_memory = (fs_info.usedBytes / fs_info.totalBytes) * 100;
  Serial.print(used_memory);
  Serial.println();
}

Un punto importante del uso de archivos, es que una vez que terminemos de usar el archivo tenemos que cerrarlo con file.close(). Esto nos evitará perdida de información o que se pueda corromper el archivo.

Lo mejor es que en esta memoria podemos almacenar cualquier tipo de información, desde archivos de texto o archivos html o css.

Por el momento esto es todo, pero se vienen proyectos usando esta memoria. Si te ha gustado tienes el programa completo en mi repositorio.

Descargar ESP8266 librería LittleFS desde GitHub

Saludos!!!

ESP8266 ADXL345 y openStreetMaps con NEO6MV2

Muy Buenas Arduineros y Arduineras

Ahora si, juntamos los proyectos con el sensor ADXL345 y el sistema GPS con NEO6MV2. Esta unión afecta tanto al microrontrolador ESP8266 tanto como al programa para Python.

Si ya has visto las entradas anteriores, Servidor socket adxl345 Servidor AP GPS NEO6MV2 socket interface hacemos un pequeño resumen.

Son interfaces para comunicar mediante Wi-Fi los sensores arriba descritos. En estas interfaces se muestran los datos de posición de los ejes para el ADXL345 y la telemetría de la señal GPS.

Tipo de conexión:

• Cliente Se conecta a la red local.
• Como punto de acceso Nos conectamos directamente al microcontrolador.

Ambas opciones funcionan igual de bien y la latencia dependerá más por la distancia que tengamos con respecto al módulo que por la lectura de los sensores.

En el caso que de que estemos usando un portátil la ventaja para la conexión cliente es que como estamos conectados al router de casa seguiremos teniendo internet. No pasa lo mismo con el modo AP, una vez conectado no tendremos acceso a internet a no ser que estemos usando ethernet.

El modo AP en el ESP8266 será muy útil en exteriores como gracias a su conexión directa con la interfaz.

Tener los datos de latitud y longitud esta bien pero es mucho mejor tener una representación visual del recorrido. Además podemos añadir puntos de control que irán construyendo un perímetro con estas referencias. Para lograr tener el mapa en la interfaz hemos recurrido a la librería de Tom Schimansky TkinterMapView

TkinterMapView

TkinterMapView es una biblioteca de Python que nos permite crear mapas interactivos dentro de aplicaciones que utilicen la interfaz gráfica de usuario (GUI) de Tkinter. En otras palabras, es una herramienta que te facilita la integración de mapas en tus programas.

Entre sus características destacan:

• Mostrar mapas: Es su función principal, mostrar mapas basados en mosaicos como los que ofrece OpenStreetMap.
• Interactuar con el mapa: Los mapas que creas con TkinterMapView son interactivos. Los usuarios pueden hacer zoom, desplazarse y, en algunos casos, buscar ubicaciones específicas.
• Personalización: Puedes seleccionar entre diferentes proveedores de mapas y capas.
• Agregar marcadores y overlays: También puedes añadir marcadores para señalar puntos de interés en el mapa y superponer diferentes capas de información, como datos geográficos o imágenes.
• Facilidad de uso: La biblioteca es relativamente sencilla de usar, especialmente si ya estás familiarizado con Tkinter.
• Integración con Tkinter: Al ser compatible con Tkinter, puedes combinar los mapas con otros elementos de tu interfaz gráfica.

Alguna de las funciones que más usaras son:

• set_position - (set_position(x_lat, y_lon) Vamos a la posición dada por las coordenadas de latitud y longitud
• set_marker - (set_marker(x_lat, y_lon) Crea un marcador en el mapa
• set_zoom - (set_zoom(int)) Aplica zoom sobre el mapa
• set_address - (set_address("Almeria", marker=True, text="Spain")) Nos sitúa en la ciudad especificada
• set_polygon - (self.coordinates, name="Route NEO6MV2") con set_polygon crearemos una cerca que sera delimitada por una lista de puntos de latitud y longitud

Ahora que sabemos la novedad en este programa, este es un ejemplo sencillo de su uso con las funciones "set_position" y "set_marker":

import tkinter
import tkintermapview

# create tkinter window
root_tk = tkinter.Tk()
root_tk.geometry(f"{1000}x{700}")
root_tk.title("map_view_simple_example.py")

# Crea el widget con el mapa
map_widget = tkintermapview.TkinterMapView(root_tk, width=1000, height=700, corner_radius=0)
map_widget.pack(fill="both", expand=True)


# Establece la posición por latitud y longitud y aplica zoon 
map_widget.set_position(37.179790, -1.821792, marker=False)  # Garrucha, Almería 
map_widget.set_zoom(17)

# Establece la posición actual según su dirección
# map_widget.set_address("Garrucha, Almeria", marker=False)

def marker_click(marker):
    print(f"marker clicked - text: {marker.text}  position: {marker.position}")

# Establece un marcador, puede tener un color personalizado y comando "onClick"
marker_2 = map_widget.set_marker(37.179790, -1.821792, text="Garrucha Ayto.", command=marker_click)


root_tk.mainloop()

Con esta pequeña introducción a la librería TkinterMapView y como es prácticamente la única función añadida en el programa, ahora si, veamos la interfaz:

Para dar un toque diferente a la interz, le he aplicado una capa visual llamado "Forest ttk theme" alojado en GitHub para romper un poco con la monotonía del apartado visual por defecto

Como se puede apreciar, la parte superior es la dedicada al sensor ADXL345 y la parte inferior para el GPS NEO6MV2 junto con el mapa.

Para mostrar el mapa necesitamos tener conexión a internet, como explicaba más arriba esto no funcionará si estamos en el modo AP

Para usar el programa en modo AP no tendremos que realizar ningún cambio en la interfaz, pero si tener cargado el programa adecuado en el microcontrolador

• Descargar ESP8266 cliente adxl neo6mv2
• Descargar ESP8266 AP adxl neo6mv2

Conexión ESP8266 como cliente:

Para conectarnos en modo cliente tenemos que averiguar la IP que nos asigna el router, esta información nos la proporciona el programa y la podemos ver en el monitor serial

Conexión ESP8266 como AP:

Por otra parte si nos conectamos en modo AP, primero tenemos que conectarnos a la red: "gpsServer" y su contraseña es "gps12345". Una vez estemos conectados al ESP8266, la dirección IP por defecto para el modo AP es 192.168.4.1

Espero que os guste y si estáis aprendiendo a programar en Python os puede ayudar con vuestros proyectos Aquí teneís otros enlaces de este blog relacionados con Python:

Programa de ejemplo de este articulo en GitHub

Otras interfaces:

Interfaz de ejemplo con Tkinter de este articulo en GitHub

Adxl Socket Server en GitHub

Aquí tienes otros enlaces de este blog relacionados con Python:

Muestra el estado del sistema Raspberry Pi

Raspberry pi PWM

Tienes este y otros proyectos en mi repositorio de GitHub

Espero que os guste el contenido, Saludos!!

ESP32 oled 128x32 velocímetro RC Dashboard

Muy buenas a todos Arduineros y Arduineras

Librería Adafruit

Ya os presente uno de los mejores proyectos para Radio Control el ESP32 Engine sound. En este proyecto una de las últimas opciones que implementaron fue la pantalla con velocímetro o dashboard

En ese apartado, se sincroniza una pequeña pantalla de 160x80 con conexión SPI. Simplemente genial.

¿Cual es mi problema con esto? Pues en principio ninguno, pero no disponía de una pantalla SPI, pero si una OLED de 128x32 y conexión I2C

Librería U8g2Lib

El panel original viene un frok del ESP32 Engine Sound original al que como hemos comentado, se le añadió la pantalla con cuatro relojes, Velocidad, RPM, Gasolina y ADblue y los iconos de las funciones más comunes en todos los vehículos.

Como me pareció sencillo, decidí probar si ese código se podría portar a una pantalla I2C. Para la comunicación I2C con la pantalla he probado las 2 librerías más famosas para la pantalla SSD1306, la librería U8g2Lib y la librería Adafruit_SSD1306 siendo esta última la que me mejor a funcionado.

El proyecto lo he dividido en 2 partes, la primera es para usarlo de manera independiente y la segunda es con la pantalla ya integrada en el sistema ESP32 Engine Sound.

Los componentes que se han utilizado para el proyecto son los siguientes:

• ESP32 WROOM Dev Kit V1
• Oled SSD1306 128x32 I2C
  

Para no liar con lo que ya esta hecho, primero he renombrado los archivos dashboardc.cpp y dashboard.h a dashboardi2c.cpp dashboardi2c.h. y borrar todo lo que no esta relacionado con la pantalla "Garimaldi"

Para el manejo de la pantalla he usado la librería de Adafruit_SSD1306.h y Adafrit_GFX.h. Esto ha llevado cambios en la inicialización del programa y los tamaños de las esferas. Estos valores los cambiamos en el archivo dashboardi2c.h

En este archivo encontraremos los valores predefinidos como el radio de las esferas, iconos, colores o la posición de los iconos en la pantalla. Después de las definiciones, esta la clase "Dashboard" sustituida por "DashboardI2c" junto con sus funciones, menos la función "drawLogo()" que no afecta al funcionamiento normal del programa.

Puedes encontrar los archivos para su descarga al final de este articulo

Una vez que ya he probado las funciones y parece que todo funciona bien, añado un puerto para el I2c en la placa con el programa RC Engine Sound ESP32 y copio los archivos a la carpeta "RC_Engine_Sound_ESP32/src/src/"

En el archivo 9_Dashboard.h añado la siguiente linea para poder activar o desactivar la pantalla:

#define I2C_DASHBOARD 

Con la definición creada ya podemos añadir los cambios en el archivo "src.ino". Primero declaramos el objeto dashboard:

// Other objects -----
// Dashboard

#ifdef I2C_DASHBOARD
  DashboardI2c dashboard;
#else
  Dashboard dashboard;
#endif

En la función void setup() tenemos que desactivar los pines que correspondes al puerto I2C que en la placa DOIT ESP32 DEVKIT V1 corresponden a los pines GPIO21 (SCL) y GPIO22(SDA) y en el programa a las funciones "Beacon1" y "Cab light":

// Added for I2c dashboard
#if not defined I2C_DASHBOARD
  beaconLight1.begin(BEACON_LIGHT1_PIN, 9, 20000);  // Timer 9, 20kHz
  cabLight.begin(CABLIGHT_PIN, 12, 20000); // Timer 12, 20kHz
#endif

Un poco más abajo en la misma función setup() ponemos un mensaje para mostrar en el monitor serial que la pantalla esta activada:

#if defined I2C_DASHBOARD
  // Dashboard setup
  Serial.printf("I2C_DASHBOARD enabled. Pins 21 (beacon1), 22 (cablights) not usable!\n");
  Serial.printf("-------------------------------------\n");
  dashboard.init(dashRotation);
#endif

Como la tasa de refresco de la pantalla es bastante baja, el tiempo en el que se muestra tiene que ser mayor, si no gastará mucho tiempo "dibujando" y el programa ira excesivamente lento, para esto añadimos en la función "updateDashboard()" lo siguiente:

#ifdef I2C_DASHBOARD
  if (millis() - lastFrameTime > 300) // We need to save processing time!
#else
  if (millis() - lastFrameTime > 40) // 40) // We need to save processing time!
#endif
  

Y por último actualizamos la pantalla en la función loop():

#ifdef I2C_DASHBOARD
    updateDashboard();
#endif

Por supuesto todo esto ha sido para poder implementar la pantalla junto con su código en el programa original RC Engine Sound, pero no solo de código vive el hombre, así que este es el diagrama de conexiones que utilizo actualmente:

Al conservar los nombres que le dieron a las funciones en la clase Dashboard original, solo con unos pocos cambios podemos hacer compatibles esta pantalla I2C con el sistema RC Engine Sound ESP32. Si bien no dispone de todo el colorido y la rapidez de la pantalla SPI. Quedará muy bien en cualquier vehículo RC.

Como comente al principio, la librería U8G2Lib que, aunque si que dibuja la pantalla, la tasa de refresco es muy inferior a la tasa de refresco de la librería Adafruit. Esto hace que la pantalla no muestre los datos de una manera fluida e incluso produzca cuelgues en el ESP32.

Tienes mas información sobre el sistema en el artículo:Man Kat con Rc Engine Sound esp32.

Los archivos, tanto para la librería Adafruit como para U8g2Lib, para el velocímetro los puedes descargar en:

Descargar ESP32 oled i2c 128x32_dashboard desde GitHub

El programa original, en ingles, lo podéis encontrar en el siguiente enlace:

Repositorio oficial de RC Engine Sound ESP32 en GitHub

Puedes hacer las placas para RC Engine Sound ESP32 de una manera profesional desde el repositorio PCBway.com de "Thediyguy

Espero que os guste esta pequeña modificación para este excelente programa y para los que os gusta trastear, esta es una manera más clara de aprender a como dibujar en una pantalla de estas características.

 Saludos!!