Amstrad CPC 464 Reparación parte 1

Muy buenas a todos y todas!!!

Hoy traigo la segunda adquisición de Amstrad: El Amstrad CPC 464.

Antes de empezar con mis idas y venidas con este ordenador vamos a ver sus especificaciones técnicas:

Como su hermano mayor, el CPC 6128, el CPC 464 cuenta con procesador Zilog Z80. También con una velocidad de 4Mhz de los cuales son efectivos 3,3Mhz.

Zilog Z80 en Amstrad CPC 464

Su memoria RAM es de 64Kb (La mitad que el CPC 6128).

Su memoria ROM es de 48Kb.

Su Controlador de vídeo es un Amstrad Gate-Array 40010 y un controlador de gráficos 6845 CRTC. Esto nos permite tener 3 diferentes modos de texto y 3 modos gráficos:

• Los 3 modos de texto:
• 20x25 caracteres
• 40x25 caracteres
• 80x25 caracteres
• Los 3 modos gráficos:
• Modo 0: 160x200 en 16 colores
• Modo 1: 320x200 en 4 colores
• Modo 2: 640x200 en 2 colores

Otras particularidades de la máquina son:

• Paleta de 27 colores.

• Unidad de casete integrada, con 2 velocidades, 1000 y 2000 baudios.

• Conectores para monitor RGB, impresora Centronics, joysticks y salida de audio.

• Chip de sonido General Instrument AY-3-8912, con 3 canales de sonido y un canal de ruido blanco.

• Lenguaje Locomotive BASIC V1.0 incluido en ROM que también se puede utilizar como sistema operativo.

Amstrad CPC Locomotive Basic 1.0

Mi Amstrad CPC 464

Lo adquirí en una web de cosicas de segunda mano con un estado "En condiciones aceptables".. Spoiler: No eran tan aceptables.

Por suerte, su primera conexión fue exitosa, Una pantalla azul casi identica a la que sale en CPC 6128. Hasta aquí todo bien.

Ahora empiezan los problemas: Al pulsar una tecla... nada... al pulsar otra.. nada... EL TECLADO NO FUNCIONA y esto no me lo había comentado el vendedor...

Tocaba destripar al paciente.

Primero tenemos que retirar los 6 tornillos que están en la parte posterior del teclado y con esto ya tenemos separadas las carcasas. 

 

Separamos poco a poco ya que hay cables conectados entre las dos carcasas, el cable del teclado, que son dos conectores de plástico y El conector que sale de la unidad de cinta y va hacia la placa.

Hecho esto podemos ver la placa del Amstrad CPC 464:

Primera misión: Encontrar el fallo:

La parte que va dedicada al teclado está en la parte izquierda de la placa. No ha sido difícil encontrar el fallo: La Membrana esta rota y faltan de algunos muelles que presionan las membranas.

Aquí falta algo...

Según tengo entendido gracias a este magnifico vídeo de Manuel Cuenca llamado Reparación Amstrad CPC 472 de Juanan, no enciende, fallo parcial de teclado y sin sonido. en su canal de Youtube: "Manuel Cuenca (MMChip)".

Aunque no es especifico para el Amstrad CPC 464, nos puede servir como una excelente guía para detectar el fallo. En mi caso me centre en el minuto 5:00 que es donde explica como probar que la placa este correctamente haciendo unos puentes entre los diferentes puntos del conector CP002. Haciendo esto comprobé que aprecian letras y números.

Podemos comprobar esto con un puente entre los pines 9 y 19 en el conector CP002:

Esta combinación activa la tecla "intro", de esta manera descartamos que sea la placa del CPC la que pueda tener algún integrado en mal estado.

En la siguiente imagen están todas las combinaciones de teclas tal y como viene descrito en la pagina 11 del Service Manual (en Ingles):

Pincha en la imagen para agrandar.

Segunda misión: Encontrar repuestos.

Esta es la parte mas difícil hasta ahora, encontrar repuestos... y para la membrana nada menos!!! Navegando por diferentes Webs podemos encontrar algunas alternativas. Pero antes de comprar mejor tener la mayor información posible, así que recurrí otra vez al canal de Manuel Cuenca quien, desde un principio se ofreció a echarme una mano con mi pequeña empresa de arreglar esta pequeña joya.

La solución ha venido de la mano de "Retro Fuzion", una web situada al sur de Australia dedicada a repuestos de Commodore, Atari, Amiga y alguno más.

Es curioso que siendo un aparato de origen Ingles, los únicos que tengan este tipo de repuestos sea el sur de Australia.

Bien!! hasta aquí la primera parte, continuaré con la entrada cuando reciba el repuesto y lo ponga en la máquina.

Saludos Retro!!!

Repuesto para membrana Amstrad CPC 464 de Retro Fuzion

Manual de mantenimiento CPC 464 en Ingles.

Manual de usuario CPC 464 en Español.

Guía de usuario CPC 464 en Español.

Manual de referencia BASIC en Español.

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