Geolocalización WiFi con Arduino NodeMCU Firebase y Google Maps Deja un comentario
Hace tiempo que los avances en la tecnología nos permiten geolocalizar objetos, dispositivos o personas. Dentro de este área han ido surgiendo diferentes técnicas como el GPS, GSM, UWB o LPWAN. Pero quizás la más útil para los Makers sea la geolocalización WiFi con Arduino y NodeMCU.
En este artículo vas a ver cómo configurar y programar un Arduino MKR1000 o NodeMCU para que a través de la geolocalización WiFi los puedas ubicar en Google Maps.
Google es un recolector de información de todo tipo. Hay opiniones de todo tipo, los que dicen que vulneran nuestra privacidad catalogando a Google como el demonio y los que parecen formar parte de la “secta” y todo les parece bien.
Mi opinión es que dependerá del beneficio que cada uno pueda obtener de esos servicios. Si a cambio de enviar cierta información irrelevante para mi obtengo el beneficio de poder utilizar ciertos servicios, me resulta bastante interesante utilizar Google y pertenecer a la “secta” 🙂
En este artículo te voy a explicar como sacar provecho a varios servicios de Google para poder utilizar la geolocalización WiFi con Arduino MKR1000 y NodeMCU.
¿Qué utilidad tiene la geolocalización WiFi? Aquí es donde entra la imaginación de los Makers. Un uso muy interesante es poder geolocalizar material, maquinaria u objetos de una forma muy económica.
Pero sobre todo nos sirve para aprender cómo utilizar esta tecnología y las herramientas que se utilizan entorno a este proyecto. Nosotros (Germán y yo) lo utilizamos para el proyecto Dash Button Santa presentado en el concurso The Arduino Internet of Holiday Things.
Así que vamos allá, coge tu placa Arduino MKR1000 o NodeMCU y comencemos este tutorial.
Esquema general de la aplicación geolocalización WiFi
Como siempre, es conveniente tener una perspectiva general de lo que vamos a hacer. ¿Te acuerdas del artículo donde hablé del proceso del prototipado?, pues esta parte es donde describimos la idea general.
La idea general es utilizar la capacidad de Arduino MKR1000 y NodeMCU para leer las direcciones MAC y la potencia de la señal de los routers que se encuentren alrededor de la placa. Esta información se la enviarás a la API Location de Google y devolverá una latitud y longitud.
El siguiente paso será almacenar esta información en la plataforma en la nube Firebase. Esto permitirá leer dicha ubicación desde una página web para posicionar el dispositivo en un mapa de Google Maps.
Los pasos que vamos a seguir son los siguientes:
- Obtener una clave de API del servicio Google Maps Geolocation API
- Instalar y probar la librería WiFiLocation
- Configurar la base de datos en Firebase
- Código para conectarnos a la base de datos desde Arduino y NodeMCU
- Interfaz web para mostrar la geolocalización WiFi en Google Maps
¿Qué es la geolocalización WiFi?
Seguro que ya conoces la geolocalización por GPS. Este sistema utiliza satélites para obtener la ubicación de un objeto, dispositivo o persona mediante la triangulación. También se pueden utilizar tecnologías como GSM, UWM o LPWAN.
Todas estas tecnologías requieren de un componente o shield que nos de la capacidad de poder geolocalizar un dispositivo. Con la geolocalización WiFi conseguimos utilizar este tipo de redes para ubicar nuestra placa además de para conectarnos a Internet.
Pero para conseguir esto debes cumplir dos requisitos:
- Necesitas tener una conexión a Internet.
- Necesitas una cuenta de Google.
Google es un recopilador de datos de todo tipo. Los datos por si solos no significan nada pero cuando los interpretamos se convierten en información. Con la geolocalización WiFi ocurre este fenómeno.
¿Quieres montar tu primer proyecto con Arduino?
Con este curso gratuito crearás un Sistema de Riego Automático con Arduino, paso a paso y en sólo una semana.
Cuando se instala un router nuevo en una casa, los propios dispositivos móviles que escuchan o ven esa red WiFi son los encargados de informar de su ubicación a Google. Todo esto se hace gracias a dos parámetros del router, la dirección MAC y la potencia de la señal con la que transmite.
Una dirección MAC (del inglés Media Access Control) es un identificador único de un dispositivo hardware con capacidad de conectarse a una red. Lo importante de esta MAC es que, en principio, es único en todo el mundo.
Por lo tanto, podemos identificar cada router a través de su MAC facilitada por el propio fabricante. Normalmente se puede localizar en la parte trasera del dispositivo.
Cada router emite con una potencia según sus características técnicas. Si conocemos la potencia con la que emite un router por sus antenas y conocemos la potencia con la que nos llega a nuestro dispositivo, podemos saber a que distancia está si aplicamos la formula de atenuación de la señal con respecto a la distancia.
Esta técnica no es una ciencia exacta debido a las reflexiones y obstáculos que hay entre el emisor (router) y receptor (dispositivo). Sin embargo, nos dará la ubicación bastante aproximada de donde está el dispositivo. Se consigue una precisión de entre 10 y 100 metros, suficiente para nuestros proyectos Makers 🙂
Pero lo más importante es que te permitirá experimentar y aprender cómo funcionan todos los servicios que se ven involucrados.
Google Maps Geolocation API para la geolocalización WiFi
Como ya he comentado, vamos a utilizar la dirección MAC y la potencia de la señal que nos llega de los diferentes routers para hacer la geolocalización WiFi. Esta información se la enviaremos al servicio Google Maps GeoLocation API.
Cuantos más routers le enviemos, mejor será la precisión de la ubicación de nuestro dispositivo. Por supuesto que esto no depende de nosotros, más bien dependerá de donde esté ubicado el dispositivo.
Para utilizar este servicio necesitamos una clave o key de la API de este servicio. Para conseguir esta clave necesitas forzosamente tener una cuenta de Google.
Si ya tienes una cuenta de Google sigue los siguientes pasos y si no la tienes, te puedes crear una fácilmente.
#1 Accede a la consola de desarrolladores de Google, Google Developers Console
Lo primero es hacer login en Google y una vez estés dentro accede a Google Developers Console. Busca Google Maps Geolocation API y pincha en el enlace.
#2 Crea un nuevo proyecto
Para poder obtener una clave de la API debes crear un proyecto. Si es la primera vez que accedes a Google Developers Console no tendrás ninguno creado y ahora es el momento de crear uno.
Pon el nombre que quieras, yo le he puesto geolocalizar-wifi por ejemplo. Este será el ID (identificador único) de tu proyecto. Luego haz click en crear.
Como último paso, debes habilitarlo.
#3 Crear credenciales para el proyecto
Para poder obtener una clave de API hay que crear las credenciales. Básicamente estamos diciendo quién y cómo pueden acceder al proyecto. Haz click en Crear credenciales.
Al hacer click se abre una nueva ventana donde debes elegir el tipo de credenciales. En nuestro caso selecciona Google Maps Geolocation API (el que viene por defecto) y luego haz click en ¿Qué credenciales necesito?
En la siguiente ventana te muestra la clave de API. No hace falta que la copies todavía, luego podrás acceder a ella. Ahora solo queda hacer click en Listo.
En la opción del menú Credenciales tienes acceso a todas las claves de API que hayas creado. Desde aquí podrás modificar y eliminar cualquier clave de API.
Con esto ya estaría todo listo en Google Developers Console. Más adelante necesitaremos la clave de API pero por el momento no.
Instalar librería WiFiLocation para la geolocalización WiFi
WiFiLocation es una librería que creo Germán Martín para poder comunicarnos con el servicio Google Maps GeoLocation API.
Lo que hace esta librería es enviar la información de las direcciones MAC, la potencia de la señal y el canal a través de una petición HTTP mediante el método POST.
La función de esta librería (como casi todas) es facilitarnos la vida además de tener el código más ordenado y legible. Ya traté en un artículo cómo instalar librerías en el IDE de Arduino, no es nada nuevo para nosotros.
En este caso vamos a descargar el archivo .zip de GitHub.
Ahora la vamos a instalar a través de la opción de Añadir librería .ZIP…
Selecciona donde hayas guardado la librería WiFiLocation y ya estaría instalada.
Para poder utilizar WiFiLocation necesitamos hacer uso de otra librería es decir, tiene una dependencia. Si estás trabajando con un Arduino MKR1000 necesitas tener instalado WiFi101. Si utilizas NodeMCU necesitas la librería ESP8266WiFi.
¿Quieres montar tu primer proyecto con Arduino?
Con este curso gratuito crearás un Sistema de Riego Automático con Arduino, paso a paso y en sólo una semana.
Como instalar y utilizar estas dos librerías te lo contamos en estos dos artículos:
Si todo ha ido bien y nos has tenido ningún problema en la instalación ya estás listo para probar la librería WiFiLocation y hacer la primera geolocalización WiFi, que emoción 🙂
Probar librería para la geolocalización WiFi
Si hay algo que caracteriza a la programación de electrónica con Arduino es la facilidad y rapidez a la hora de probar las cosas. Siempre suelo decir lo mismo, hay que ponerse en acción y no sufrir el típico parálisis por análisis.
Para probar WiFiLocation vamos a utilizar el ejemplo que se instala junto a la librería. Lo puedes abrir accediendo a Archivo/Ejemplos/WiFiLocation/googleLocation.
Esto te abre el siguiente código
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
#ifdef ARDUINO_ARCH_SAMD #include #elif defined ARDUINO_ARCH_ESP8266 #include #else #error Wrong platform #endif #include “WifiLocation.h” #define GOOGLE_KEY “YOUR_GOOGLE_API_KEY” #define SSID “SSID” #define PASSWD “PASSWD” WifiLocation location(GOOGLE_KEY); void setup() { Serial.begin(115200); while (WiFi.status() != WL_CONNECTED) { Serial.print(“Attempting to connect to WPA SSID: “); Serial.println(SSID); // Connect to WPA/WPA2 network: WiFi.begin(SSID, PASSWD); // wait 5 seconds for connection: delay(5000); Serial.print(“Status = “); Serial.println(WiFi.status()); } location_t loc = location.getGeoFromWiFi(); Serial.println(“Location request data”); Serial.println(location.getSurroundingWiFiJson()); Serial.println(“Latitude: “ + String(loc.lat, 7)); Serial.println(“Longitude: “ + String(loc.lon, 7)); Serial.println(“Accuracy: “ + String(loc.accuracy)); } void loop() { } |
Tienes que poner los datos correspondientes a tu red WiFi y a tu clave de API que hemos creado antes. Sustituye los siguientes valores que aparecen entre comillas:
- YOUR_GOOGLE_API_KEY: en la línea 11 sustituye este valor por tu clave de API. Recuerda que la puedes ver en Google Developer Console en el apartado de credenciales.
- SSID: nombre de tu red WiFi.
- PASSWD: contraseña de tu red WiFi.
El ejemplo ya está preparado para que funcione con Arduino MKR1000 y NodeMCU, no tienes que hacer nada más. Carga el código en el Arduino o el NodeMCU y abre el monitor serie. Saldrá algo parecido a esto.
El recuadro azul es la información que le enviamos a Google.
- macAddress: es la dirección MAC de los routers que se encuentran alrededor del dispositivo. En mi caso ha encontrado 9 routers pero en tu caso puede que haya más o menos dependiendo de dónde te encuentres.
- signalStrength: es la potencia de la señal medida en dBm.
- channel: el canal por el que el dispositivo se conecta a cada router.
El recuadro rojo indica la latitud y la longitud donde se encuentra el dispositivo. Accuracy te indica la precisión que en mi caso sería de un radio de 24 metros.
Situar en un mapa con latitud y longitud la geolocalización WiFi
Seguramente no sepas de memoria cual es la latitud y longitud de tu casa o de donde se encuentre el dispositivo y por lo tanto no sabrás si los datos son correctos.
Para comprobar que la ubicación es la correcta puedes utilizar esta página web. Solo tendrás que indicar una latitud y longitud y te mostrará en un mapa donde está situada esa ubicación.
Como ves es relativamente sencillo geolocalizar un dispositivo como Arduino o NodeMCU mediante la WiFi.
Ahora lo que veremos es cómo podemos almacenar esta información en una plataforma en la nube como Firebase para después consultarla desde una página web a través de JavaScript.
Configurar servicio Firebase de Google con Arduino y NodeMCU
Firebase es una plataforma en la nube que pertenece a Google. En principio no está orientada exclusivamente a proyectos del IoT ya que permite alojar webs y otros servicios relacionados. Sin embargo, es una herramienta muy útil para los Makers debido a varias razones.
Por un lado es muy fácil de utilizar (lo irás viendo a lo largo de este tutorial). Por otro lado, nos permite su uso de forma gratuita con restricciones aunque para nuestro propósito es más que suficiente.
Lo primero que vamos a hacer es configurar el servicio. Sigue los siguientes pasos para dejar todo preparado antes de conectarnos con Arduino y NodeMCU.
#1 Accede a la consola de Firebase
Para acceder al servicio gratuito de Firebase debes tener una cuenta de Google. Accede a la home de Firebase y pincha en IR A CONSOLA.
Esto te abrirá el panel de control de Firebase.
#2 Crear un nuevo proyecto con Firebase
Una vez que hemos entrado al panel de control vamos a crear un nuevo proyecto así que haz click en Añadir proyecto.
Esto te abre una nueva pantalla para que rellenes el nombre y la ubicación. En mi caso he puesto el nombre wifi-arduino-nodemcu y el País/Región España.
Una vez seleccionado haz click en CREAR PROYECTO.
#3 Configurar base de datos de Firebase
Una vez creado el proyecto se abre el panel de control. Aquí podrás acceder a las diferentes apartados de configuración y podrás ver el identificador único de tu proyecto (ID).
Vamos a configurar la base de datos, haz click en Database.
Por defecto, la base de datos tiene asignadas unas reglas de acceso que solo permite conectarse a usuarios autentificados en Google. Vamos a modificar estas reglas para que pueda acceder todo el mundo sin restricciones.
Abre la pestaña de reglas en el panel de control de Database.
Debes poner los dos valores read y write a true (verdadero). No te olvides en hacer click en PUBLICAR.
Cuando valides las reglas te saldrá un mensaje de alerta donde dice: Tus reglas de seguridad están definidas como públicas, cualquiera puede leer o escribir en tu base de datos. No te preocupes por esto, de momento vamos a dejarlo así estamos ya que estamos en la fase de pruebas.
Y con esto ya tendríamos configurado Firebase para utilizarlo con Arduino y NodeMCU. Ahora solo falta establecer la estructura con la que vamos a enviar los datos.
Estructura de datos en Firebase para la geolocalización WiFi con Arduino y NodeMCU
La tecnología que utiliza Firebase para sus bases de datos no es una información pública y por lo tanto no sabemos qué motor de base de datos utiliza. Algunos dicen que utilizan MongoDB o cualquier otra base de datos NoSQL.
En realidad a nosotros nos da lo mismo ya que vamos a conectarnos a ella a través de la API. En principio no tenemos que tener ninguna estructura de tablas ni de campos, esto lo haremos enviando un archivo JSON.
La idea es enviar la información de latitud, longitud, el nombre del dispositivo y la precisión. Como clave única (el identificador unívoco de cada dispositivo) utilizaremos la dirección MAC el Arduino MKR1000 o del NodeMCU.
¿Quieres montar tu primer proyecto con Arduino?
Con este curso gratuito crearás un Sistema de Riego Automático con Arduino, paso a paso y en sólo una semana.
Pero ¿de dónde obtenemos toda esta información?
- La latitud, longitud y precisión la obtenemos a través del servicio Google Maps Geolocation API
- El nombre del dispositivo se lo ponemos nosotros. Por ejemplo, sensor temperatura casa, sensor humedad jardín, etc…
- La dirección MAC del dispositivo la obtenemos a través de las librerías WiFi101 y ESP8266WiFi.
Con toda esta información podemos crear un archivo JSON como este.
|
{ “dispositivo” : { “MAC” : { “lat” : 38.3685, “lon” : –0.4219, “prec” : 100999, “nombre” : “MKR1000” } } } |
Esta es la información que enviaremos desde Arduino o NodeMCU a Firebase, ahora veremos cómo hacerlo.
Configuración geolocalización WiFi con Arduino MKR1000 y NodeMCU
Hasta aquí lo que hemos visto es cómo obtener la ubicación (latitud y longitud) a través de la geolocalización WiFi y cómo configurar Firebase. Ahora veremos como enviar esta información a la base de datos a través del código nativo de Arduino.
Por comodidad voy a separar el código de Arduino MKR1000 y de NodeMCU ya que cada uno utiliza su propia librería WiFi. Así quedará más fácil de entender y un código más limpio 😉
Vamos a comenzar con el Arduino MKR1000.
Configuración geolocalización WiFi con Arduino MKR1000
Lo primero que voy a hacer es ordenar y limpiar el código de ejemplo que venía con la librería WiFiLocation. Elimino toda referencia a las librerías de NodeMCU y paso la geolocalización al loop() principal.
Por último he puesto que compruebe la ubicación del dispositivo cada 15 segundos. Este tiempo dependerá de cada proyecto lo ideal es ampliarlo lo máximo posible e incluso poner la placa en deep sleep (modo reposo) mientras no haga nada.
El código sería el siguiente.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
#include #include “WifiLocation.h” // Constantes clave API e información red WiFi #define GOOGLE_KEY “YOUR_GOOGLE_API_KEY” #define SSID “SSID” #define PASSWD “PASSWD” // Llamada a la API de Google WifiLocation location(GOOGLE_KEY); location_t loc; // Estructura de datos que devuelve la librería WifiLocation void setup() { Serial.begin(115200); while (WiFi.status() != WL_CONNECTED) { Serial.print(“Attempting to connect to WPA SSID: “); Serial.println(SSID); // Connect to WPA/WPA2 network: WiFi.begin(SSID, PASSWD); // wait 5 seconds for connection: delay(5000); Serial.print(“Status = “); Serial.println(WiFi.status()); } } void loop() { // Obtenemos la geolocalización WiFi loc = location.getGeoFromWiFi(); // Mostramos la información en el monitor serie Serial.println(“Location request data”); Serial.println(location.getSurroundingWiFiJson()); Serial.println(“Latitude: “ + String(loc.lat, 7)); Serial.println(“Longitude: “ + String(loc.lon, 7)); Serial.println(“Accuracy: “ + String(loc.accuracy)); // Esperamos 15 segundos delay(15000); } |
Acuérdate de sustituir la clave API y el SSID y PASSWD de tu red WiFi. Ahora vamos a incorporar la llamada a la base de datos de Firebase. Esto lo vamos a hacer con una llamada HTTP mediante el método PUT.
Para hacer esta petición necesitarás la URL o HOST donde esté la base de datos de Firebase. Esto lo puedes obtener desde el panel de control de Firebase. Tu tendrás el tuyo según hayas nombrado tu proyecto.
Mi HOST es https://wifi-arduino-nodemcu.firebaseio.com/. Arduino MKR1000 se comportará como un cliente web y hará peticiones HTTP a esa URL.
Con esta información ya podemos montar todo el código necesario para conectarnos a Firebase desde Arduino MKR1000.
Código geolocalización WiFi con Arduino MKR1000 y Firebase
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 |
#include #include “WifiLocation.h” #define GOOGLE_KEY “YOUR_GOOGLE_API_KEY” // Clave API Google Geolocation #define SSID “SSID” // SSID de tu red WiFi #define PASSWD “PASSWD” // Clave de tu red WiFi #define HOSTFIREBASE “HOST-FIREBASE” // Host o url de Firebase #define LOC_PRECISION 7 // Precisión de latitud y longitud // Llamada a la API de Google WifiLocation location(GOOGLE_KEY); location_t loc; // Estructura de datos que devuelve la librería WifiLocation // Variables byte mac[6]; String macStr = “”; String nombreComun = “ARDUINO MKR1000”; // Cliente WiFi WiFiClient client; void setup() { Serial.begin(115200); // Conexión con la red WiFi while (WiFi.status() != WL_CONNECTED) { Serial.print(“Attempting to connect to WPA SSID: “); Serial.println(SSID); // Connect to WPA/WPA2 network: WiFi.begin(SSID, PASSWD); // wait 5 seconds for connection: delay(5000); Serial.print(“Status = “); Serial.println(WiFi.status()); } // Obtenemos la MAC como cadena de texto macStr = obtenerMac(); Serial.print(“MAC MKR1000: “); Serial.println(macStr); } void loop() { // Obtenemos la geolocalización WiFi loc = location.getGeoFromWiFi(); // Mostramos la información en el monitor serie Serial.println(“Location request data”); Serial.println(location.getSurroundingWiFiJson()); Serial.println(“Latitude: “ + String(loc.lat, 7)); Serial.println(“Longitude: “ + String(loc.lon, 7)); Serial.println(“Accuracy: “ + String(loc.accuracy)); // Lanzamos la petición HTTP con el método PUT peticionPut(); // Esperamos 15 segundos delay(15000); } /********** FUNCIÓN PARA OBTENER MAC COMO STRING **********/ String obtenerMac() { // Obtenemos la MAC del dispositivo WiFi.macAddress(mac); // Convertimos la MAC a String String keyMac = “”; for (int i = 0; i < 6; i++) { String pos = String((uint8_t)mac[i], HEX); if (mac[i] <= 0xF) pos = “0” + pos; pos.toUpperCase(); keyMac += pos; if (i < 5) keyMac += “:”; } // Devolvemos la MAC en String return keyMac; } /********** FUNCIÓN QUE REALIZA LA PETICIÓN PUT **************/ void peticionPut() { // Cerramos cualquier conexión antes de enviar una nueva petición client.stop(); client.flush(); // Enviamos una petición por SSL if (client.connectSSL(HOSTFIREBASE, 443)) { // Petición PUT JSON String toSend = “PUT /dispositivo/”; toSend += macStr; toSend += “.json HTTP/1.1rn”; toSend += “Host:”; toSend += HOSTFIREBASE; toSend += “rn” ; toSend += “Content-Type: application/jsonrn”; String payload = “{“lat”:”; payload += String(loc.lat, LOC_PRECISION); payload += “,”; payload += “”lon”:”; payload += String(loc.lon, LOC_PRECISION); payload += “,”; payload += “”prec”:”; payload += String(loc.accuracy); payload += “,”; payload += “”nombre”: “”; payload += nombreComun; payload += “”}”; payload += “rn”; toSend += “Content-Length: “ + String(payload.length()) + “rn”; toSend += “rn”; toSend += payload; Serial.println(toSend); client.println(toSend); client.println(); client.flush(); client.stop(); Serial.println(“Todo OK”); } else { // Si no podemos conectar client.flush(); client.stop(); Serial.println(“Algo ha ido mal”); } } |
Debes poner los parámetros de tu clave de API, SSID y contraseña. En el host de Firebase elimina el https:// y la barra (/) del final. Por ejemplo, en mi caso quedaría de la siguiente manera.
|
#define HOSTFIREBASE “wifi-arduino-nodemcu.firebaseio.com” |
En la petición HTTP enviamos el JSON que hemos visto antes sustituyendo los valores de latitud, longitud, precisión, nombre del dispositivo y la dirección MAC. Esta petición se hace a través de SSL.
Si lo ejecutas y entras a la base de datos de Firebase tendrás algo parecido a esto.
Cada 15 segundos comprobará la ubicación y la actualizará. Como hemos tenido la precaución de utilizar la dirección MAC como clave primaria, no creará un registro nuevo, solo lo actualizará.
Ahora vamos a ver el código con NodeMCU.
Configuración geolocalización WiFi con NodeMCU
Una de las ventajas que tenemos con NodeMCU es que el código es prácticamente el mismo que con Arduino MKR1000. La única diferencia es la utilización de la librería ESP8266WiFi.
Algo a tener en cuenta es el tiempo de espera para mandar la información a Firebase. NodeMCU no tiene un microcontrolador dedicado para la WiFi al contrario que Arduino MKR1000. Esto hace que en ocasiones si realizamos un tiempo de espera largo se produzcan desconexiones.
Debes tener en cuenta esto a la hora de implementar tu código.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 |
#include #include “WifiLocation.h” #define GOOGLE_KEY “YOUR_GOOGLE_API_KEY” // Clave API Google Geolocation #define SSID “SSID” // SSID de tu red WiFi #define PASSWD “PASSWD” // Clave de tu red WiFi #define HOSTFIREBASE “HOST-FIREBASE” // Host o url de Firebase #define LOC_PRECISION 7 // Precisión de latitud y longitud // Llamada a la API de Google WifiLocation location(GOOGLE_KEY); location_t loc; // Estructura de datos que devuelve la librería WifiLocation // Variables byte mac[6]; String macStr = “”; String nombreComun = “NodeMCU”; // Cliente WiFi WiFiClientSecure client; void setup() { Serial.begin(115200); // Conexión con la red WiFi while (WiFi.status() != WL_CONNECTED) { Serial.print(“Attempting to connect to WPA SSID: “); Serial.println(SSID); // Connect to WPA/WPA2 network: WiFi.begin(SSID, PASSWD); // wait 5 seconds for connection: delay(5000); Serial.print(“Status = “); Serial.println(WiFi.status()); } // Obtenemos la MAC como cadena de texto macStr = obtenerMac(); Serial.print(“MAC NodeMCU: “); Serial.println(macStr); } void loop() { // Obtenemos la geolocalización WiFi loc = location.getGeoFromWiFi(); // Mostramos la información en el monitor serie Serial.println(“Location request data”); Serial.println(location.getSurroundingWiFiJson()); Serial.println(“Latitude: “ + String(loc.lat, 7)); Serial.println(“Longitude: “ + String(loc.lon, 7)); Serial.println(“Accuracy: “ + String(loc.accuracy)); // Hacemos la petición HTTP mediante el método PUT peticionPut(); // Esperamos 15 segundos delay(15000); } /********** FUNCIÓN PARA OBTENER MAC COMO STRING **********/ String obtenerMac() { // Obtenemos la MAC del dispositivo WiFi.macAddress(mac); // Convertimos la MAC a String String keyMac = “”; for (int i = 0; i < 6; i++) { String pos = String((uint8_t)mac[i], HEX); if (mac[i] <= 0xF) pos = “0” + pos; pos.toUpperCase(); keyMac += pos; if (i < 5) keyMac += “:”; } // Devolvemos la MAC en String return keyMac; } /********** FUNCIÓN QUE REALIZA LA PETICIÓN PUT **************/ void peticionPut() { // Cerramos cualquier conexión antes de enviar una nueva petición client.stop(); client.flush(); // Enviamos una petición por SSL if (client.connect(HOSTFIREBASE, 443)) { // Petición PUT JSON String toSend = “PUT /dispositivo/”; toSend += macStr; toSend += “.json HTTP/1.1rn”; toSend += “Host:”; toSend += HOSTFIREBASE; toSend += “rn” ; toSend += “Content-Type: application/jsonrn”; String payload = “{“lat”:”; payload += String(loc.lat, LOC_PRECISION); payload += “,”; payload += “”lon”:”; payload += String(loc.lon, LOC_PRECISION); payload += “,”; payload += “”prec”:”; payload += String(loc.accuracy); payload += “,”; payload += “”nombre”: “”; payload += nombreComun; payload += “”}”; payload += “rn”; toSend += “Content-Length: “ + String(payload.length()) + “rn”; toSend += “rn”; toSend += payload; Serial.println(toSend); client.println(toSend); client.println(); client.flush(); client.stop(); Serial.println(“Todo OK”); } else { // Si no podemos conectar client.flush(); client.stop(); Serial.println(“Algo ha ido mal”); } } |
Solo te falta cambiar la clave de API, el SSID, la contraseña y el host de Firebase.
Si lo ejecutas en tu NodeMCU obtendrás algo parecido a esto.
En mi caso tengo dos dispositivos, un Arduino MKR1000 y NodeMCU. Están diferenciados cada uno por la dirección MAC, única para cada uno de ellos.
Bien, ya tenemos nuestro sistema funcionando. Obtenemos la ubicación y la almacenamos en una base de datos. Ahora lo que veremos es cómo visualizar esta información en un mapa de Google a través de una página web.
Interfaz gráfica para mostrar la geolocalización WiFi en Google Maps
El último paso que vamos a ver es cómo mostrar los dispositivos que han utilizado la geolocalización WiFi en un mapa de Google. Todo lo haremos a través de una página web y un archivo de JavaScript que utiliza jQuery.
En la página web mostraremos un mapa y en ese mapa los diferentes dispositivos que hay en la base de datos de Firebase gracias a la librería JavaScript que nos proporciona Firebase.
¿Quieres montar tu primer proyecto con Arduino?
Con este curso gratuito crearás un Sistema de Riego Automático con Arduino, paso a paso y en sólo una semana.
Para mostrar la información con Google Maps necesitamos tener una clave API de este servicio. Esto seguro que te suena :).
Vamos a crear una paso a paso. Recuerda que tienes que tener una cuenta de Google para acceder a este servicio.
#1 Accede a Google Maps API
Desde este enlace accederás al panel de control de Google Maps API. Haz click en Web.
Ahora haz click en OBTÉN UNA CLAVE.
#2 Habilitar clave API Google Maps
Cuando haces click en OBTÉN UNA CLAVE se abre una ventana donde te pide que selecciones un proyecto. Aparecen los dos que hemos creado anteriormente el de Google Maps Geolocation y el de Firebase. Selecciona el primero, el de Google Maps Geolocation API.
Una vez que lo tengas haz click en ENABLE API.
#3 Copia la clave API de Google Maps
Una vez habilitada la API, se abrirá una nueva ventana donde te informa de la clave API. Puedes copiarla o puedes ir a Google Developer Console APIs al apartado de Credenciales y desde allí ver todas las claves API que has creado.
Es conveniente que renombres cada una de ellas para que sepas a que servicio pertenece.
Página web con Google Maps para mostrar geolocalización WiFi
Ahora ya ha llegado el momento de visualizar los dispositivos en un Google Maps. A continuación te dejo la página web que tendrás que copiar en un archivo nuevo y guardarla con extensión .html
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
name=“robots” content=“noindex”>
id=“map”>
|
Sustituye la CLAVE-API-GOOGLE-MAPS por la que has obtenido al habilitar este servicio en Google Maps API.
Archivo JavaScript para mostrar la geolocalización WiFi de los dispositivos
El código HTML anterior no sirve de nada si no creamos un archivo .js donde esté la programación para mostrar los datos en el mapa. Este archivo se tiene que llamar script.js y debe estar en la misma carpeta que el archivo .html anterior.
A continuación te dejo el código JavaScript.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
// Create a firebase reference var dbRef = new Firebase(‘HOST-FIREBASE’); var costumersRef = dbRef.child(‘dispositivo’); var markers = {} //load persons costumersRef.on(“child_added”, function(snap) { // Print to map addNewPerson(snap.val().lat,snap.val().lon,snap.val().nombre); }); //change persons costumersRef.on(“child_changed”, function (snap) { changePerson(snap.val().lat, snap.val().lon, snap.val().nombre); }); /******** GOOGLE MAPS *********/ var map; function initMap() { // Center map var myLatLng = {lat: 38.392101, lng: –0.525467}; map = new google.maps.Map(document.getElementById(‘map’), { center: myLatLng, zoom: 3 }); } function addNewPerson(lat, lon,nombre){ var marker = new google.maps.Marker({ position: new google.maps.LatLng(lat,lon), map: map, title: nombre // Tooltip = MAC address }); markers[key] = marker; } function changePerson(lat, lon, nombre) { marker = markers[key]; marker = new google.maps.Marker({ position: new google.maps.LatLng(lat, lon), map: map, title: nombre // Tooltip = MAC address }); markers[key] = marker; } |
Lo único que tienes que hacer es sustituir la palabra HOST-FIREBASE de la línea 2 por el host o URL de tu base de datos en Firebase. Es el mismo que hemos puesto en el código del Arduino MKR1000 y NodeMCU, pero esta vez es la ruta completa.
Por ejemplo, en mi caso tengo que poner lo siguiente
|
var dbRef = new Firebase(‘https://wifi-arduino-nodemcu.firebaseio.com/’); |
Probando la aplicación geolocalización WiFi con Arduino MKR1000 y NodeMCU
Ya estamos llegando al final. Si abres la página HTML en un navegador y tienes todo bien configurado, te deberá aparecer un mapa del mundo. Haciendo zoom en la ubicación donde tienes tu dispositivo verás un marcador rojo.
Directamente está pintando en el mapa la geolocalización WiFi del dispositivo. En mi caso como tengo dos que, aunque estén ubicados uno al lado de otro, aparecen separados debido a la precisión en cada momento.
¿Quieres montar tu primer proyecto con Arduino?
Con este curso gratuito crearás un Sistema de Riego Automático con Arduino, paso a paso y en sólo una semana.
Conclusiones de la geolocalización WiFi con Arduino MKR1000, NodeMCU y Firebase
Ha sido un tutorial bastante largo donde hemos visto paso a paso cómo utilizar la geolocalización WiFi con Arduino y NodeMCU. Gracias a los servicios que nos proporciona Google podemos utilizar todo esto para nuestros propios proyectos sin coste alguno.
La idea es que tu mismo lo repliques, hagas pruebas y modifiques el código para adaptarlo a tus requisitos. Me alegría mucho saber si lo has utilizado y cómo lo has utilizado. Déjame un comentario aquí abajo 🙂
¿Te parece interesante la geolocalización WiFi con Arduino y NodeMCU?
¿En que proyectos aplicarías la geolocalización WiFi?
Todos los comentarios aquí abajo por favor 😉
Gracias a Shutterstock por ceder los derechos de las siguientes imágenes:
