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

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 ESP8266 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.

Instalación de la librería:

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"

Funciones básicas LittleFS

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);
  
  // Monta el sistema de archivos
  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();
}

• Create_file("/FILENAME", data);
  Crea el archivo FILENAME y almacena los datos del String "data".

// Create_file("/data.txt", data);

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.

// Add_data_file("/data.txt", data);

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

// Read_file("/data.txt");

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

// Delete_file("/data.txt");

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).

// Format_all();

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 "/".

// Show_filetree("/");

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

// Show_memory();

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.

Librería LittleFS desde GitHub

Descargar ejemplo con ESP8266 librería LittleFS desde GitHub

Saludos!!!

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

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.

Principales características módulo NEO-6MV2

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

ESP8266 Servidor socket ADXL 345

Si ya leíste la entrada anterior sobre el sensor ADXL345, hemos mostrado los datos que genera un sensor de 3 ejes en el monitor serial. A mucha gente, una serie de números en una pantalla no le dicen mucho, algo más "humano" puede ser representarlo en un gráfico.

¿Como dibujar con Python?

Aunque más que a Python nos referimos a una de las librerías más famosas para crear interfaces, Tkinter. Junto con esta librería viene uno de los widgets más versátil para el dibujo, Canvas.

Canvas te proporciona un espacio donde puedes dibujar y mostrar elementos gráficos de forma personalizada. Es como una hoja de papel en la que puedes dibujar líneas, formas, texto, imágenes e incluso vídeo si utilizas una librería externa como OpenCV (Open Source Computer Vision Library).

Dentro de Canvas encontraremos la función create_line, con la que representaremos las coordenadas X Y Z de forma visual de tal manera que van a tener sentido.

id = cv.create_line(obj, init_ancho, init_alto, ancho, alto, trazo)

El programa va estructurado en dos partes, por un lado tenemos el ESP8266 con el sensor ADXL345 en modo servidor y por otro lado tenemos un ordenador con Python y el programa ADXL345 Interface Axis. 

NodeMCU -> Python Tkinter

ESP8266 ModeMCU con ADXL345

Este sensor tiene su propia entrada en el blog "ESP8266 y ADXL345 acelerómetro de 3 ejes. Lectura Serial" y es recomendable leerlo para entender mejor el funcionamiento del sensor ADXL345.

Primero iniciamos el microcontrolador ESP8266 con el sketch "esp8266_adxl_socket_server.ino". La principal diferencia con el programa básico es la implementación de un servidor socket en modo servidor con la librería "ESP8266WiFi.h". Solo hay que cambiar los datos para el ssid y password.

 
#include "ESP8266WiFi.h"

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

// Tipo de Socket y puerto
WiFiServer wifiServer(1314);

En la función setup() realizamos la conexión:

 
void setup() 
 
  Serial.begin(115200);
 
  delay(1000);
 
  WiFi.begin(ssid, password);
 
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Conectando..");
  }
 
  Serial.print("Connected to WiFi. IP:");
  Serial.println(WiFi.localIP());
 
  wifiServer.begin();
  

Por último se ejecuta todo en loop()

void loop() {
 
  WiFiClient client = wifiServer.available();
 
  if (client) {
    Serial.println("Client connected");
    while (client.connected()) {
 	  
      // Función donde se obtienen los datos del sensor.
      client.print(getADXL());
      delay(10);
    }
 
    client.stop();
    Serial.println("Client disconnected");
 
  }
}

Ahora que sabemos como se conecta a nuestra red wifi,tenemos que averiguar la IP del dispositivo. La opción más sencilla es abrir el monitor serial y esperar la confirmación de conexión con la red que hayamos definido en YOUR_SSID y PASSWORD. Otra opción es mirar que dirección IP nos asigno el router.

Si utilizas el IDE de Arduino tras la confirmación se mostrará la IP del dispositivo ESP8266.

Monitor serial

El resto de información confirma que el sensor ADXL345 esta funcionando correctamente. Ahora podemos desconectar el ESP8266 y conectarlo a una fuente externa como una powerbank. Una vez que lo conectes se volverá a cargar la IP que nos dio el monitor serial.

Cliente ADXL345 Interface Axis

Por la parte del cliente, este programa creado con Python y la librería gráfica Tkinter. Consta de dos archivos, main_adxl345.py y class_cliente_adxl345.py.

• main_adxl345.py es el encargado de dibujar la interfaz y las funciones que manejan los datos del sensor.
• class_cliente_adxl345.py se encarga de la conexión wi-fi con el microcontrolador con el servicio socket server.
  

