Subversion Repositories shark

/*

 * Project: S.Ha.R.K.

 * G P S  D E M O : this program receives and displays data from a gps

 * transmitter connected to COM1 port. This is also a graphic demo that

 * uses a software emulation of MESA libraries to display actual latitude

 * and longitude on the earth globe. You can also use the program without

 * having a gps transmitter because it can run in a demo mode (to do that

 * press d key when the program starts).

 *

 * In the main function graphics and com1 port are initialized, respectively

 * with a call to the functions gl_init and open_com. Then all the tasks

 * used in the program are created and activated, these are :

 *

 *    TASK refresh : copies the gl buffer to video memory

 *    TASK draw    : draws all the graphics

 *    TASK gps     : receives data from gps transmitter

 *

 */

#include <kernel/log.h>

#include <kernel/kern.h>

#include <math.h>

#include <stdlib.h>

#include <drivers/shark_fb26.h>

#include <drivers/shark_keyb26.h>

#include <GL/osmesa.h>  //MESA header

#include <GL/glut.h>    //MESA header

#include "texture.h"    //contains three arrayes that define the R, G, B data of the first texture (phisical earth)

#include "texture2.h"   //contains three arrayes that define the R, G, B data of the second texture (political earth)

#include "comport.h"    //contains constants used by COM1 functions

#ifndef M_PI

#define M_PI 3.14159265

#endif

//Graphic variables and constants

#define WIDTH 800    //Width of the screen in pixel

#define HEIGHT 600   //Height of the screen in pixel

#define BYTES_PP 2   //BytesPerPixel

OSMesaContext ctx;

extern void *video_memory;

unsigned char *rgb_565_buf = NULL;                      //RGB 16 bpp Buffer

unsigned char *video_buf = NULL;                        //Video Buffer

unsigned long int VMEMLONG = WIDTH*HEIGHT*BYTES_PP / 4; //Used by copy_videomem_16to16

unsigned long int RGB565MEM = WIDTH*HEIGHT*BYTES_PP;    //Total video mem

//Graphic Objects variables and constants

GLdouble radius, twist;       //radius and twist of the sphere

float zoom = 0;               //zoom factor

int sel_texture = 1;          //index of the actually selected texture

GLubyte tex[256][256][3];     //stores the R, G, B data of the first texture

GLubyte tex2[256][256][3];    //stores the R, G, B data of the second texture        

GLint sphere;                 //index of the shpere list (see mesa functions for details)

//Tasks variables and constants

unsigned long int PERIOD_REFRESH = 100000; //period of the refresh task in ns

unsigned long int PERIOD_DRAW = 100000; //period of the draw task

unsigned long int PERIOD_GPS = 1000;       //period of the gps task

unsigned long int WCET_REFRESH, WCET_DRAW, WCET_GPS; //deadlines of the tasks

PID refresh_PID, draw_PID, gps_PID;     //indexes of the tasks

//Gps receiver task variables and constants

char word[30];       //contains every word received from the gps transmitter

int ind = 0;         //contains the index of the next character to be written in the variable word

int ind_gpgga = 0;   //index of the next gpgga word to be read from gps

int ind_gpgsv = 0;   //index of the next gpgsv word to be read from gps

int ind_gprmc = 0;   //index of the next gprmc word to be read from gps

int nlist;           //used to index satellites in gps_sat_data structure

//Demo mode variables and functions

int demo_mode = 0;   //indicates if demo mode is active(=1) or not (=0)

int ndemo = 0;       //a counter used while running in demo mode

int lat, lon;        //auxiliary variables used for integer division

int kmov;            //used to change the moving direction 

float demolat = 0;   //stores latitude

float demolon = 0;   //stores longitude

//Gps data structures

typedef struct {

   float id, elevation, azimuth, signal_level;

} gps_sat_data;

struct {

   float latitude, longitude, altitude, nsat, speed, dir_mov, date, var_mov;

   char dirlat, dirlon, time[12], dir_var_mov;

   gps_sat_data sat_data[4]; //data of the satellites in view (4 maximum)

} gps_data;

TASK refesh(void);

TASK draw(void);

TASK gps(void);

//converts a string to a floating point

float strtof(char *s)

{

   int d, n;

   float f = 0, pot;

   //if the string is null ends returning 0

   if(s[0] == '\0')

      return 0;

   //finds the dot character until the end of the string

   for(d = 0; (s[d] != '.') && (s[d] != '\0') ; d++);

   //converts non decimal numbers

   pot = 1;

   for(n = d - 1; n >= 0; n--) {

      f = f + pot * (s[n] - 48);

      pot = pot * 10;      

   }

   //ends if there are not decimal numbers

   if( s[d] == '\0')

      return f;

   //converts decimal numbers

   pot = 0.1;

   for(n = d + 1; s[n] != '\0'; n++) {

      f = f + pot * (s[n] - 48);

      pot = pot / 10;

      if(n >= 30)

         break;

   }

   return f;

}

//compares two strings returning 1 if they are equal otherwise 0

int streq(char *s1, char *s2)

{

   int n = 0;

   while(1)

      if( s1[n] == s2[n] )

         if( s1[n] == '\0' ) {

            return 1;

         }

         else {

            n++;

            //ends if the string is larger than the word variable 

            if(n >= 30)

              return 0;

         }

      else

         return 0;

}

//copies s2 string in s1 string

void strcp(char *s1, char *s2)

{

   int n = 0;

   while( s2[n] != '\0' ) {

      s1[n] = s2[n];

      n++;

      //ends if the string is larger than the word variable

      if(n >= 30)

         break;

   }

   s1[n] = '\0';

}

//writes data on the COM1 port (used only by open_com function)

void com_write(unsigned int port,unsigned int reg,unsigned int value)

{

    if (port > 3 || reg > 7) return;

    ll_out(com_base[port]+reg,value);

}

//reads data from the COM1 port without waiting

unsigned int com_read(unsigned int port,unsigned int reg)

{

    unsigned int b;

    if (port > 3 || reg > 7) return(0);

    b = ll_in(com_base[port]+reg);

    return(b);

}

//activates the COM1 port and makes it ready for reading/writing

int open_com(unsigned int port, DWORD speed, BYTE parity, BYTE len, BYTE stop)

{

    unsigned long div,b_mask;

    /* Now set up the serial link */

    b_mask = (parity & 3) * 8 + (stop & 1) * 4 + ((len - 5) & 3);

    div = 115200L / speed;

    /* Clear serial interrupt enable register */

    com_write(port,IER,0);

    /* Empty input buffer */

    com_read(port,RBR);

    /* Activate DLAB bit for speed setting */

    com_write(port,LCR,0x80);

    /* Load baud divisor */

    com_write(port,0,div & 0x00FF);

    div >>= 8;

    com_write(port,1,div & 0x00FF);

    /* Load control word (parity,stop bit,bit len) */

    com_write(port,LCR,b_mask);

    /* Activate OUT1 & OUT2 */

    com_write(port,MCR,0x0C);

    return 0;

}

/*rotates the axes of the mesa graphic objects and also of the sphere

  using the latitude and longitude data contained in the gps_data structure */

void polarView()

{

    float signlat, signlon; //contains directions of rotation

    //translates the axes far or near from the observer point to make zoom effect

    glTranslated(0.0, 0.0, radius + zoom);

    glRotated(-twist, 0.0, 0.0, 1.0);

    //direction of rotation in latitude may be Nord 'N' or Suoth 'S'

    if(gps_data.dirlat == 'N')

       signlat = -1;

    else

       signlat = 1;

    //direction of rotation in longitude may be East 'E' or West 'W'

    if(gps_data.dirlon == 'E')

       signlon = -1;

    else

       signlon = 1;

    /*there are some graphic errors in the two textures that result in a

      wrong placing of latitude and longitude on the image displayed.

      To compensate these errors some correction factors that depend

      on what texture you are using are added to latitude and longitude.*/

    switch(sel_texture) {

        case 1 : glRotated(signlat*gps_data.latitude + 3 , 1.0, 0.0, 0.0);

                 glRotated(signlon*gps_data.longitude, 0.0, 1.0, 0.0);                  

                 break;

        case 2 : glRotated(signlat*gps_data.latitude + 7 , 1.0, 0.0, 0.0);

                 glRotated(signlon*gps_data.longitude + 15, 0.0, 1.0, 0.0);                

    }

}

//initializes the mesa memory and prepares the textures

void gl_init()

{

  GLfloat h = (GLfloat) HEIGHT / (GLfloat) WIDTH;

  int r, c;

  //Create the OSMesa Context

  ctx = OSMesaCreateContext(OSMESA_RGB_565, NULL);

  //Set the memory pointed by rgb_565_buf to be the mesa buffer

  OSMesaMakeCurrent(ctx, rgb_565_buf, GL_UNSIGNED_SHORT_5_6_5, WIDTH, HEIGHT);

  glEnable(GL_DEPTH_TEST);

  glDisable( GL_DITHER );

  //Set up texturing

  glEnable( GL_TEXTURE_2D );

  glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL );

  glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST );

  /*puts all data contained in the headers in the tex and tex2 structures

    using the right order*/

  for(r = 0;  r < 256; r++)

     for(c = 0; c < 256; c++)

     {

        tex[r][c][0] = textureR[256*(256-r)+c];

        tex[r][c][1] = textureG[256*(256-r)+c];

        tex[r][c][2] = textureB[256*(256-r)+c];

        tex2[r][c][0] = texture2R[256*(256-r)+c];

        tex2[r][c][1] = texture2G[256*(256-r)+c];

        tex2[r][c][2] = texture2B[256*(256-r)+c];

     }

  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );

  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );

  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );

  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );

  //creates the list that define the sphere object

  sphere = 1;

  glNewList(sphere, GL_COMPILE);

        glEnable(GL_TEXTURE_2D);

        GLUquadricObj *quadObj = gluNewQuadric ();

        gluQuadricTexture(quadObj, GL_TRUE);

        gluQuadricDrawStyle(quadObj, GLU_FILL);

        gluQuadricNormals(quadObj, GLU_SMOOTH);

        glRotated(-90, 1.0, 0.0, 0.0);

        gluSphere (quadObj, 3, 30, 30);

  glEndList();

  glEnable(GL_NORMALIZE);

  //sets mesa(gl) viewport

  glViewport(0, 0, (GLint) WIDTH, (GLint) HEIGHT);

  glMatrixMode(GL_PROJECTION);

  glLoadIdentity();

  //sets the 3d visual volume and the observer point

  glFrustum(-1.0, 1.0, -h, h, 5.0, 60.0);

  glMatrixMode(GL_MODELVIEW);

  glLoadIdentity();

  //places the origin of the axes of the 3d view

  glTranslated(0, -1, -40);

  radius = 0;

  twist = 0;    

}

/*Because mesa functions write graphic data on a dedicated buffer (gl buffer)

  this buffer once drawn has to be copied on video memory using this task*/

TASK refresh(void)

{

 /*  The gl buffer is used only by mesa functions, other graphic

  *  functions write directly on video memory (es. grx_text, grx_rect,...)

  *  so the refresh task can not overwrite the first 90 lines of video memory

  *  used by non mesa functions.

  */

  while(1) {

    task_testcancel();

    memcpy((video_buf+90*WIDTH*2), rgb_565_buf, RGB565MEM-90*WIDTH*2);

    task_endcycle();

  }

  sys_end();

}

/*generates gps-like values to simulate the gps transmitter when it is not connected,

  this function is called every time before drawing the image on mesa buffer

  if demo mode is on*/

void demo_val()

{

   int ns;

   int signal_max[4] = {25, 30, 10, 70};

   int azimuth_max[4] = {170, 10, 60, 100};

   int elevation_max[4] = {10, 60, 30, 79};

   ndemo += 1;

   //generates speed

   gps_data.speed = 25;

   //generates next direction increasing or decreasing the last one using kmov

   if(gps_data.dir_mov == 135)

      kmov = -1;

   if(gps_data.dir_mov == 45)

      kmov = 1;

   gps_data.dir_mov += kmov;

   //generates next latitude and longitude data using direction and speed

   demolat += cos(gps_data.dir_mov / (360/(2*M_PI)) ) * (gps_data.speed / 20);

   demolon += sin(gps_data.dir_mov / (360/(2*M_PI)) ) * (gps_data.speed / 20);

   lat = (int) demolat;

   lon = (int) demolon;

   /*demolat and demonlon count latitude and longitude from -infinite to

     +infinite, but latitude is actually displayed from -90 to +90

     (respectively nord or south) and longitude from -180 to +180 (respectively

     east or west) and so you have to convert demolat and demolon data into real

     latitude and longitude data before putting them in gps_data structure*/

   if(lon < 0)

      lon = 360 - (-lon) % 360;

   if(lon % 360 > 180) {

      gps_data.longitude = 180 - (lon % 360 - 180);

      gps_data.dirlon = 'W';

   }

   else {

      gps_data.longitude = lon % 360;

      gps_data.dirlon = 'E';      

   }

   if(lat < 0)

      lat = 360 - (-lat) % 360;

   if(lat % 360 >= 180) {    

      gps_data.dirlat = 'S';

      if(lat % 360 > 270)

         gps_data.latitude = 90 - (lat % 360 - 270);

      else {

         gps_data.latitude = lat % 360 - 180;

         gps_data.longitude = 180 - gps_data.longitude;

         if(gps_data.dirlon == 'E')

            gps_data.dirlon = 'W';

         else

            gps_data.dirlon = 'E';        

      }

   }

   if(lat % 360 < 180) {

      gps_data.dirlat = 'N';

      if(lat % 360 > 90) {

         gps_data.latitude = 90 - (lat % 360 - 90);

         gps_data.longitude = 180 - gps_data.longitude;

         if(gps_data.dirlon == 'E')

            gps_data.dirlon = 'W';

         else

            gps_data.dirlon = 'E';

      }

      else

         gps_data.latitude = lat % 360;    

   }

   //generates altitude and time

   gps_data.altitude = 79;

   strcp(gps_data.time, "113024.00");

   //generates the data of the satellites

   gps_data.nsat = 4;

   for(ns = 0; ns < 4; ns++) {

      gps_data.sat_data[ns].id = ns + 20;

      gps_data.sat_data[ns].azimuth = ndemo % azimuth_max[ns];

      gps_data.sat_data[ns].elevation = ndemo % elevation_max[ns];

      gps_data.sat_data[ns].signal_level = ndemo % signal_max[ns];

   }

}

//this task draws the whole graphic on video memory and on mesa buffer

TASK draw(void)

