gps-parser.h

Go to the documentation of this file.

/* GPS parser header file */
/* Copyright (C) 2010 Sebastian Klemm
 *               2010, 2011 Holger Dietze
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) version 3.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License along
 *   with this program; if not, see <http://www.gnu.org/licenses/>.
 */

/* written for Explorer's Pal (http://explorerspal.org/) */

#ifndef GPS_PARSER_H
#define GPS_PARSER_H

#include <stdint.h>
#include <avr/pgmspace.h>
#include <stdlib.h>
#include <string.h>

#include <usarts.h>

#include <ff.h>

typedef struct gps_time_s {
  uint8_t hour; 
  uint8_t min; 
  uint16_t msec; 
} gps_time_t;

typedef struct gps_date_s {
  uint16_t year; 
  uint8_t month; 
  uint8_t day;   
} gps_date_t;

typedef int32_t gps_degree_t;
#define GPS_DEGREE_SCALE (10000000L)
#define GPS_DEGREE_SCALE_EXP (7)

typedef struct gps_dms_s {
  int8_t sign;
  uint8_t deg;
  uint8_t min;
  uint8_t sec;
} gps_dms_t;

extern gps_dms_t gps_degree_to_dms (gps_degree_t v);

typedef struct gps_dop_s {
  uint8_t dop;
  uint8_t dopfrac; 
} gps_dop_t;

typedef struct gps_height_s {
  uint16_t height;
  uint8_t heightfrac; 
  char unit;
} gps_height_t;

typedef struct gps_sat_s {
  uint8_t id; 
  uint8_t has_dgps:1; 
  uint8_t used:1; /*<\brief sat is used in fix */
  uint8_t elevation; 
  uint16_t azimuth; 
  uint8_t snr; 
  uint8_t dgps_age; 
  uint16_t dgps_corr; /*<\brief DGPS correction in m/100 */
} gps_sat_t;

typedef struct {
  gps_time_t time;
  gps_date_t date;
  gps_degree_t lat, lon;
  gps_height_t height;
  gps_dop_t hdop;
} gps_position_t;


typedef enum {
  GPS_LINE_MORE = 0, 
  GPS_LINE_CKERR,    
  GPS_LINE_OVERFLOW, 
  GPS_LINE_OK,       
  GPS_LINE_FIX,      
  GPS_LINE_TIME,     
  GPS_LINE_SAT,      
} gps_line_status_t;

typedef struct gps_parser_s gps_parser_t;

typedef enum {
  GPSPROTO_NONE = 0,
  GPSPROTO_NMEA,
  GPSPROTO_SiRF,
  GPSPROTO_NUMPROTOS /* keep last entry */
} gps_proto_t;

typedef struct gps_proto_functions_s {
  gps_line_status_t (*recvd) (gps_parser_t *, usart_rxdata_t);
  struct gps_proto_parser_s * (*newparser) (gps_parser_t *);
  void (*freeparser) (gps_parser_t *);
  const struct gps_proto_functions_s * (*switchproto) (gps_parser_t *, gps_proto_t,
                                                 baudrate_t baud);
  gps_proto_t proto;
  baudrate_t baudrate_max;
} PROGMEM gps_proto_functions_t;

extern const gps_proto_functions_t gps_proto_sirf;
extern const gps_proto_functions_t gps_proto_nmea;

typedef struct gps_proto_parser_s {
  const gps_proto_functions_t * func;
} gps_proto_parser_t;

#define MAX_NUM_SATS (18)

