gps.c

Go to the documentation of this file.

/* gps.c --- 
 * 
 * Filename: gps.c
 * Description: 
 * Author: Bryce Himebaugh
 * Maintainer: 
 * Created: Mon Oct 23 16:22:50 2006
 * Version: 
 * Last-Updated: 
 *           By: 
 *     Update #: 0
 * Keywords: 
 * Compatibility: 
 * 
 */

/* Commentary: 
 * 
 * 
 * 
 */

/* Change log:
 * 
 * 
 */

/* 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, or (at your option)
 * any later version.
 * 
 * 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; see the file COPYING.  If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

/* Code: */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <vcs_bsp/vcsbsp.h>
#include "gps.h"

gps_t buf_struct;

int init_gps(void) {
  buf_struct.db[0].status=EMPTY;     // Initialize the structures used to store the GPS sentences
  buf_struct.db[1].status=EMPTY;
  
  gps_send("$PGRMC,,,,,,,,,,,,2,,"); // Turn on the periodic pulse output from the GPS. 
  gps_send("$PGRMC1,,,,,,,,,,,,,2"); // Periodic Pulse will turn off when GPS data not available. 
  gps_send("$PGRMO,,2");             // Turn on all of the sentences
  while (!flush_uart1());
  gps_send("$PGRMO,PGRMF,1");        // Turn on the GPS Fix Data Sentence
  gps_send("$PGRMO,PGRME,1");        // Turn on the Estimate Error Sentence
  gps_send("$PGRMO,PGRMV,1");        // Turn on the 3D Velocity Information
  return (0);
}

int get_field(char *sentence,char *field,int field_num) {
  // Function returns 1 if the requested field is found. 
  // 0 is returned if the end of "sentence" is found 
  // before the desired field is located. 
  // The field is copied to the buffer starting at "field".
  char *field_ptr=0;
  char *field_start=0;
  char ret_val=0;
  field_ptr=field_start=sentence;
  while (*field_ptr) {
    if ((*field_ptr==',')||(*field_ptr=='*')) {
      if (!field_num) {
        while (field_start<field_ptr) {
          *field++=*field_start++;
        }
        *field=0;
        ret_val=1;
        break;
      }
      else {
        field_start=field_ptr+1;            
        field_num--;
      }
    }  
    field_ptr++;
  } 
  return (ret_val);
}

void get_field_test(void) {
  char sentence[]="$foo,,,3,4,5,6,7,8,9,10,11,12*5E";
  char field_buf[20]="";
  int i;
  for (i=0;i<16;i++) {
    if (get_field(sentence,field_buf,i)) {
      printf("%s\n",field_buf);
    }
    else {
      printf("returned 0\n");
    }
    flush_uart0();
  }
}

int gps_parse (char *sentence) {
  static int gps_avail=0;
  char buf[20];
  const char PGRMF[]="$PGRMF";
  const char PGRME[]="$PGRME";
  const char PGRMV[]="$PGRMV";
  int ret_val=0;

  if (get_field(sentence,buf,0)) {
    if (!strcmp(buf,PGRMF)) {
      if (get_field(sentence,buf,FIX)) {
        if ((gps_avail=atoi(buf))) {
          if (get_field(sentence,buf,DATE)) {
            printf("DATE=%s ",buf);
          }
          if (get_field(sentence,buf,TIME)) {
            printf("TIME=%s ",buf);
          }
          if (get_field(sentence,buf,LATITUDE)) {
            printf("LAT=%s ",buf);
          }
          if (get_field(sentence,buf,LONGITUDE)) {
            printf("LON=%s ",buf);
          }
        }
        else {
          printf("NO FIX\n");
        }
        flush_uart0();
      }
    }
    else if (!strcmp(buf,PGRME)) {
      if (gps_avail) {
        if (get_field(sentence,buf,HPE)) {
          printf("ERR=%s ",buf);
          flush_uart0();
        }
      }
    }
    else if (!strcmp(buf,PGRMV)) {
      if (gps_avail) {
        if (get_field(sentence,buf,NVEL)) {
          printf("NVEL=%s ",buf);
        }
        if (get_field(sentence,buf,EVEL)) {
          printf("EVEL=%s ",buf);
        }
        printf("\n");
        flush_uart0();
      }
    }
  }
  return(ret_val);
}

char *gps_get(void) {
  char *ret_val=0;
  static int gps_buf=0;
  if (buf_struct.db[gps_buf].status==READY) {
    ret_val=buf_struct.db[gps_buf].data;
    buf_struct.db[gps_buf++].status=EMPTY;
    if (gps_buf==GPS_BUF_NUM) {
      gps_buf=0;
    }
  }
  return (ret_val);
}

int evaluate_gps(void) {
  static char message_buffer[100]="";
  static char *buf_ptr = message_buffer;
  enum {LOCATE_SENTINEL,CRLF};
  static char parser_state=LOCATE_SENTINEL;
  static int char_counter=0;
  static int current_buffer=0;
  char temp;
  int ret_val=0;
  while ((temp=getchar_gps_nb())) { // Grab a character from the buffer.
    switch (parser_state) {
    case LOCATE_SENTINEL:
      if ((temp=='$')&&(buf_struct.db[current_buffer].status==EMPTY)) {
        buf_ptr=buf_struct.db[current_buffer].data;
        *buf_ptr++=temp;
        parser_state=CRLF;
        char_counter=1;
      }
      break;
    case CRLF:
      if (temp=='\r') {
        *buf_ptr++='\n';
        *buf_ptr=0;
        buf_struct.db[current_buffer++].status=READY;
        if (current_buffer==GPS_BUF_NUM) {
          current_buffer=0;
        }
        parser_state=LOCATE_SENTINEL;
      }
      else {
        if (char_counter++<100) {
          *buf_ptr++=temp;
        }
        else {
          parser_state=LOCATE_SENTINEL;
        }
      }
      break;
    }
  }
  return (ret_val);
}

int gps_show_raw(void) {
  char temp;
  char message_buffer[100]="";
  char *buf_ptr = message_buffer;
  
  while ((temp=getchar_gps_nb())) {
    *buf_ptr++=temp;
  }
  *buf_ptr=0;
  printf("%s",message_buffer);
  flush_uart0();
  return (1);
}

int gps_add_checksum(char *sentence) {
  unsigned char sum = '\0';
  char c, *p = sentence;
  int ret_val=0;

  if (*p == '$') {
    p++;
  } 
  else {
    ret_val=1;
  }
  while ( ((c = *p) != '*') && (c != '\0')) {
    sum ^= c;
    p++;
  }
  *p++ = '*';
  (void)snprintf(p, 5, "%02X\r\n", (unsigned)sum);
  return (ret_val); 
}

int gps_send(const char *fmt, ... ) {
  static int init=0;
  int ret_val=0;
  char buf[100];
  if (!init) {
    uprintf(&putchar_gps,"\r\n"); // Send a CR/LF to clean out any previous partial commands. 
    init=1;
  }
  va_list ap;
  va_start(ap, fmt) ;
  (void)vsnprintf(buf, sizeof(buf)-5, fmt, ap);
  va_end(ap);
  if (fmt[0] == '$') {
    strcat(buf, "*");
    if (gps_add_checksum(buf)) {
      ret_val=1;
    }
  } 
  else {
    strcat(buf, "\r\n");
  }
  if (!ret_val) {
    uprintf(&putchar_gps,"%s",buf);
    flush_uart1();
  }
  return (ret_val);
}

/* gps.c ends here */

---