{

  char text[100];    

  TIME draw_TIME, refresh_TIME, gps_TIME;

  while(1) {

    task_testcancel();

    //if demo mode is on it calls demo_val function to generate gps-like values

    if(demo_mode == 1)

       demo_val();

    //gets time of execution of all the tasks

    jet_gettable(refresh_PID, &refresh_TIME, 1);

    jet_gettable(draw_PID, &draw_TIME, 1);

    jet_gettable(gps_PID, &gps_TIME, 1);

    //displays text informations and graphics using standard functions (grx functions)

    //displays the data of the execution times of the tasks 

    sprintf(text,"Hard Task Refresh PER:%6d us EX:%6d us",(int)PERIOD_REFRESH,(int)refresh_TIME);

    grx_text(text,10,55,rgb16(100,100,100),0);    

    sprintf(text,"Hard Task Draw    PER:%6d us EX:%6d us",(int)PERIOD_DRAW,(int)draw_TIME);

    //if there is a risk of system crash warns displaying the text in red color

    if(draw_TIME > PERIOD_DRAW * 0.65)

       grx_text(text,10,65,rgb16(255,0,0),0);

    else

       grx_text(text,10,65,rgb16(100,100,100),0);

    sprintf(text,"Hard Task Gps     PER:%6d us EX:%6d us",(int)PERIOD_GPS,(int)gps_TIME);

    grx_text(text,10,75,rgb16(100,100,100),0);

    //displays data contained in gps_data structure

    grx_rect(0, 0, 799, 89, rgb16(0, 0, 250));

    grx_rect(1, 52, 380, 88, rgb16(100, 100, 100));

    grx_text("Current position :",390,5,rgb16(0,255,255),0);

    sprintf(text,"Latitude %f dir %c      ", gps_data.latitude, gps_data.dirlat);

    grx_text(text,390,25,rgb16(0,255,255),0);

    sprintf(text,"Longitude %f dir %c      ", gps_data.longitude, gps_data.dirlon);

    grx_text(text,390,35,rgb16(0,255,255),0);

    sprintf(text,"Altitude %f   ", gps_data.altitude);

    grx_text(text,390,45,rgb16(0,255,255),0);

    sprintf(text,"Time %c%c:%c%c:%c%c  ", gps_data.time[0], gps_data.time[1], gps_data.time[2], gps_data.time[3], gps_data.time[4], gps_data.time[5]);

    grx_text(text,390,55,rgb16(0,255,255),0);

    sprintf(text,"Speed %f      ", gps_data.speed);

    grx_text(text,390,65,rgb16(0,0,255),0);

    sprintf(text,"Direction %f  ", gps_data.dir_mov);

    grx_text(text,390,75,rgb16(0,0,255),0);

    //displays satellites data contained in the gps_data structure

    grx_text("Satellites in view : ",600,5,rgb16(255,0,0),0);

    sprintf(text,"Number of satellites %f ", gps_data.nsat);

    grx_text(text,600, 25,rgb16(255,0,0),0);

    grx_text("Signal level ", 600, 35,rgb16(255,0,0),0);

    for(nlist = 0; nlist < 4; nlist++)

       if( gps_data.sat_data[nlist].signal_level > 99)

         gps_data.sat_data[nlist].signal_level = 99;

    grx_box(600, 45, 700, 80, rgb16(0, 0, 0));

    grx_box(600, 45, 600+gps_data.sat_data[0].signal_level, 50, rgb16(100, 0, 0));

    grx_box(600, 55, 600+gps_data.sat_data[1].signal_level, 60, rgb16(150, 0, 0));

    grx_box(600, 65, 600+gps_data.sat_data[2].signal_level, 70, rgb16(200, 0, 0));

    grx_box(600, 75, 600+gps_data.sat_data[3].signal_level, 80, rgb16(250, 0, 0));  

    //displays program title and other informations

    grx_text("G P S   D E M O", 10, 5, rgb16(0, 255, 0), 0);

    grx_text("Esc : end program...",170,5,rgb16(0,255,0),0);  

    grx_text("t   : change texture" ,170,15,rgb16(0,255,0),0);

    grx_text("d   : demo/gps mode " ,170,25,rgb16(0,255,0),0);

    grx_text("a z : zoom near/far " ,170,35,rgb16(0,255,0),0);

    if(demo_mode == 1)

       grx_text("Demo mode  " ,10,25,rgb16(255,255,0),0);

    else

       grx_text("Gps mode   " ,10,25,rgb16(0,255,0),0);          

    //displays mesa graphic

    int nmax;

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    //selects and activates the correct texture

    if(sel_texture == 1)    

       glTexImage2D( GL_TEXTURE_2D, 0, 3, 256, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, tex );

    else

       glTexImage2D( GL_TEXTURE_2D, 0, 3, 256, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, tex2 );

    //draws the sphere calling the appropriate list defined in gl_init function

    glPushMatrix();

        polarView();

        glCallList(sphere);

    glPopMatrix();

    //draws the arrow and the cross on the sphere

    glPushMatrix();

        glTranslated (0, 0, zoom);        

        glDisable(GL_TEXTURE_2D);

        glColor3f (0, 1, 1);

        glTranslated (0, 0, 6);

        glRotated(180 + gps_data.dir_mov, 0.0, 0.0, 1.0);

        glLineWidth (2.0);

        glBegin(GL_LINES);

           glVertex2f(-0.2, 0.2);

           glVertex2f(0.2, -0.2);

           glVertex2f(0.2, 0.2);

           glVertex2f(-0.2, -0.2);

           glColor3f (0, 0, 1);

           glVertex2f(0, 0);

           glVertex2f(0, gps_data.speed/30);

           glVertex2f(0, gps_data.speed/30);

           glVertex2f(0.2, gps_data.speed/30-0.2);

           glVertex2f(0, gps_data.speed/30);

           glVertex2f(-0.2, gps_data.speed/30-0.2);

        glEnd();

        glColor3f (0, 0, 0.3);

        glTranslated (0.05, 0.05, 0);

        glBegin(GL_LINES);

           glVertex2f(-0.2, 0.2);

           glVertex2f(0.2, -0.2);

           glVertex2f(0.2, 0.2);

           glVertex2f(-0.2, -0.2);          

           glVertex2f(0, 0);

           glVertex2f(0, gps_data.speed/30);

           glVertex2f(0, gps_data.speed/30);

           glVertex2f(0.2, gps_data.speed/30-0.2);

           glVertex2f(0, gps_data.speed/30);

           glVertex2f(-0.2, gps_data.speed/30-0.2);          

        glEnd();

    glPopMatrix();

    //draws sattellites in view using azimuth and elevation data

    if(gps_data.nsat < 4) //this function can draw four satellites at maximum

       nmax = gps_data.nsat;

    else

       nmax = 4;

    for(nlist = 0; nlist < nmax; nlist++) {

        glPushMatrix();          

           glDisable(GL_TEXTURE_2D);

           glColor3f (0.4+0.2*nlist, 0, 0);

           glLineWidth (2.0);

           glRotated(gps_data.sat_data[nlist].azimuth, 0.0, 0.0, 1.0);

           glTranslated (0, 0, 3 + zoom);

           glRotated(90 - gps_data.sat_data[nlist].elevation, 1.0, 0.0, 0.0);

           glTranslated (0, 0, 4);

           glBegin(GL_LINES);

              glVertex2f(-0.1, -0.1);

              glVertex2f(0.1, 0.1);

              glVertex2f(-0.1, 0.1);

              glVertex2f(0.1, -0.1);

           glEnd();

        glPopMatrix();

    }

    glFinish();

    task_endcycle();

  }

  sys_end();

}

/*This task reads the data from the gps transmitter using the polling system.

  Gps sends data with a rate of 4800 bit/s this means 1 byte every 1.6 ms.

  If you want to be sure to get all the bytes transmitted by the gps you have

  to choose a period <1.6 ms for this gps task, in this program the period is

  1000ns or 1ms.*/

TASK gps(void)

{

  char c;

  while(1) {

    task_testcancel();

    //if a character is present on COM1

    if((com_read(COM1,LSR) & 1) == 1) {

       //reads and stores it in c

       c = com_read(COM1,RBR);

       //if c is a word delimiter

       if( (c == ',') || (c == '\n') || (c == '*') || (c == '\0') ) {

          //ends the current word and resets the word index

          word[ind] = '\0';

          ind = 0;

          //decodes the word variable

          //if word is a label that identifies the beginning of a gpgga string

          if( streq(word, "$GPGGA") == 1 )

             ind_gpgga = 0; //resets the gpgga index

          /*decodes the word depending on the gpgga index that identifies

            the position of the word just read in the gpgga string.

            then the word decoded is stored in the gps_data structure.*/

          switch(ind_gpgga) {

             case 1 : strcp(gps_data.time, word);

                      break;

             case 2 : gps_data.latitude = strtof(word) * 0.01;

                      break;

             case 3 : gps_data.dirlat = word[0];

                      break;

             case 4 : gps_data.longitude = strtof(word) * 0.1;

                      break;

             case 5 : gps_data.dirlon = word[0];

                      break;

             case 9 : gps_data.altitude = strtof(word);

          }

          //if the string is not ended increases the gpgga word counter

          if(ind_gpgga <= 14)

             ind_gpgga++;  

          //the same for gpgsv string

          if( streq(word, "$GPGSV") == 1 )

             ind_gpgsv = 0;

          switch(ind_gpgsv) {

             case 3 : gps_data.nsat = strtof(word);          

                      break;

             case 4 : gps_data.sat_data[0].id = strtof(word);

                      break;

             case 5 : gps_data.sat_data[0].elevation = strtof(word);

                      break;

             case 6 : gps_data.sat_data[0].azimuth = strtof(word);

                      break;

             case 7 : gps_data.sat_data[0].signal_level = strtof(word);

                      break;

             case 8 : gps_data.sat_data[1].id = strtof(word);

                      break;

             case 9 : gps_data.sat_data[1].elevation = strtof(word);

                      break;

             case 10 : gps_data.sat_data[1].azimuth = strtof(word);

                       break;

             case 11 : gps_data.sat_data[1].signal_level = strtof(word);

                       break;

             case 12 : gps_data.sat_data[2].id = strtof(word);

                       break;

             case 13 : gps_data.sat_data[2].elevation = strtof(word);

                       break;

             case 14 : gps_data.sat_data[2].azimuth = strtof(word);

                       break;

             case 15 : gps_data.sat_data[2].signal_level = strtof(word);

                       break;