La interfaz:

Esta es la ventana principal donde se mostraran los datos que recibimos desde el ESP8266. Lo ejecutamos usando el comando:

python3 -m main_adxl345

Es bastante sencilla, en la parte izquierda es donde esta el canvas para representar los ejes y la parte derecha están los apartados de conexión y el muestreo de los datos.

En el apartado "socket connection" es donde hay que introducir la IP que nos ha proporcionado Arudino IDE en el monitor serial y pulsar el botón "start conn".

Si todo esta correcto, la pantalla empezará a mostrar los datos y representar en la pantalla los ejes del sensor. Podemos hacer que se muestren o no las lineas de cada eje de una manera independiente con los check button situados bajo el frame de recepción de datos.

 

 

ADXL345 Interface Axis es un programa sencillo con el que podremos ver los ejes de un sensor ADXL 345 de una manera visual, un código sencillo y reutilizable. De hecho con unas pocas modificaciones lo he usado para mi próximo ejemplo con un sensor GPS 6MV2 y representar sus datos. 

Programa de ejemplo de este articulo en GitHub

 

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

Muestra el estado del sistema Raspberry Pi

Raspberry pi PWM

Espero que os guste el contenido, Saludos!!

ESP8266 y ADXL345 acelerómetro de 3 ejes. Lectura Serial

ADXL345

Buenas a todos!! El ADXL345 es un sensor súper versátil en campos como la robótica, drones o sistemas de seguridad.

Pues tengo varias ideas para el pero por el momento es mejor hablar sobre que es el sensor ADXL345 y cuales son sus características más destacadas.

¿Que es el sensor ADXL345?

El sensor ADXL345 es un acelerómetro digital de 3 ejes ampliamente utilizado en aplicaciones muy diversas, desde drones y robots hasta dispositivos portátiles y sistemas de control industrial. El sensor ADXL345 tiene una muy popular gracias a su alta precisión, bajo consumo de energía y facilidad de uso.

Las aplicaciones típicas para el sensor ADXL345:

• Detección de movimiento: Detección de movimiento: En sistemas de seguridad, juegos, interfaces gestuales.
• Control de orientación: Control de orientación: En drones, robots, estabilizadores de imagen.
• Monitoreo de vibraciones: En maquinaria industrial, equipos de diagnóstico.
• Interfaz hombre-máquina: En dispositivos portátiles, controles remotos.
• Reconocimiento de patrones de movimiento: En aplicaciones de fitness, rehabilitación.

Principales Características técnicas funcionalidades:

• Consumo de 23uA en modo de medición y 0.1uA en modo standby
• Voltaje en un rango de 2.0V a 3.6V (ADXL345 funciona a 3,3V)
• Conexión SPI de 3 o 4 lineas e interfaces I2C
• Resolución fija de 10-bits y una máxima de 13-bits
• Temperatura de uso -40º hasta +85º

Las principales funcionalidades del sensor ADXL345 pueden ser:

• Medición de Aceleración: Mide la aceleración en los tres ejes del espacio (X, Y, Z), así permite determinar la orientación, inclinación o movimiento de un objeto.
• Rango de medición configurable: Permite mediciones de ±2g, ±4g, ±8g y ±16g, adaptándose a diferentes aplicaciones.
• Alta Resolución: Con una resolución de hasta 13 bits, lo que se traduce en una alta precisión en la medición de la aceleración.
• Bajo Consumo de Energía: Consume muy poca energía, tanto en modo de medición como en modo de espera, con consumos tan reducidos es ideal para dispositivos alimentados por batería.
• Comunicación: Puede comunicarse a través de interfaces I2C o SPI.
• Regulador de Voltaje Integrado: Incorpora un regulador de voltaje interno, simplificando el diseño del circuito.
• Tasa de muestreo configurable: Permite ajustar la frecuencia a la que se toman las medidas
• Interrupciones configurables: Se puede configurar para generar interrupciones cuando se detectan ciertos eventos, como una aceleración determinada o un cambio de orientación.

¿Cómo Funciona?

El ADXL345 utiliza micro-condensadores que se desplazan físicamente cuando se aplica una fuerza (aceleración). Este desplazamiento cambia la capacitancia de los condensadores, lo que se traduce en una señal eléctrica que es convertida a un valor digital por un convertidor analógico-digital (ADC) interno.

En esta señal digital es donde se encuentran los datos que utilizaremos para representar las coordenadas X Y Z

Como usar el sensor ADXL345

Para utilizar el sensor ADXL345 de una manera más amigable tenemos disponibles varias librerías que simplifican su uso y que como comentamos mas arriba, nos permitirá tanto lectura de datos como programar eventos. Estas son las librerías más populares:

• Adafruit ADXL345 library: Es una de las librerías más conocidas y documentadas, desarrollada por Adafruit Industries.

  Esta librería ofrece una amplia gama de funciones para configurar y leer datos del sensor, como establecer el rango de medición, ajustar la tasa de muestreo y leer los valores de aceleración en los tres ejes. Es muy fácil de usar gracias a su interfaz es intuitiva y bien estructurada, lo que facilita su integración en tus proyectos.

• SparkFun ADXnodemcu adxl 345L345 library: Muy similar a la librería de Adafruit pero desarrollada por SparkFun Electronics.

  Esta librería comparte muchas similitudes con la de Adafruit y puede incluir algunas funciones adicionales o variaciones en la implementación, pero en general, su funcionalidad es prácticamente la misma.

• Jarzebski Arduino ADXL345: Esta librería ofrece algunas funciones más avanzadas, como la detección de caídas libres y la detección de golpes y una mayor personalización de la configuración del sensor. Incluye gravedades como Marte, la Luna o el sol. No es la más conocida pero merece la pena darle un vistazo.

Opciones avanzadas:

Para el ejemplo del sensor ADXL345 vamos a utilizar la librería Adafruit ADXL345 library conectado a un microcontrolador ESP8266 NodeMCU por protocolo I2C. El sensor es alimentado por los 3.3V que ofrece el microcontrolador y el NodeMCU se alimenta por el mismo cable USB por donde recibiremos los datos.

El ejemplo es el mismo que aparece en su web así que no pondré parte del ejemplo que esta en la misma librería. Una vez cargado el programa pasará por los siguientes procesos:

• Creamos el sensor:

  
      /* Crea el sensor. 12345 asigna una ID unica para el sensor*/
      Adafruit_ADXL345_Unified accel = Adafruit_ADXL345_Unified(12345);
      
      

• En el apartado void setup() inicializamos el sensor y seleccionamos el rango:

  
        /* Inicializa el sensor */
        if(!accel.begin()) {
        	/* Hay un problema al conectar ADXL345 ... compruebe las conexiones... */
        	Serial.println("Ooops, no ADXL345 detected ... Check your wiring!");
        	while(1);
        }
        
        /* Selecciona el rango apropiado para tu proyecto */
        accel.setRange(ADXL345_RANGE_16_G);
      
      

• Una vez en el loop tomamos los eventos para luego mostrarlos en el monitor serial. Los datos se acualizan cada 500ms.

  
      void loop(void) {
      /* Get a new sensor event */ 
      sensors_event_t event;
      accel.getEvent(&event);
      
      /* Display the results (acceleration is measured in m/s^2) */
      Serial.print("X: "); Serial.print(event.acceleration.x); Serial.print("  ");
      Serial.print("Y: "); Serial.print(event.acceleration.y); Serial.print("  ");
      Serial.print("Z: "); Serial.print(event.acceleration.z); Serial.print("  ");Serial.println("m/s^2 ");
      delay(500);
      }
      
      

Con todo funcionando tenemos que tener una salida en el monitor similar a esta:

Accelerometer Test

------------------------------------
Sensor:       ADXL345
Driver Ver:   1
Unique ID:    12345
Max Value:    -156.91 m/s^2
Min Value:    156.91 m/s^2
Resolution:   0.04 m/s^2
------------------------------------

Data Rate:    100  Hz
Range:         +/- 16  g

X: 0.47  Y: -1.18  Z: 12.20  m/s^2 
X: 0.59  Y: -1.06  Z: 12.32  m/s^2 
X: 0.51  Y: -1.10  Z: 12.28  m/s^2 
X: 0.59  Y: -1.14  Z: 12.24  m/s^2 
X: 0.08  Y: -0.71  Z: 12.24  m/s^2 
X: 10.16  Y: -1.22  Z: 2.51  m/s^2 
X: 10.40  Y: -0.90  Z: 2.51  m/s^2

Salida serial ESP8266 NodeMCU y ADXL3345

Es realmente sencillo conectar el sensor a cualquier microcontrolador que admita protocolo I2C además de tener la opción SPI. Espero que este ejemplo os sirva de ayuda para futuros proyectos

Hoja de datos: ADXL345 DataSheet

Saludos!!!

WLED el mejor control para tus tiras LED