struct gps_parser_s {
  gps_proto_parser_t * proto_parser;
  usart_control_t * usart; 
  uint8_t is_active/*:1*/; 
  gps_time_t time;  
  gps_date_t date;  
  gps_degree_t lat; 
  gps_degree_t lon; 
  uint8_t num_sats;  
  gps_dop_t hdop;         
  gps_height_t height;       
  struct {
    uint16_t speed;
    uint8_t speedfrac;
    char unit;
  } speed;        
  struct {
    uint16_t course;
    uint8_t coursefrac;
  } course;       
  struct {
    baudrate_t baud;
    uint8_t frame_errors;
    uint8_t faster;
    uint8_t slower;
  } autobaud;
  char * usart_name; 
  struct {
    uint8_t tcnt2;
  } msg_timestamp[2];
  uint32_t msg_timestamp_ticks; 
  gps_sat_t satellites[MAX_NUM_SATS]; 
  FIL * logfile; 
};


/* GCC magic ahead! */
#define PROTO_CALL(FUNCP,ARGS...)                                       \
  __extension__({                                                       \
    __typeof__(*FUNCP) __p = (__typeof__(*FUNCP))pgm_read_word (FUNCP); \
    (__p) (ARGS);                                                       \
  })


gps_parser_t * new_gps_parser (usart_control_t * usart);

inline void free_gps_parser (gps_parser_t *parser)
{
  PROTO_CALL(&(parser->proto_parser->func->freeparser), parser);
  free (parser->usart_name);
  free (parser->logfile);
  free (parser);
}

inline gps_proto_t gps_get_proto (gps_parser_t *parser)
{
  if (parser->proto_parser)
    return pgm_read_byte (&(parser->proto_parser->func->proto));
  return GPSPROTO_NONE;
}

gps_proto_t gps_set_proto (gps_parser_t *parser, gps_proto_t newproto,
                           baudrate_t baud);

inline void gps_timestamp_set_trigger (gps_parser_t *parser, uint8_t trigger)
{
  usart_timestamp_set_trigger (parser->usart, trigger);
}

void gps_timestamp_start_of_message (gps_parser_t *parser);

baudrate_t gps_set_baudrate (gps_parser_t *parser, baudrate_t baudrate);

void gps_start_log (gps_parser_t * parser);

gps_line_status_t gps_recvd (gps_parser_t * parser, usart_rxdata_t c);

inline uint8_t gps_usart_can_recv (gps_parser_t * parser)
{
  return usart_can_recv (parser->usart);
}

gps_line_status_t gps_usart_recv_and_handle (gps_parser_t * parser,
                                       usart_rxdata_t *c);

int gps_format_position (char * buf, size_t sz, gps_parser_t * parser);

gps_sat_t * gps_get_satellite (gps_parser_t *parser, uint8_t idx);

uint8_t gps_get_time (gps_parser_t *parser,
                      gps_date_t * pdate, gps_time_t * ptime);

uint8_t gps_get_position (gps_parser_t *parser,
                          gps_degree_t * plat, gps_degree_t * plon);

uint8_t gps_get_height (gps_parser_t *parser,
                        gps_height_t * pheight);

uint8_t gps_get_hdop (gps_parser_t *parser,
                      gps_dop_t * phdop);

uint8_t gps_get_data (gps_parser_t * parser, gps_position_t * data);

inline uint8_t gps_get_source (gps_parser_t *parser,
                               const char * *psrc, const char * *pproto,
                               baudrate_t *baud)
{
  extern const char * gps_proto_names[];

  if (psrc) *psrc = parser->usart_name;
  if (pproto) *pproto = gps_proto_names[gps_get_proto(parser)];
  if (baud) *baud = parser->autobaud.baud;
  return 1;
}

inline uint8_t gps_usart_is_active (gps_parser_t *parser)
{
  return parser->is_active;
}

inline void gps_usart_power (gps_parser_t *parser,
                             uint8_t onoff)
{
  usart_control_t * uc = parser->usart;
  if (onoff) {
    usart_power (uc, 1);
    usart_set_baudrate (uc, parser->autobaud.baud);
    usart_enable (uc);
  } else {
    usart_disable (uc);
    usart_power (uc, 0);
  }
  parser->is_active = onoff;
}

void gps_set_parsed_time (gps_parser_t *parser,
                          gps_date_t date,
                          gps_time_t time);

#endif