Если у вас возникли сложности с курсовой, контрольной, дипломной, рефератом, отчетом по практике, научно-исследовательской и любой другой работой - мы готовы помочь.
Предоплата всего
Подписываем
Tutorial Arduino #0009 – Módulo GPS & Display i2C
5
20 mar 2012
Display i2C, Geoduino, GPS
by Pablo Murillo
# ARDUINO – Módulo GPS & Display i2C
Hola amig@s!
Bienvenidos a un nuevo tutorial Arduino, en este caso, el primero de la categoría expertos por la complejidad de programación que alberga, pero no os desaniméis! Estamos aquí para aprender!!
Podéis descargar los archivos necesarios compartiéndonos en las redes sociales!
Parte 1: ¿Que vamos a hacer?
En este tutorial Arduino, vamos a aprender a conectar los módulos GPS que fabrica LIBELIUM, a extraer y comprender las tramadas de datos que recibimos de los GPS y a tratar esa información para sacar por un display con bus i2C la latitud, longitud, altura y hora UTC.
Podríamos haber hecho un programa más enrevesado, pero queríamos dejar clara la manera de trabajar con el módulo para que aprendáis a desarrollar por vosotros mismos!
Veamos en un video el resultado final de este tutorial!
Hilo oficial de este proyecto en el foro de Arduino.cc AQUI
Material necesario para este tutorial:
Parte 2: Diseñando el Hardware…
En este proyecto casi no necesitamos realizar ningún diseño de hardware, por lo que me centraré en explicar la manera de conectar cada uno de los módulos con nuestro Arduino.
Los módulos GPS
Como comentaba al principio, este tutorial sirve para los dos módulos GPS diseñados por LIBELIUM, así que veamos sus diferencias!
En primer lugar tenemos el módulo GPS 1037-A, el cual es modelo más económico, ya que tan solo utiliza el protocolo NMEA (National Marine Electronics Association) para transmitir los datos de posición.
Como veis, las conexiones son muy simples, tan solo tenemos la alimentación, y la conexión serie Rx (Recepción) y Tx (Transmisión) por la que circularán los datos.
En principio solo usaremos el Tx que transmitirá los datos hacia nuestro Arduino, pero podríamos usar el Rx para enviarle una trama al GPS y “dormirlo” mientras no lo utilicemos, algo fundamental si usamos pilas!! O también pre-establecer nuestra posición, altitud, fecha, para que el posicionamiento sea aún más rápido.
Como consejo, recomiendo aislar este módulo en alguna caja de plástico o similar y alejarlo de fuentes electromagnéticas, ya que es algo sensible.
El tiempo que puede tardar en ubicarse puede oscilar entre 5 y 8 minutos en función de las condiciones en las que estemos y el cielo abierto que tengamos a la vista.
Y la tramada recibida en nuestro Arduino sería parecida a la siguiente una vez ubicado:?
|
1 2 3 4 5 6 7 |
$GPGGA,142651.000,4138.39329,N,00053.28085,W,1,05,3.5,272.35,M,51.6,M,,*76 $GPVTG,0.0,T,,M,0.1,N,0.3,K*62 $GPGSA,A,3,10,08,07,02,04,,,,,,,,9.8,3.5,9.2*36 $GPGSV,3,1,10,13,49,047,,10,80,000,30,23,21,061,,16,07,043,*7E $GPGSV,3,2,10,08,42,174,37,07,65,121,39,05,24,303,,02,51,277,35*7C $GPGSV,3,3,10,04,52,213,41,120,71,269,,,,,,,,,*46 $GPGLL,4138.393,N,00053.281,W,142651.000,A*29 |
El otro tipo que he probado, es el módulo GPS 1080-B, a diferencia del anterior, este utiliza también el protocolo SIRF III.
Las conexiones Rx, Tx y alimentación son las mismas que en el anterior, en esta imagen podemos ver como conectar la antena al GPS.
Este módulo es mucho más estable y rápido, además nos ofrece más datos que el anteriorpara nuestros programas, la trama recibida en nuestro Arduino sería parecida a la siguiente cuando está ubicado:
?
|
1 2 3 |
$GPGSV,3,1,11,12,60,232,37,15,58,167,36,18,26,255,32,09,70,357,*74 $GPGSV,3,2,11,27,64,057,,17,24,051,,25,19,232,21,22,18,299,*7D $GPGSV,3,3,11,26,16,143,,14,05,317,,28,00,048,*4F |
?
|
1 2 3 |
$GPRMC,183324.466,V,4138.0755,N,00055.5164,W,,,210312,,,N*63 $GPGGA,183325.466,4138.0818,N,00055.5159,W,0,03,,-51.6,M,51.6,M,,0000*72 $GPGSA,A,1,12,15,18,,,,,,,,,,,,*10 |
Lo he separado porque recibiremos 1 bloque como el de arriba $GPGSV por cada 5 como el de abajo.
Podríamos adentrarnos todo lo que quisiéramos en describir las tramadas, pero prefiero describir únicamente lo que vamos a utilizar en el programa y más adelante realizar otro tutorial, de todas maneras os dejo ESTE LINK para que indaguéis por vuestra cuenta, y recordar, si hacéis vuestros programas… compartirlo en el foro!
En primer lugar os muestro el significado de cada trama:
La trama que hemos usado para el programa es la GPGGA, ya que es común a los dos módulos y porta mucha información, la manera de interpretarla es la siguiente, teniendo en cuenta que la numeración, es la posición de la trama separada por comas:
$GPGGA,1,2,3,4,5,6,7,8,9,10,11,12,13,14*15
Como podéis observar, el módulo 1080-B nos devuelve 5 veces por segundo la trama $GPRMC, que aunque no la hemos utilizado en este programa, os la dejo por si optáis por ese módulo ya que nos devuelve la velocidad y dirección con un gran refresco de datos, algo muy útil para tracking.
$GPRMC, 1,2,3,4,5,6,7,8,9,10,11,*12
Modos de conexión a nuestro Arduino
Podemos usar estos módulos de dos maneras diferentes:
Una vez visto los módulos GPS, mostraremos toda la información a través de un Display i2C, el cual nos va a permitir ahorrar una cantidad considerable de pines en comparación al que usábamos en ESTE EJEMPLO.
En realidad es el mismo display del ejemplo, salvo que lleva soldado en su parte posterior un interface que nos permite interactuar con él mediante un bus i2C.
Como la explicación del bus i2C se merece un tutorial por si solo, simplemente os diré que es un bus de comunicación en serie que solo requiere de una señal de reloj (SCL) y una señal de datos (SDA) aparte de la alimentación, por lo que con tan solo dos hilos podremos interactuar con el display activando incluso el backlight (retroiluminación).
La señal de reloj (SCL) deberemos conectarla al pin A5 en un Arduino UNO o al pin 21 en un Arduino MEGA y la señal de datos (SDA) deberá ir al pin A4 en un Arduino UNO o al pin 20 en un Arduino MEGA.
El resto del circuito que usaremos es simplemente un LED que nos indicará cuando ha obtenido ubicación y un pulsador con una resistencia Pull-Down para interactuar con el menú, si tenéis dudas acerca de esto os recomiendo leer antes estos tutoriales:
Veamos entonces el circuito final teniendo en cuenta que:
Parte 3: Programando…
Este programa, es de los más complicados que hemos hecho hasta la fecha, pero no por ello vamos a desanimarnos!
Podréis encontrar todos los archivos de este proyecto para la descarga compartiéndonos en las redes sociales!
Y aquí tenéis el hilo de discusión en el foro oficial ESTE HILO DEL FORO si tenéis cualquier duda, sugerencia, o comentario.. Este es el lugar!!
Este programa, se ha hecho utilizando la librería LiquidCrystal_I2C en la versión 0023 de Arduino, estamos trabajando para adaptar la librería a la versión 1.0 del IDE Arduino, os avísaremos en cuanto la tengamos preparada, mientras, si no disponéis de la versión 023 de Arduino, podéis descargarla desde ESTE ENLACE.
En los archivos de descarga, observaréis una carpeta llamada LiquidCrystal_I2C, para instalar la librería, tan solo debéis copiar esa carpeta dentro de la carpeta librerías del directorio donde tengáis instalado vuestro IDE, si tenéis algún problema, comentarlo en el hilo de foro!!
En cuanto a los archivos del programa, veréis que hay cuatro archivos diferentes, pero en realidad es el mismo programa, podemos abrir cualquiera de ellos, que nos aparecerá algo parecido a la siguiente imagen:
Como podéis ver, cada uno de los archivos que había en la carpeta del sketch, se corresponde con una pestaña del programa, es una opción que nos permite el IDE de Arduino para estructurar y organizar mucho mejor nuestros programas.
Para crear una nueva pestaña en vuestro IDE, tan solo debéis pulsar la flecha situada más a la derecha a la altura de las pestañas y seleccionar New Tab.
Como este programa es algo extenso, me he esforzado al máximo en comentar cada una de las líneas de código por separado en el propio Sketch para comentar pestaña por pestaña aquellas cosas que no hayamos visto en anteriores tutoriales.
Pestaña principal GPS
?
|
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 |
/* Tutorial # 0009 Arduino Academy GPS + Display I2C
En este proyecto aprendemos a conectar un modulo GPS y a tratar la informacion recibida para mostrar en un display I2C la latitud, longitud, hora y altitud.
Este proyecto es de dominio público. */
//Incluimos librerias #include <SoftwareSerial.h> //Para crear un puerto Serie que trabaje con el GPS #include <LiquidCrystal_I2C.h> //Para usar un display I2C #include <Wire.h> //La necesita la libreria LiquidCrystal_I2C.h
//Declaramos las constantes #define txPin 6 //Pin Tx para conexion con el GPS #define rxPin 7 //Pin Rx para conexion con el GPS
// Creamos un puerto serie para el GPS SoftwareSerial gps = SoftwareSerial(rxPin, txPin); //Llamada a la libreria SoftwareSerial para configurar los pines RX TX
//Creamos un objeto para el Display llamado lcd LiquidCrystal_I2C lcd(0x27,16,2); //Establece la dirección de memoria 0x27 (es la que mandan) para un display de 16 caracteres y 2 líneas
//Variables del programa byte byteGPS = 0; // Donde guardaremos cada byte que leamos del gps para mandarlos al array int i = 0; // Variable que utilizaremos como acumulador int Estado = 0; // Guarda el estado de la conexion int menu = 1; // Para saber en que menu estamos int inPin = 5; // PIN del pulsador int value = 0; // Estado del pulsador de menu char TramaGPG[100]; // Array donde iremos almacenando los bytes leidos del GPS char *pch; // Creamos un puntero de tipo char char *GGA[15]; // y un array de punteros de tipo char int sat = 0; // Variable para almacenar el numero de satelites
//Setup del programa void setup() { Serial.begin(9600); // Configuracion del puerto serie de arduino lcd.init(); // Inicializamos el LCD lcd.backlight(); // Encendemos la iluminacion trasera del LCD pinMode(12, OUTPUT); // Configuramos el pin 12 para el LED de la placa digitalWrite(12, LOW); // Apagamos el led hasta tener señal del satelite pinMode(inPin, INPUT); // Inicializa el pin 5 como entrada digital inicio(); // Llama a intro de LCD Serial.flush(); // Borramos el buffer del serial para evitar errores pinMode(rxPin, INPUT); // Configuramos los pines del GPS para poder leer.. pinMode(txPin, OUTPUT); // y para poder escribir en el... gps.begin(4800); // finalmente establecemos la velocidad de comunicacion con el GPS }
//Loop del programa void loop() { value = digitalRead(inPin); // leemos el estado del pulsador que tenemos en el circuito
if(value==1) //COMPROBACION PARA PULSADOR DE MENU { // Si esta a 1 significa que esta pulsado, por lo que menu++; // sumamos 1 a la variable menu lcd.clear(); // Limpiamos el LCD para que al escribir no queden restos de la informacion anterior if (menu==3) { // Si el menu toma valor 3 significa que esta a final de los menus (solo hay dos) menu=1; // por lo que lo reiniciamos a 1 } }
//Preparamos todo para la lectura del puerto serie creado para el GPS memset(TramaGPG, 0, sizeof(TramaGPG)); // Inicializa a cero la cadena para eliminar restos no deseados de lecturas anteriores byteGPS = 0; // Limpiamos el posible contenido byteGPS = gps.read(); // Leemos el byte que tenemos en la entrada del puerto serie creado para el GPS
//Buscamos la cadena deseada para empezar a guardarla en el array while(byteGPS != '$') { // Mientras el byte que tengamos leido no sea igual a $ byteGPS = gps.read(); // leeremos el siguiente caracter }
//Ya tenemos localizada la cadena, asi que la guardamos en un array i=1; // inicializamos a uno el contador TramaGPG[0] = '$'; // y colocamos el $ en la primera posicion de nuestra cadena de caracteres
//Esto nos detecta hasta que dato queremos almacenar en el array, es decir, hasta * que nos indica el final de la cadena y nos llena el array. while(byteGPS != '*' ) { // Mientras el caracter leido no sea igual a * byteGPS = gps.read(); // leeremos el siguiente caracter TramaGPG[i]=byteGPS; // y lo almacenaremos en la cadena de caracteres en la posicion que corresponda i++; // e incrementamos en uno el contador }
TramaGPG[i]='�'; // para evitar porblemas añadiremos nosotros manualmente el caracter de fin de linea cadena(); // Llamamos a la funcion que manipula nuestra cadena } |
Empezando por el principio, tenemos las librerías que necesitamos para este proyecto:
?
|
1 2 3 |
#include <SoftwareSerial.h> //Para crear un puerto Serie que trabaje con el GPS #include <LiquidCrystal_I2C.h> //Para usar un display I2C #include <Wire.h> //La necesita la libreria LiquidCrystal_I2C.h |
Arduino UNO tan solo tiene un puerto de comunicación serie asociado a los pines 0 y 1, el cual se realiza vía hardware con un chip UART (Universal Asynchronous Receiver – Transmitter) y es utilizado cuando activamos el monitor de puerto serie, por lo que nos hace falta un puerto seria más para comunicarnos con el GPS, para ello virtualizamos uno con esta librería, obviamente tiene alguna limitación en comparación al UART, como la velocidad máxima (9600 Baudios) o por ejemplo que no podemos realizar otras tareas mientras estamos escuchando por él, pero esto no es problema para nuestro programa.
La siguientes librerías son para utilizar el Display i2C como pone en los comentarios.
Lo siguiente que nos resulta nuevo es la manera de “crear” un puerto serie con la librería:
?
|
1 |
SoftwareSerial gps = SoftwareSerial(rxPin, txPin); |
Con esta linea hemos creado un puerto serie llamado gps que usa las variables rxPin y txPin para la comunicación.
A continuación hacemos lo propio para nuestro display:
?
|
1 |
LiquidCrystal_I2C lcd(0x27,16,2); |
Con esto le decimos la dirección de memoria a usar, que nos la da la info del display y sus características, 16 columnas por 2 filas.
La siguiente novedad es la definición de una variable como puntero, y un array de punteros:
?
|
1 2 |
char *pch; // Creamos un puntero de tipo char char *GGA[15]; // y un array de punteros de tipo char |
Explicar que son los punteros es algo extenso, simplemente nos quedaremos con la idea que *pch lo usaremos como un francotirador que apunta a un objetivo (dirección de memoria), mientras no lo toquemos, como buen soldado, no lo va a perder de vista, y cuando lo necesitemos, nos dirá el contenido del objetivo al que está apuntando (contenido de la dirección de memoria).
Entre las siguientes lineas observamos:
memset(TramaGPG, 0, sizeof(TramaGPG));
Esto nos “setea” a cero todo el array TramaGPG para evitar restos no deseados de lecturas anteriores, y se corresponde a la siguiente sintaxis:
memset(cadena, 0, sizeof(cadena));
El resto de programa de esta pestaña es fácilmente comprensible con las lineas de comentarios que he colocado.
Como veréis, all final del todo llamamos a la función cadena(); así que pasemos a la siguiente pestaña para ver que nos alberga esa llamada:
?
|
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 |
/* Esta funcion nos va a permitir identificar la trama que necesitamos para sacar los datos de longitud, latitud etc.. usados en el programa.
Podeis crear vuestros propios filtros para para sacar los datos de otras tramas de una manera sencilla, tomando como base esta funcion. */
void cadena() { i=0; // Inicializamos el contador memset(GGA, 0, sizeof(GGA)); // Limpiamos el array GGA introduciendo en el todo ceros
pch = strtok (TramaGPG,","); // Tokenizamos (troceamos) la cadena que tenemos en el array TramaGPG por las comas // y el primer intervalo lo guardamos en pch (puntero char)
//Analizamos ese intervalo guardado en pch para ver si es la cadena que necesitamos if (strcmp(pch,"$GPGGA")==0) // Si es la correcta, seguimos adelante { while (pch != NULL) // Mientras el dato sea valido, lo aceptamos para llenar el array GGA { pch = strtok (NULL, ","); // Pasamos al siguiente intervalo cortado de la cadena GGA[i]=pch; // Guardamos el valor de pch en el array GGA i++; // Incrementamos el contador/acumulador }
representa(GGA,"$GPGGA"); // llamamos a la funcion que nos va a mostrar los datos, bien por serial o por LCD // a esta funcion se le pasan dos paramtros 1º el array de chars, 2º la cadena a comparar. } } |
Este código es que que utilizamos para filtrar las tramas capturadas, está preparado para reaccionar únicamente cuando detectemos la trama GPGGA, pero sería fácilmente modificable para usar con cualquier otra trama que recibamos del gps, así que si vais a realizar vuestros propios proyectos os será muy sencillo.
Como novedades tenemos:
?
|
1 |
pch = strtok (TramaGPG,","); |
Esto coge el array TramaGPG, lo separa en tokens, en este caso las comas de nuestra línea recibida del GPS, y deja apuntando a nuestro francotirador pch a la dirección de memoria del primer intervalo cortado para analizarlo luego en estas lineas:
?
|
1 2 3 4 5 6 7 8 9 10 |
if (strcmp(pch,"$GPGGA")==0) { while (pch != NULL) { pch = strtok (NULL, ","); // Pasamos al siguiente intervalo cortado de la cadena GGA[i]=pch; // Guardamos el valor de pch en el array GGA i++; // Incrementamos el contador/acumulador } representa(GGA,"$GPGGA"); } |
Aquí analizamos que la cadena a la que apunta nuestro puntero sea igual a GPGGA gracias a la instrucción:
strcmp(pch,"$GPGGA")==0
Se coloca un “igual a cero” ya que cuando realiza la comparación reacciona de la siguiente manera:
A continuación de decimos que compruebe que el contenido del intervalo de la cadena sea válido, y mintras esto sea así, vaya pasando de intervalo en intervalo, almacenando francotiradores que apuntan a esos intervalos en el array de punteros GGA.
Para finalizar, llamamos a la función representa pasándole un par de datos de referencia.
Así que veamos la pestaña representa al completo:
?
|
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 |
/* Esta funcion nos va a organizar los datos recibidos del gps, para imprimirlos en el LCD y en el monitor de puerto serie. */
void representa(char **GGAPrint, char *trama) // Capturamos los datos pasados a la funcion { Estado = atoi(GGAPrint[5]); // Transformamos el char que contiene el estado de la conexion a un entero sat = atoi(GGAPrint[6]); // Transformamos el char que contiene el numero de satelites a un entero
if(trama=="$GPGGA" && Estado==1) // Si la trama que tenemos es $GPGGA y el estado esta a 1 (conectado) { digitalWrite(12, HIGH); // Indicamos que hay conexion satelite encendiendo el led
//Imprimimos en el LCD if(menu==1) { // Muestra toda la informacion de la pantalla correspondiente LongLat(GGAPrint[3],GGAPrint[4],GGAPrint[1],GGAPrint[2]); // Impmrime latitud y longitud en display }
if(menu==2) { altitud(GGAPrint[8],GGAPrint[9]); // Imprime altitud en el LCD reloj(GGAPrint[0]); // Imprime la hora en formato UTC }
//Ademas de imprimir en el LCD, sacamos los datos por el puerto serie de Arduino
Serial.println(""); Serial.println("----------------------------------------------"); Serial.print("Hora UTC -> "); Serial.println(GGAPrint[0]); Serial.print("Latitud -> "); Serial.print(GGAPrint[1]); Serial.println(GGAPrint[2]); Serial.print("Longitud -> "); Serial.print(GGAPrint[3]); Serial.println(GGAPrint[4]); Serial.print("Indicacion de calidad GPS: 0=nula; 1=GPS fija -> "); Serial.println(GGAPrint[5]); Serial.print("Numero de satelites visibles por el receptor -> "); Serial.println(sat); Serial.print("Dilucion horizontal de posicion -> "); Serial.println(GGAPrint[7]); Serial.print("Altitud de la antena por encima / por debajo del nivel del mar (geoidal) -> "); Serial.print(GGAPrint[8]); Serial.println(GGAPrint[9]); Serial.print("Separacion geoidal -> "); Serial.print(GGAPrint[10]); Serial.println(GGAPrint[11]); Serial.println("----------------------------------------------"); Serial.println("");
}
else // Si no ha conexion satelite { digitalWrite(12, LOW); // Apagamos el led de conectado esperaGPS(sat); // llamamos a la funcion de LCD que representa el numero de satelites conectados.. Serial.println(""); // e imprimimos por el serial un banner con el numero de satelites conectados Serial.println("-----------------------------"); Serial.print("|---Satelites visibles -->"); Serial.print(sat); Serial.println(" |"); Serial.println("|----Esperando ubicacion----|"); Serial.println("-----------------------------"); Serial.println(""); } } |
Como vemos, la función requiere esos dos datos que le hemos pasado al llamarla y sobre los que trabajaremos:
?
|
1 |
void representa(char **GGAPrint, char *trama) |
Siguiendo el desarrollo veremos la instrucción atoi que usamos para convertir datos de tipo char almacenados en el array, en enteros para poder trabajar con ellos de una manera más sencilla:
?
|
1 2 |
Estado = atoi(GGAPrint[5]); sat = atoi(GGAPrint[6]); |
El resto de esta pestaña nos imprime los datos que recibimos del GPS en el monitor de puerto serie y llama a las funciones que imprimen en nuestro display, almacenadas en la última pestaña de este programa, así que vayamos a ello!!
?
|
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 |
/* Aqui almacenamos todos los menus y la manera de contruirlos para imprimirlos en el LCD */
//Banner inicial del LCD void inicio() { lcd.clear(); // borramos la pantalla para quitar basura anterior lcd.setCursor(0, 0); // posicionamos el cursor lcd.print("Proyecto #0009"); // imprimimos la cadena lcd.setCursor(0, 1); // posicionamos el cursor lcd.print("Arduino Academy"); // imprimimos la cadena delay(3000); // hacemos una pausa aunque el gps seguira conectando lcd.clear(); // borramos la pantalla lcd.setCursor(0, 0); // posicionamos el cursor lcd.print("Modulo GPS"); // imprimirmos la cadena lcd.setCursor(0, 1); // posicionamos el cursor lcd.print("& Display I2C... "); // imprimimos la cadena delay(3000); // hacemos una pausa aunque el gps seguira conectando lcd.clear(); // borramos la pantalla lcd.setCursor(0, 0); // posicionamos el cursor lcd.print("Iniciando...."); // imprimirmos la cadena lcd.blink(); // dejamos el cursor parapadenando delay(4000); // hacemos una pausa aunque el gps seguira conectando lcd.clear(); // borramos la pantalla para quitar basura anterior }
//Pantalla de espera del GPS mientras se conecta void esperaGPS(int NumSat) { lcd.setCursor(0, 0); // posicionamos el cursor lcd.print("Esperando sat. "); // imprimirmos la cadena lcd.setCursor(0, 1); // posicionamos el cursor lcd.print("Sat.Visibles->"); // imprimirmos la cadena lcd.setCursor(14, 1); // posicionamos el cursor lcd.print(NumSat); // imprimimos la variable }
//Menu 1 - Imprime la latitud y la longitud void LongLat(char *Longitud, char *Brujula1, char *Latitud, char *Brujula2) //Recogemos los parametros de la funcion { lcd.setCursor(0, 0); // posicionamos el cursor lcd.print("Lat->"); // imprimimos la cadena lcd.print(Latitud[0]); // imprimimos el primer caracter de la cadena lcd.print(Latitud[1]); // imprimimos el segundo caracter de la cadena lcd.print("."); // imprimirmos la cadena lcd.print(Latitud[2]); // imprimimos el tercer caracter de la cadena lcd.print(Latitud[3]); // imprimimos el cuarto caracter de la cadena lcd.print("'"); // imprimirmos la cadena lcd.print(Latitud[5]); // imprimimos el quinto caracter de la cadena lcd.print(Latitud[6]); // imprimimos el sexto caracter de la cadena lcd.print(" "); // imprimirmos la cadena lcd.print(Brujula2); // imprimimos la variable lcd.setCursor(0, 1); // posicionamos el cursor lcd.print("Lon->"); // imprimirmos la cadena lcd.print(Longitud[1]); // imprimimos el primer caracter de la cadena lcd.print(Longitud[2]); // imprimimos el segundo caracter de la cadena lcd.print("."); // imprimirmos la cadena lcd.print(Longitud[3]); // imprimimos el tercer caracter de la cadena lcd.print(Longitud[4]); // imprimimos el cuarto caracter de la cadena lcd.print("'"); // imprimirmos la cadena lcd.print(Longitud[6]); // imprimimos el quinto caracter de la cadena lcd.print(Longitud[7]); // imprimimos el sexto caracter de la cadena lcd.print(" "); // imprimirmos la cadena lcd.print(Brujula1); // imprimimos la variable lcd.setCursor(15, 1); // posicionamos el cursor }
//Menu 2.1 que nos imprime la hora en el LCD void reloj(char *hora) //recogemos los parametros de la funcion { lcd.setCursor(0, 1); // posicionamos el cursor lcd.print("Hora-> "); // imprimirmos la cadena lcd.print(hora[0]); // imprimimos el primer caracter de la cadena lcd.print(hora[1]); // imprimimos el segundo caracter de la cadena lcd.print(":"); // imprimirmos la cadena lcd.print(hora[2]); // imprimimos el tercer caracter de la cadena lcd.print(hora[3]); // imprimimos el cuarto caracter de la cadena lcd.print(":"); // imprimirmos la cadena lcd.print(hora[4]); // imprimimos el quinto caracter de la cadena lcd.print(hora[5]); // imprimimos el sexto caracter de la cadena lcd.setCursor(16, 1); // posicionamos el cursor }
//Menu 2.2 que nos imprime la altitud en el LCD void altitud(char *altitud, char *unidades) //recogemos los parametros de la funcion { lcd.setCursor(0, 0); // posicionamos el cursor lcd.print("Altitud->"); // imprimirmos la cadena lcd.print(altitud); // imprimimos la variable lcd.print(unidades); // imprimimos la variable } |
Como veis, esta última pestaña simplemente hace llamadas a datos para imprirlos en una secuencia determinada, y así obtener el resultado final en nuestro LCD.