WLED es un firmware de código abierto que te permite controlar tiras de LED digitales RGB con un microcontrolador ESP8266 o ESP32.

Es una de las mejores alternativas a los controladores LED tradicionales, ya que ofrece una gran flexibilidad y personalización a través de una interfaz web intuitiva.

Empecemos!

¿Que son los LEDS WS2812B?

Una tira de LED direccionables es un tipo de tira de LED que te permite controlar el color y el brillo de cada LED individual. La más popular es la denominada WS2812B y es la tira de led que he usado en varios proyectos con unos resultados totalmente satisfactorios. Uno de ellos es la iluminación para la caja del PC.

Repetidor Wifi con ESP8266

Muy buenas a todos y todas los amantes de los microcontroladores!!!

Últimamente estoy usando mucho este tipo de chips, tanto el ESP8266 como el ESP32 ya que tienen una mejor conectividad necesaría para casi cualquier proyecto relacionado IOT (el internet de las cosas).

Antes de empezar podemos ver en la tabla las características técnicas relacionadas con la conectividad:

Diferencias de conectividad entre ESP8266 y ESP32:

Característica	ESP8266	ESP32
Wi-Fi Estándar	802.11 b/g/n	802.11 b/g/n
Banda	2.4 GHz	2.4 GHz
Modos Wi-Fi	STA/AP	STA/AP/STA+AP
Bluetooth	✘ No	✔️ BLE 4.2 + Classic

El problema:

Debido a la distancia entre el router y la habitación donde normalmente uso el PC en la maqueta provoca que haya múltiples desconexiones y conexiones con el router haciendo casi imposible tener una conexión estable.

Ya tengo otro repetidor comercial para el ordenador, pero quería separar las redes para poder hacer pruebas y no interferir en la de casa. Y como tengo también unas cuantas baterías de tipo 18650, la idea es hacerlo para poder usarlo también fuera de casa.

Para probar este proyecto he usado el microcontrolador ESP8266 en su versión NodeMcu V3.

Los archivos necesarios están en formato .bin así que he utilizado la herramienta "esptool.py".

Podemos instalar esptool.py desde el terminal con:

sudo apt install esptool

Programación directa del módulo ESP8266 con Arduino UNO o NANO

Buenas a todos!!!

Últimamente no ando mucho por el blog ya que he estado liado con otros proyectos de mi otra web lamaquetade.infotronikblog.com y un programa para Android llamado DCCpp Cab para el control de maquetas ferroviarias en sistema digital DCC.

ESP8266 con divisor de tensión en RX
y listo para ser usado como
servidor webSockets

La central utiliza la comunicación serial para recibir y mandar los datos y ahí es donde entra el ESP8266 como intermediario, además ya lo había usado en algunos proyectos tales como:

• Como actualizar el firmware del ESP8266 con Arduino Nano.
  
  
• Comandos AT para modulo ESP8266.
  
  
• Arduino ESP8266 servidor web con DTH11 y sensor de humedad en tierra.
  
  

Pero en todos estos proyectos siempre programo Arduino para que sea él el que se comunica y daba las ordenes al ESP8266 tales como la red wifi, SSID y Password. De esta manera, todas esas ordenes quedaban guardadas directamente en la memoria del ESP8266.

Manos a la obra, ¿que necesitamos?

Materiales necesarios:

Antes de montar ningún circuito, tenemos que instalar en el IDE de Arduino para ello lo primero es abrir el IDE de Arduino e ir a "archivos ==> Preferencias":

Arduino ESP8266 servidor web con DHT11 y sensor de humedad en tierra

Buenas a todos!!!
Estamos otra vez por aquí  con nuevos ejemplos. En este caso estoy probando una pequeña estación meteorológica  con Arduino y el módulo ESP8266.
Si bien he tenido que mirar muchas páginas y diferentes ejemplos hasta encontrar el que más a mi modo de ver fácil y con un funcionamiento de notable.

Tuve bastantes problemas con un fallo llamado "busy s..." incluso después de haber actualizado la versión del Firmware a la versión 0.9.2.2 tuve que volver a actualizar a la versión 1.3.0.
Toda la información sobre como actualizar el Firmware del modulo ESP8266 la podéis encontrar aquí.


Para este ejemplo he utilizado los siguientes componentes

• Arduino Nano
• Módulo WiFi ESP8266
• Sensor DHT11 Temperatura y Humedad
• Sensor SMS  (Soil Moisure Sensor) Sensor de humedad en suelo.
  
  
  
  
  

Una vez abierto el Programa al final del archivo .ino encontrareis una linea llamada: