miércoles, 18 de diciembre de 2024

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!!!

miércoles, 20 de noviembre de 2024

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!!!

sábado, 2 de noviembre de 2024

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

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!!

viernes, 25 de octubre de 2024

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!!

lunes, 14 de octubre de 2024

ESP8266 AP con GPS-6MV2 socket interface


GPS-6MV2 Tkinter interface

Buenas a todos!!!

Aprovechando que ya sabemos como mostrar, de manera serial, los datos que nos proporciona el módulo GPS-6MV2

No es muy practico tener que abrir el monitor Serial del IDE Arduino, o putty, para tener que ver una serie de números que, a priori, no nos dicen nada.

Pero para eso tenemos a Python, la navaja suiza de los lenguajes de programación. Igual que hicimos con el módulo ADXL345 con la interfaz y la clase socket. Solo necesitamos unos cuantos labels para mostrar los datos GPS de una manera que tengan sentido para cualquier usuario.

GPS-6MV2 pyTermTk interface

Pero volver a mostrar el mismo programa en otra entrada diferente, ya que los cambios son mínimos, no me convencía mucho. He probado a crear un programa pero usando esta vez pyTermTk.

Para cambiar un poco la programación esta vez no he usado ttkDesigner, simplemente he ido creando la interfaz como si estuviera usando Tkinter.

El resultado han sido dos programas prácticamente iguales, pero uno diseñado para mostrar datos en un entorno con ventanas y el otro se puede usar directamente desde cualquier terminal.

Arduino ESP8266 en modo AP:

Otra de las cosas que he cambiado es la manera de conectar el módulo ESP8266 con el portátil. Generalmente programo en un entorno cerrado y la conexión del ESP8266 se realiza con una conexión al router.

¿Pero que pasa si quiero salir de casa? Pues que el sistema deja de funcionar y tendría que programar la IP de cada red a la que se conecte.

Poniendo el microcontrolador en modo AP (Access Point) convertimos el ESP8266 en el punto central de una pequeña red local. De esta manera son los dispositivos como portátiles o smartphones los que se conectan al microcontrolador

Puede ser una red abierta (no recomendado) o una red con contraseña WPA2-PSK y la programación cambia muy poco con respecto al modo cliente, que es que uso habitualmente.

El programa esta dividido en dos archivos:

  • ESP8266_GPS6MV2_AP_server.ino Establece el modo AP y la comunicación con el módulo GPS-6MV2.
  • neo6mv2.ino donde se construye el String con los datos recibidos por el GPS-6MV2.

Asignamos un nombre y contraseña para la red:


#include "ESP8266WiFi.h"

const char* ssid = "gpsServer";
const char* password =  "!2345678";
WiFiServer wifiServer(1314);
void setup(){

  WiFi.softAP(ssid, password);

  IPAddress IP = WiFi.softAPIP();
  Serial.print("Starting GPS-6MV2 in AP mode on IP: ");
  Serial.println(IP);
}


Con este código el microcontrolador ya está en modo AP

Es el loop() donde se crearán los nuevos clientes y donde se sitúa la función principal, en este caso las funciones relacionadas con el módulo GPS:


void loop() {
  
 WiFiClient client = wifiServer.available();
 
  if (client) {
    Serial.println("Client connected");
    while (client.connected()) {
    
    // Lo que haga el programa
    
    }
  client.stop();
  Serial.println("Client disconnected");
  } 
}

En este punto ya solo tenemos que añadir la parte de código que ya hemos visto en el artículo Modulo GPS 6MV2 Serial ESP8266 NodeMCU.

Si ya has descargado el código y conectado el ESP8266 a una fuente de alimentación tiene que aparecer en el gestor de conexiones de la distribución que estemos usando.

Gestor de conexiones

Cuando le damos a conectar, nos pedirá la contraseña, !2345678, la introducimos y tenemos la conexión establecida. Empecemos con el programa realizado con Tkinter:


python3 -m main_gps6mv2

Si ya estas conectado a la red "gpsServer", los datos aparecerán al pulsar el botón "Start Conn":


Para el ejemplo desarrollado con la librería pyTermTk tenemos que ejecutar:


python3 -m main_gps_termtk


Igual que con la otra interfaz, si estamos conectados a la red "gpsServer" y pulsamos "Connect":

Puedes descargar los programas estas interfaces para el módulo GPS-6MV2 desde GitHub desde los siguientes enlaces:

Programa para microcontrolador ES8266 comunicación en GitHub

Interfaz de ejemplo con Tkinter de este articulo en GitHub

Interfaz de ejemplo con pyTermTk de este articulo en GitHub

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

Interfaz para el módulo ADXL345

Muestra el estado del sistema Raspberry Pi

Raspberry pi PWM

Espero que os guste el contenido, Saludos!!

miércoles, 9 de octubre de 2024

Primer barco RC Zhong Shan Gunship

Muy buenas a todos marineros!!

Ya sabéis que nos encantan los vehículos RC, generalmente son vehículos terrestres Pero el verano pasado decidí comprar un kit para un barco, y mirando por mi web chinesca de confianza encontré este modelo de plástico para montar: Zhongshan Gunboat. lo que más me llamo la atención es que estaba medio preparado con motor. Como no entiendo de barcos, me dije, pues este mismo, y esto es lo que pasó...

 

Pero antes, un poco de la historia sobre el barco Zhongshan Gunboat:

 

Según wikipedia este barco cañonero de 65,8 metros de longitud y 8,8 metros de manga, pertenecía a la Marina China y fue construido en Japón en 1913 e irónicamente hundido por esta misma armada japonesa durante un bombardeo en la segunda guerra Sino-Japonesa (1937-1945) en el rio Yangtze el 24 de octubre de 1938.

En 1986, cuando decidieron recuperar los restos del naufragio, recuperación que se llevo a cabo en 1997, 59 años después de su hundimiento. En 2001 recuero su apariencia de 1925 pero decidieron conservar daños sufridos durante su hundimiento-

El Zhongshan restaurado ahora se encuentra en el Museo de Buques de Guerra Zhongshan en Wuhan.

Fin de un poquito de historia :)

No soy experto en montar maquetas de barcos ni en barcos en general, asi que primero mis disculpas a los que si por que me imagino que no estaré usando las palabras técnicas del mundillo. Y casi con seguridad podría decir que es la primera maqueta de plástico que monto.

¿La experiencia? Ha sido entretenida y sobre todo montar el Zhong Shan Gunboat ha sido muy divertido.

Para montar el kit de plastico he utilizado las siguientes herramientas:

  • Cuter
  • Lima
  • Alicates de corte
  • Taladro manual
  • Vaselina o grasa
  • Pinturas en spray

Como el motor ya viene prácticamente montado, solo lo he desmontado para aplicar un poco de grasa en los piñones interiores. Y la primera parte que he mecanizado es el timón.

 

Para poner el timón primero he cortado la parte que va en el interior de barco, después con una broca de 1.5mm he agrandado el agujero para poder introducir un tornillo de 35mm. En la parte superior he puesto el enganche que conectará con el servo que mueve el timón.

Antes de poner el timón en su posición definitiva hay que aplicar grasa en todo el tornillo hasta que todo el hueco quede estanco. Esto evitará que el agua pueda introducirse en el interior del barco.

Para colocar las helices primero tenemos que quitar los 4 tornillos que sujetan el motor, de esta manera se trabaja con mayor comodidad. Después hay que introducir la vaselina en los tubos (¿bocinas?) antes de meter los ejes donde colocaremos las helices. Como los tubos son algo pequeños, apliqué la vaselina, primero calentando un poco al baó maría y aplicandola con una jeringa. Al empujar, tiene que salir parte de esta vaselina hasta que salga el eje. Con esto, igual que con el timón, evitamos que el agua se filtre al interior de la embarcación

Con esto hecho, poniendo el receptor para la radio Taranis y un par de ajustes rápidos, ya estaba preparado su primera prueba de navegación





Una vez termine de probar que todo funcionaba correctamente desmonte la electrónica y pase al segundo paso, pintar.

Pintar no es algo que se me de especialmente bien, aún así primero pinte todo de negro, para darle opacidad al platico, esto es por que el plástico es bastante fno y la otra pintura al ser gris, no creo que sea capaz de no dejar pasar la luz del ESC o del receptor desde el interior y es algo que no me gusta.

Para el casco he usado color rojo claro para la parte inferior y el gris oscuro para la parte que va sobre el agua. Si bien hay una franja blanca, ya me había quedado bien el corte de rojo a gris y no quise arriesgar

Para el puente he usado una especie de marrón y el mismo gris oscuro que he usado en el casco. Al ser escala 1/150 me ha venido vien para ponerle un personaje en el puente como timonel.

Electrónica y reglaje:


Para la electrónica he probado varias emisoras. Primero probé con la radio "Taranis" pero hay un fallo que no supe arreglar y es que al desconectar la radio, el servo se pone en una posición que hace que el timón estuviera forzado.

Imagino que no le he dedicado el suficiente tiempo a esta radio, por que no lo logre quitar. Curiosamente también me pasa con otros receptores de la misma marca.

En la prueba con GT5 la cosa mejoró notablemente. Ahora el servo siempre esta en su sitio.

  • Receptor: FS2A AFHDS 2A de 4 canales
  • ESC: Genérico motor escobillas
  • Baterías: 2 x 18650
  • Motor: Genérico 130
  • Servo: Servo 9G genérico

Recuerda que puedes hacer tus propios packs de baterías 2S en este enlace.

 

Una vez que ponemos las baterías el barco pierde estabilidad así que probé a poner más peso en la parte posterior. En total se han añadido 30g extra que sumados a los 110g de la batería, 10g del servo y 20g del ESC hacen un total de 170g.

Como primera experiencia de navegación ha sido bastante fácil de poner en marcha e incluso de subsanar pequeños errores que han ido surgiendo durante el montaje y pruebas.


 

ARRR!!! Marineros!!!! Si esta entrada gusta, compraré otro diferente para montar y compartir mis experiencias. A ver si para el próximo consigo hacer funcionar la "Taranis y probamos. Además si encuentro el fallo comento como corregirlo.

Saludos!!!

Fuentes:

Wikipedia: Chinese gunboat Zhongshan