Registrador GPS Arduino: 3 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:43

Hola tios, Me emocionan mucho los pequeños proyectos que permiten a las personas comprender mucho más de la tecnología que tenemos a diario.

Este proyecto trata sobre la ruptura de GPS y el registro SD. Aprendí mucho simplemente construyendo estas cosas.

Hay muchas nociones que obtendrá siguiendo este tutorial, y muchas más siguiendo el enlace que proporciono para profundizar en los temas.

Entonces, ¿qué es eso? Simple: es un rastreador GPS que registra posiciones (con altitud también), velocidad y fecha / hora en una microSD.

Que necesitarás:

Arduino nano a 5x7cm) - Alambres

Todos esos componentes son bastante baratos, excepto el módulo GPS. Eso es alrededor de 30-40 dólares y es la parte más cara. Incluso un nuevo juego de cautín podría costar menos.

También existe un escudo Adafruit con módulos de tarjeta SD y GPS juntos. Si desea usarlo, tenga en cuenta que está hecho para Arduino UNO, por lo tanto, necesitará un UNO y no un Nano. Sin embargo, no hay diferencia en el boceto.

Vayamos más allá …

Paso 1: Conexión de componentes

Bueno, después de obtener los componentes, deberá conectarlos. Aquí puede encontrar los esquemas fritzing que son bastante claros. Sin embargo, aquí está el pinout también:

Rotura de microSD

5V -> 5VGND -> GnnCLK -> D13DO -> D12DI -> D11CS -> D4 (Si está usando el escudo, este está integrado en D10)

Rotura de GPS

Vin -> 5VGnn -> GnnRx -> D2Tx -> D3

Pequeñas notas sobre ese módulo: esos dos niños pequeños se comunican a través de diferentes caminos con el Arduino. El GPS usa un TTL Serial, del mismo tipo que usamos cuando nos comunicamos con Arduino a través de Serial Monitor, por eso tenemos que declarar a través de una biblioteca un nuevo serial (Tx y Rx) porque GPS quiere usar el 9600 por defecto, y nosotros quiero usarlo tampoco. El módulo GPS está transmitiendo datos siempre y constantemente, si está conectado. Esta es la parte difícil de manejar, porque si leemos una oración y luego la imprimimos, podríamos perder la siguiente, que también es necesaria. ¡Tenemos que tenerlo en cuenta a la hora de codificar!

La MicroSD se comunica a través de SPI (Serial Peripheral Interface), otra forma de comunicarse con la placa. Ese tipo de módulo usa siempre CLK en el D13, DO en el D12 y DI en el D11. A veces, esas conexiones tienen un nombre diferente como CLK = SCK o SCLK (reloj serie), DO = DOUT, SIMO, SDO, SO, MTSR (todos indican salida maestra) y DI = SOMI, SDI, MISO, MRST (entrada maestra). Finalmente tenemos el CS o SS que indica el pin donde enviamos lo que queremos escribir en la MicroSD. Si desea utilizar dos módulos SPI diferentes, solo tiene que diferenciar este pin para poder utilizar ambos. Por ejemplo, pantalla LCD Y un MicroSd como el que estamos usando. Debería funcionar también con dos pantallas LCD diferentes conectadas a diferentes CS.

Suelde estas partes juntas en el tablero y estará listo para cargar el boceto.

Como puede ver en el boceto, sueldo algunos conectores hembra dupont en lugar del componente directo, eso se debe a que en el futuro es posible que desee reutilizar el componente o cambiar uno.

También soldé el módulo GPS con los conectores en la dirección equivocada, eso fue mi culpa y no quise hacerlo, pero funciona y no quiero arriesgarme a romperlo tratando de desoldar a esos pequeños bastardos! ¡Solo suelde de la manera correcta y todo estará bien!

Aquí algunos videos de soldadura útiles: Guía de soldadura para principiantes Un video sobre desoldar

Canal de Youtube de Adafruit, ¡hay muchas cosas interesantes allí!

Cuando suelde, intente usar solo la cantidad de metal que necesita, de lo contrario, hará un desastre. No tenga miedo de hacerlo, tal vez comience con algo no tan caro y luego siga soldando cosas diferentes. ¡El material adecuado también marca la diferencia!

Paso 2: ¡El boceto

Primero, por supuesto, importamos la biblioteca y construimos sus objetos para trabajar con: SPI.h es para comunicarse con módulos SPI, SD es la biblioteca MicroSD y Adafruit_GPS es la biblioteca del módulo GPS. SoftwareSerial.h sirve para crear un puerto serie mediante software. La sintaxis es "mySerial (TxPin, RxPin);". El objeto GPS debe apuntar a una serie (entre paréntesis). Aquí están los enlaces de las bibliotecas para la ruptura de Adafruit GPS, la ruptura de MicroSD (para hacer un trabajo limpio, también debe formatear la SD con este software de la asociación SD) y el Biblioteca de software en serie (debe incluirse en el IDE).

NOTA: Enfrenté algún problema al intentar agregar mucha información en un archivo o al usar más de dos archivos en el boceto. No formateé la SD con ese software, tal vez eso podría resolver el problema. Además, intenté agregar otro sensor en el dispositivo, un BMP280 (módulo I2C), sin éxito. ¡Parece que usar el módulo I2C hace que el boceto se vuelva loco! Ya pregunté al respecto en el foro de Adafruit, pero todavía no obtuve respuesta.

#incluya "SPI.h" #incluya "SD.h" #incluya "Adafruit_GPS.h" #incluya "SoftwareSerial.h" SoftwareSerial mySerial (3, 2); Adafruit_GPS GPS (y mySerial);

Ahora necesitamos todas nuestras variables: las dos cadenas son para leer las dos oraciones que necesitamos para calcular un montón de información útil del GPS. El char es para almacenar las oraciones antes de analizarlas, los flotadores son para calcular las coordenadas en grados (el GPS envía usa coordenadas en grados y minutos, las necesitamos en grados para que las lea en google earth). El chipSelect es el pin donde conectamos el CS de la tarjeta MicroSD. En este caso es D4, pero si está usando un escudo SD, tendrá que poner D10 aquí. La variable de archivo es la que almacenará la información del archivo que estamos usando durante el boceto.

String NMEA1;

String NMEA2; char c; grado de flotación; flotar degWhole; float degDec; int chipSelect = 4; File mySensorData;

Ahora declaramos un par de funciones fo para hacer que el boceto sea un poco más elegante y menos desordenado:

Están haciendo básicamente lo mismo: leer oraciones NMEA. clearGPS () ignora tres oraciones y readGPS () guarda dos de ellas en las variables.

Veamos cómo: Un bucle while controla si hay nuevas sentencias NMEA en el módulo y lee el flujo de GPS hasta que hay una. Cuando hay una nueva oración, salimos del ciclo while, donde la oración se lee, analiza y almacena en las primeras variables NMEA. Inmediatamente estamos haciendo lo mismo para el siguiente, porque el GPS está en constante transmisión, no está esperando que estemos listos, no tenemos tiempo para imprimirlo de inmediato.

¡Esto es muy importante! No hagas nada antes de almacenar ambas oraciones, de lo contrario, la segunda eventualmente se dañaría o simplemente estaría mal.

Después de obtener dos oraciones, las imprimimos en la serie para controlar que vaya bien.

void readGPS () {

clearGPS (); while (! GPS.newNMEAreceived ()) {c = GPS.read (); } GPS.parse (GPS.lastNMEA ()); NMEA1 = GPS. ÚltimoNMEA (); while (! GPS.newNMEAreceived ()) {c = GPS.read (); } GPS.parse (GPS.lastNMEA ()); NMEA2 = GPS. ÚltimoNMEA (); Serial.println (NMEA1); Serial.println (NMEA2); } void clearGPS () {while (! GPS.newNMEAreceived ()) {c = GPS.read (); } GPS.parse (GPS.lastNMEA ()); while (! GPS.newNMEAreceived ()) {c = GPS.read (); } GPS.parse (GPS.lastNMEA ()); w while (! GPS.newNMEAreceived ()) {c = GPS.read (); } GPS.parse (GPS.lastNMEA ()); }

Bueno, ahora que estamos listos, podemos completar la configuración ():

Primero: abrimos la comunicación en Serial 115200 para Arduino PC y en 9600 para el módulo GPS Arduino. Segundo: enviamos tres comandos al módulo GPS: el primero es apagar la actualización de la antena, el segundo es para pedir solo la cadena RMC y GGA (vamos a usar solo aquellos, que tienen toda la información que necesitaría de un GPS), el tercer y último comando es establecer la tasa de actualización en 1HZ, sugerido por Adafruit.

Después de eso, configuramos el pin D10 en OUTPUT, si, y solo si, el pin CS de su modelo SD es diferente a D10. Inmediatamente después, configure el CS en el módulo SD en el pin chipSelect.

Ejecutamos las funciones readGPS () que incluyen el cleanGPS ().

¡Ahora es el momento de escribir algo en los archivos! Si el archivo ya está en la tarjeta Sd, agregue una marca de tiempo en ellos. De esta manera no tenemos que hacer un seguimiento de las sesiones o borrar los archivos cada vez. Con una marca de tiempo escrita dentro de la función de configuración, estamos seguros de que solo agregaremos una separación en los archivos solo una vez por sesión.

NOTA: ¡La biblioteca SD es bastante seria acerca de abrir y cerrar el archivo cada vez! ¡Téngalo en cuenta y ciérrelo siempre! Para obtener más información sobre la biblioteca, siga este enlace.

Bien, realmente estamos listos para obtener el núcleo de la parte de flujo y registro del boceto.

configuración vacía () {

Serial.begin (115200); GPS.begin (9600); // Enviar comandos al módulo GPS GPS.sendCommand ("$ PGCMD, 33, 0 * 6D"); GPS.sendCommand (PMTK_SET_NMEA_OUTPUT_RMCGGA); GPS.sendCommand (PMTK_SET_NMEA_UPDATE_1HZ); retraso (1000); // solo si el pin CS de su módulo SD no está en el pin D10

pinMode (10, SALIDA);

SD.begin (chipSelect); readGPS (); if (SD.exists ("NMEA.txt")) {mySensorData = SD.open ("NMEA.txt", FILE_WRITE); mySensorData.println (""); mySensorData.print ("***"); mySensorData.print (GPS.day); mySensorData.print ("."); mySensorData.print (GPS.month); mySensorData.print ("."); mySensorData.print (GPS.year); mySensorData.print ("-"); mySensorData.print (GPS.hora); mySensorData.print (":"); mySensorData.print (GPS.minute); mySensorData.print (":"); mySensorData.print (GPS.seconds); mySensorData.println ("***"); mySensorData.close (); } si (SD.exists ("GPSData.txt")) {mySensorData = SD.open ("GPSData.txt", FILE_WRITE); mySensorData.println (""); mySensorData.println (""); mySensorData.print ("***"); mySensorData.print (GPS.day); mySensorData.print ("."); mySensorData.print (GPS.month); mySensorData.print ("."); mySensorData.print (GPS.year); mySensorData.print ("-"); mySensorData.print (GPS.hora); mySensorData.print (":"); mySensorData.print (GPS.minute); mySensorData.print (":"); mySensorData.print (GPS.seconds); mySensorData.println ("***"); mySensorData.close (); }}

Ahora tenemos el núcleo del boceto.

De hecho, es súper simple.

Vamos a leer el flujo de GPS con la función readGPS (), de lo que controlamos si tenemos una corrección igual a 1, lo que significa que estamos conectados con un satélite. Si lo conseguimos, escribiremos nuestra información en los archivos. En el primer archivo "NMEA.txt", escribimos solo las oraciones sin formato. En el segundo archivo, "GPDData.txt", agregamos las coordenadas (convertidas con las funciones que vimos antes) y la altitud. Esa información es suficiente para compilar un archivo.kml para crear una ruta en Google Earth. Tenga en cuenta que cerramos los archivos cada vez que los abrimos para escribir algo.

bucle vacío () {

readGPS (); // Condizione if che controlla se l'antenna ha segnale. Se si, procede con la scrittura dei dati. if (GPS.fix == 1) {// Solo guarda datos si tenemos un arreglo mySensorData = SD.open ("NMEA.txt", FILE_WRITE); // Apre il archivo per le frasi NMEA grezze mySensorData.println (NMEA1); // Scrive prima NMEA sul file mySensorData.println (NMEA2); // Escriba en segundo lugar el archivo NMEA sul mySensorData.close (); // ¡¡Archivo Chiude !!

mySensorData = SD.open ("GPSData.txt", FILE_WRITE);

// Converte e scrive la longitudine convLong (); mySensorData.print (grados, 4); // Coordenadas del archivo de escritura en el archivo de gradi sul mySensorData.print (","); // Scrive una virgola per separare i dati Serial.print (deg); Serial.print (","); // Converte e scrive la latitudine convLati (); mySensorData.print (grados, 4); // Coordenadas del archivo de escritura en el archivo gradi sul mySensorData.print (","); // Scrive una virgola per separare i dati Serial.print (deg); Serial.print (","); // Scrive l'altitudine mySensorData.print (GPS.altitude); mySensorData.print (""); Serial.println (GPS.altitude); mySensorData.close (); }}

Ahora que hemos terminado, puede cargar el boceto, construir el dispositivo y disfrutarlo.

Tenga en cuenta que debe usarlo con la borad GPS orientada hacia el cielo para obtener una corrección = 1, o puede conectarle una antena externa.

Además, tenga en cuenta que si tiene una solución, la luz roja parpadeará cada 15 segundos, si no, mucho más rápido (una vez cada 2-3 segundos).

Si desea aprender algo más sobre las oraciones NMEA, simplemente siga el siguiente paso de esta guía.

Paso 3: las sentencias NMEA y el archivo.kml

El dispositivo y el boceto están completos, funcionan bien. Tenga en cuenta que para obtener una solución (para tener una conexión con satélites), la fuga debe mirar hacia el cielo.

La pequeña luz roja parpadea cada 15 segundos cuando tienes una solución

Si desea comprender mejor las oraciones NMEA, puede leer más.

En el boceto usamos solo dos oraciones, la GGA y la RMC. Son solo un par de frases que transmite el módulo GPS.

Veamos qué hay en esa cadena:

$ GPRMC, 123519, A, 4807.038, N, 01131.000, E, 022.4, 084.4, 230394, 003.1, W * 6A

RMC = Sentencia mínima recomendada C 123519 = Corrección tomada a las 12:35:19 UTC A = Estado A = activo o V = Anulado 4807.038, N = Latitud 48 grados 07.038 'N 01131.000, E = Longitud 11 grados 31.000' E 022.4 = Velocidad sobre el suelo en nudos 084.4 = Ángulo de seguimiento en grados Verdadero 230394 = Fecha - 23 de marzo de 1994 003.1, W = Variación magnética * 6A = Los datos de la suma de control, siempre comienzan con *

$ GPGGA, 123519, 4807.038, N, 01131.000, E, 1, 08, 0.9, 545.4, M, 46.9, M, * 47

Datos de corrección del sistema de posicionamiento global GGA 123519 Corrección tomada a las 12:35:19 UTC 4807.038, N Latitud 48 grados 07.038 'N 01131.000, E Longitud 11 grados 31.000' E 1 Calidad de corrección: 0 = no válido; 1 = posición GPS (SPS); 2 = posición DGPS; 3 = PPS fijo; 4 = Cinemática en tiempo real; 5 = RTK flotante; 6 = estimado (navegación a estima) (característica 2.3); 7 = modo de entrada manual; 8 = modo de simulación; 08 Número de satélites rastreados 0.9 Dilución horizontal de la posición 545.4, M Altitud, Metros, sobre el nivel medio del mar 46.9, M Altura del geoide (nivel medio del mar) por encima del elipsoide WGS84 (campo vacío) tiempo en segundos desde la última actualización de DGPS (campo vacío) Número de identificación de la estación DGPS * 47 los datos de la suma de control, siempre comienzan con *

Como puede ver, hay mucha más información de la que necesita allí. Usando la biblioteca de Adafruit, puede llamar a algunos de ellos, como GPS.latitude o GPS.lat (latitud y hemisferio lat), o GPS.day/month/year/hour/minute/seconds/miliseconds … Eche un vistazo a Adafruit sitio web para saber algo más. No está tan claro, pero siguiendo algunas sugerencias en la guía de los módulos GPS, podría encontrar lo que necesita.

¿Qué podemos hacer con los archivos que tenemos? Fácil: compila un archivo kml para mostrar una ruta en Google Earth. Para hacerlo, simplemente copie / pegue el código que encontrará siguiendo este enlace (debajo del párrafo Ruta), coloque sus coordenadas del archivo GPDData.txt entre las etiquetas, guarde el archivo con la extensión.kml y cárguelo en Google Earth.

NOTA: El lenguaje de marcado.kml es simple, si ya sabe qué es un lenguaje de marcado, tómese su tiempo para leer el enlace anterior y la documentación que contiene, ¡es realmente interesante!

El uso del kml se trata de conocer sus etiquetas y argumentos. Encontré solo la guía de Google, la que vinculé antes y lo esencial es definir el estilo entre las etiquetas y llamarlo con el signo # cuando llegue el momento de escribir las coordenadas.

El archivo que agregué en esta sección es un.kml en el que puede pegar sus coordenadas. recuerde pegar con esta sintaxis: longitud, latitud, altitud