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


miércoles, 2 de octubre de 2024

Modulo GPS 6MV2 Serial ESP8266 NodeMCU

¿Qué es el Módulo GPS-6MV2?

GPS-6MV2

El módulo GPS-6MV2 es un dispositivo electrónico pequeño y, sobre todo, económico. Este dispositivo que permite determinar la posición geográfica de un objeto, como un dron, a través de las señales emitidas por los satélites GPS. Es ampliamente utilizado en proyectos de electrónica, robótica y aplicaciones de seguimiento. Fácil de programar y con multitud de librerías disponibles para leer los datos que proporciona de manera serial. Datos que posteriormente se pueden buscar en paginas como Google maps.

Antes de empezar a programar vamos a ver primero sus características, los usos más comunes y, sobre todo, su funcionamiento.

Características técnicas principales:

  • Chipset: U-blox NEO-6M
  • Alimentación: 3.3V a 5V
  • Consumo: Aproximadamente 45mA en funcionamiento
  • Comunicación: Serial UART (TTL)
  • Velocidad de comunicación: Hasta 9600 bps (Configurable)
  • Precisión: Hasta 2.5 metros
  • Antena: Integrada (cerámica)
  • Temperatura de funcionamiento: -40°C a 85°C
  • Dimensiones: Pequeño y compacto
  • Memoria: EEPROM interna para configuración

 

¿Cómo Funciona el módulo GPS 6MV2?

El módulo recibe las señales de los satélites GPS, calcula su posición en base a la demora de las señales y proporciona esta información a través de la interfaz serial. Los datos que se pueden obtener incluyen:

  • Latitud y longitud: Coordenadas geográficas exactas.
  • Altitud: Altura sobre el nivel del mar.
  • Velocidad: Velocidad del dispositivo.
  • Curso: Dirección en la que se mueve el dispositivo.
  • Número de satélites: Cantidad de satélites detectados.
  • Hora: Hora UTC (Tiempo Universal Coordinado)

¿En que aplicaciones es un gran aliado?

La versatilidad del módulo GPS-6MV2 lo hace ideal para una amplia gama de proyectos y aplicaciones, entre las que destacan:
      Seguimiento:
    • Seguimiento de vehículos, personas o mascotas.
    • Sistemas de flotas.
    • Geolocalización de activos.
      Robótica:
    • Navegación autónoma de robots móviles.
    • Drones con GPS.
    • Vehículos aéreos no tripulados (UAV).
      Proyectos con microcontroladores:
    • Creación de sistemas de posicionamiento para Arduino.
    • Desarrollo de aplicaciones de geolocalización.
      IoT (Internet de las Cosas):
    • Dispositivos IoT con seguimiento GPS.
    • Sensores remotos con geolocalización.
      Meteorología:
    • Balones sonda con GPS.
    • Estaciones meteorológicas móviles.
      Deportes:
    • Seguimiento de actividades al aire libre (running, ciclismo, etc.).
    • Análisis de rutas.

Su capacidad para determinar la posición geográfica de un dispositivo hace que sea una opción popular y accesible para los aficionados a la electrónica y los ingenieros.

Sin embargo, como cualquier tecnología, el GPS-6MV2 presenta tanto ventajas como desventajas. A continuación, veremos los puntos positivos y negativos de este módulo, esto nos permitirá tomar la decisión adecuada sobre si aplicarlo o no en nuestro proyecto.

Ventajas del módulo GPS-6MV2:

  • Bajo costo: Es una opción económica para proyectos de GPS.
  • Fácil de usar: Su interfaz serial simplifica la integración con microcontroladores como Arduino.
  • Pequeño y ligero: Ideal para aplicaciones móviles.
  • Alta precisión: Proporciona datos de posición precisos para la mayoría de las aplicaciones.
  • Amplia disponibilidad: Se encuentra fácilmente en tiendas de electrónica y en línea.

Desventajas del módulo GPS-6MV2:

  • Precisión: La precisión, pese a ser muy buena en condiciones optimas, puede verse afectada por factores como la obstrucción de la señal GPS por edificios, vegetación o factores meteorológicos como la lluvia o tormenta. El número de satélites visibles se vera afectado por estos factores y se reducirá la precisión
  • Consumo de energía: Durante la búsqueda inicial el consumo es más elevado si lo comparamos a cuando el sistema ya ha establecido conexión.
  • Configuración: Es posible configurar el módulo para ajustar parámetros como la velocidad de baudios, el formato de datos y otros.

Como vemos no todo es bonito con el módulo GPS 6MV2, pero queda claro que sus ventajas lo hacen ideal para casi cualquier proyecto que requiera la posición de un objeto.

Librerías Arduino para el Módulo GPS-6MV2

Para comunicarnos con este módulo existen diversas librerías que puedes utilizar con Arduino para interactuar con el módulo GPS-6MV2. Cada una ofrece diferentes funcionalidades y niveles de complejidad. A continuación, te presentaré algunas de las librerías más comunes y algunas otras menos conocidas pero no por ello menos importantes:

 

Librerías Principales para el módulo GPS-6MV2:

  • TinyGPS: Una de las librerías más populares y sencillas de usar. Proporciona una interfaz intuitiva para leer los datos NMEA (National Marine Electronics Association) del módulo GPS y extraer información como latitud, longitud, altitud, velocidad y tiempo. Es una excelente opción para comenzar.
  • TinyGPSPlus: Una versión mejorada de TinyGPS que ofrece funciones adicionales y un mayor rendimiento. Es ideal para proyectos que requieren un procesamiento más avanzado de los datos GPS.
  • Adafruit_GPS: Desarrollada, como su nombre indica, por Adafruit, esta librería proporciona una interfaz fácil de usar y es compatible con una amplia variedad de módulos GPS. Ofrece funciones para configurar el módulo, leer datos y calcular distancias.
  • NewSoftSerial: Esta librería no es específica para GPS, pero es útil si necesitas utilizar pines diferentes a los seriales estándar de Arduino para la comunicación con el módulo GPS.

Otras librerías menos conocidas

  • SparkFun_Ublox_GPS: Diseñada específicamente para los módulos GPS U-blox, como el NEO-6MV2. Ofrece un control más granular sobre las configuraciones del módulo y acceso a características avanzadas.
  • GPSLib: Una librería más completa que ofrece funciones para calcular distancias, rumbos y realizar otras operaciones geográficas.

Librería TinyGPSPlus y el ESP8266 NodeMCU

Es una de las librería de Arduino más populares y fáciles de usar. Procesa los datos específicos para del módulo GPS que transmite información en formato NMEA. Esta librería es una evolución de la librería TinyGPS.

Además de su facilidad de uso, cuenta con una amplia comunidad y documentación que nos proveen de toda la información necesaria para usos más específicos

Para las conexiones entre microcontrolador y módulo unicamente usaremos 2 pines, más concretamente el pin, Rx GPIO0 (D3) y Tx GPIO2 (D4). Para la alimentación usaremos los 3.3V y GND

Conexión entre NodeMCU y GPS6MV2

Es importante recordar que para muchos microcontroladores con un solo puerto serial, es imprescindible el uso de la librería "SoftwareSerial". Esta herramienta nos permite simular una comunicación serial en cualquier par de pines digitales de tu placa


#include <tinyGPSPlus.h>
#include <SoftwareSerial.h>
/*
    Este ejemplo demuestra el uso de TinyGPSPlus, requiere el uso 
    de SoftwareSerial, para el dispositivo GPS-6MV2 usaremos 9600-baud 
    y conectado al pin GPIO 0 (Rx) y el GPIO 2(Tx) del microcontrolador
    ESP8266 NodeMCU.
*/

static const int RXPin = 0, TXPin = 2;
static const uint32_t GPSBaud = 9600;
String gpsdate = "";
String gpstime = "";

// Objeto TinyGPSPlus
TinyGPSPlus gps;

// Conexión serial con el dispositivo GPS
SoftwareSerial ss(RXPin, TXPin);

// Inicia el Serial y la comunicación GPS-6MV2 
void setup() 
	{
	Serial.begin(115200);
	delay(1000);
    Serial.println("Iniciando GPS-6MV2...");
	ss.begin(GPSBaud);
	}

void loop() 
	{
	Serial.println(neo6mv2data());
    smartDelay(1000);

	if (millis() > 5000 && gps.charsProcessed() < 10) 
    	{
    	Serial.println(F("No se reciben datos GPS, revise las conexiones"));
    	}
    }

static void smartDelay(unsigned long ms) {
	unsigned long start = millis();
	do 
    	{
		while (ss.available()) 
        	{
			gps.encode(ss.read());
            }
		} while (millis() - start < ms);
}

La función principal del loop() se hace una llamada a la función neo6mv2data() Esta es la función encargada de devolvernos un String con los datos que se mandan en la comunicación serial


String neo6mv2data() {

  int satellites = -1;
  float hdop = 0.0;
  float location_lat = 0.0;
  float location_lng = 0.0;
  int age = 0;
  char dateBuffer[10]; // 00/00/0000
  char timeBuffer[8]; // 00:00:00
  float altitude = 0;
  float course = 0;
  float speed = 0;

  if (gps.satellites.isValid()) satellites = gps.satellites.value();
  else satellites = -1;
  if (gps.hdop.isValid()) hdop = gps.hdop.hdop();
  else hdop = -1;
  if (gps.location.isValid()) location_lat = gps.location.lat();
  else location_lat = 0.0;    
  if (gps.location.isValid()) location_lng = gps.location.lng();
  else location_lng = -1;
  if (gps.location.isValid()) age = gps.location.age();
  else age = -1;
  if (gps.altitude.isValid()) altitude = gps.altitude.meters();
  else altitude = -1;
  if (gps.course.isValid()) course = gps.course.deg();
  else course = -1;      
  if (gps.speed.isValid()) speed = gps.speed.kmph();
  else speed = -1;
  
   if (gps.date.isUpdated())
  {
    sprintf(dateBuffer, "%d/%d/%d", gps.date.day(), gps.date.month(), gps.date.year());
    gpsdate = String(dateBuffer);
  }
  
  if (gps.time.isUpdated())
  {
    sprintf(timeBuffer, "%d:%d:%d", gps.time.hour(), gps.time.minute(), gps.time.second());
    gpstime = String(timeBuffer);
  }

 return "<gps" 
            + String(satellites)
            + " " 
            + String(hdop)
            + " " 
            + String(location_lat,6)
            + " "
            + String(location_lng,6)
            + " "
            + String(age)
            + " "
            + String(gpsdate)
            + " "
            + String(gpstime)
            + " "
            + String(altitude, 2)
            + " "
            + String(course, 2)
            + " "
            + String(speed, 2)
            + ">";
}

Si nos fijamos en las lineas de location_lat o location_lng, al formar el Srting, conservamos los decimales, en este caso 6:


String(location_lat, 6) // x.000000

String(location_lng, 6)	// y.000000

Salida serial GPS-6MV2

Y esta es la captura de los datos seriales que recibe el microcontrolador ESP8266.

Cada uno de los valores esta delimitados por "< ">, con una cabecera con los caracteres "gps" y separados por un espacios " " y esto hace que a la hora de usar otro programa sea más sencilla su decodificación.

Versátil y barato, este módulo puede hacer las delicias de cualquier aficionado a la electrónica o la radio frecuencia. Esperamos que con esta información se pueden tener más claros ciertos conceptos y ventajas y desventajas del módulo GPS-6MV2

Descargar ESP8266 Basic GPS6MV2 Serial desde GitHub

Saludos!!!