ogr2rnx.c

The OpenGPSRec receiver software runs on the real time operating system RTAI-Linux. It compiles with

    if (fix < 3)
    {
      printf ("Couldn't detect a 3D fix in this session\n");
      printf
        ("You probably won't get a useful RINEX file, but let's try it\n");
    }
    // return;
  }
  else
  {
    if (found_0e && found_11)   // Found 0x11 AND 0x0e records
    {
      // printf("Using 0x0e and 0x11 records to get date &
      // position\n");
      for (k = 0; k < 3; k++)
        xyz[k] = rec11.llh[k];
      llh2xyz (xyz, xyz);

      *wdays = rec0e.garmin_wdays;
      *tow = (ULONG) rec0e.tow;
      // printf("[%f %f %f] :: %d
      // %u\n",pos[0],pos[1],pos[2],*wdays,*tow);
    }
    else                        // No pertinent records found 
    {
      if ((GIVEN_DATE == 0) || (GIVEN_XYZ == 0))
      {
        printf
          ("Couldn't find any records to get aproximate location and date\n");
        printf
          ("Make sure that you are using the latest version of async to log your data\n");
        printf
          ("You can also overcome this problem by providing the date of observation\n");
        printf
          ("(using the -date DD MM YYYY option) AND your approximate position\n");
        printf ("(using the -llh or -xyz options) in the command line\n");
        printf
          ("-------------------------------------------------------------------------\n");
        printf ("Exiting now\n");
        exit (0);
      }
    }
  }



  // If position or date were provided in the command line 
  // they are always used with preference to those found 

  if (GIVEN_XYZ)
    for (k = 0; k < 3; k++)
      xyz[k] = USER_XYZ[k];

  if (GIVEN_DATE)
    get_wdays_and_tow_from_user_date (wdays, tow);


}




// ///////////////////////////////////////////////7

void
get_current_date (ULONG wdays, double tow, struct tm *gmt)
{
  time_t week_start, current;
  ULONG seconds;
  struct tm *qq;

// Difference beetween GPS time and UNIX time 
  ULONG TIME_START = 631065600L;        

  seconds = (ULONG) floor (tow);

  week_start = TIME_START + wdays * 24 * 3600L;
  current = week_start + seconds;
  qq = gmtime (&current);
  *gmt = *qq;

  return;
}

char *
padd (char *in, char *out, int maxL)
{
  size_t L, cop;
  int k;

  L = strlen (in);
  cop = (L > maxL) ? maxL : L;

  for (k = 0; k < cop; k++)
    out[k] = in[k];
  for (k = cop; k < maxL; k++)
    out[k] = ' ';
  out[maxL] = 0;

  return out;
}



void
generate_rinex_header (xyz, wdays, first_obs, prod_id, version, description,
                       fd)
     double xyz[], first_obs;
     float version;
     ULONG wdays;
     UINT prod_id;
     char *description;
     FILE *fd;
{
  BYTE mask;
  int k, l, lines, written, max_lines, nchars;
  char *header, *ptr;
  time_t tt;
  char *date, buffer[80];
  struct tm gmt;
  double dt, secs;
  char obs[3][3] = { "C1", "L1", "D1" };


  // I dont think I'll use more than 40 lines for the header

  max_lines = 40;
  header = (char *) malloc (max_lines * 80 * sizeof (char));

  ptr = header;

  written = sprintf (ptr, "%6d%14c", 2, 32);
  ptr += written;
  written = sprintf (ptr, padd ("OBSERVATION FILE", buffer, 20));
  ptr += written;
  written = sprintf (ptr, padd ("GPS NAVSTAR", buffer, 20));
  ptr += written;
  written = sprintf (ptr, padd ("RINEX VERSION / TYPE", buffer, 20));
  ptr += written;

  sprintf (buffer, "OGR2RNX %4.2f", VERSION);
  written = sprintf (ptr, padd (buffer, buffer, 20));
  ptr += written;
  written = sprintf (ptr, padd ("Any GPS12 Owner", buffer, 20));
  ptr += written;
  time (&tt);
  date = ctime (&tt);
  written = sprintf (ptr, padd (date, buffer, 20));
  ptr += written;
  written = sprintf (ptr, "PGM / RUN BY / DATE ");
  ptr += written;

  padd ("** ogr2rnx (OpenGPSRec to Rinex) generates Rinex2 files", buffer, 60);
  written = sprintf (ptr, buffer);
  ptr += written;
  written = sprintf (ptr, padd ("COMMENT", buffer, 20));
  ptr += written;

  padd ("** from a OpenGPS receiver.  (c) Antonio Tabernero", buffer, 60);
  written = sprintf (ptr, "%s", buffer);
  ptr += written;
  written = sprintf (ptr, "COMMENT             ");
  ptr += written;


  sprintf (buffer, "** Generated from OGR data file: %s ", DATAFILE);
  padd (buffer, buffer, 60);
  written = sprintf (ptr, "%s", buffer);
  ptr += written;
  written = sprintf (ptr, "%s", padd ("COMMENT", buffer, 20));
  ptr += written;

  written = sprintf (ptr, "** Options: ");
  ptr += written;
  written = sprintf (ptr, padd (COMMAND_LINE, buffer, 60 - written));
  ptr += written;
  written = sprintf (ptr, "COMMENT             ");
  ptr += written;

  sprintf (buffer, "%s", marker);
  written = sprintf (ptr, padd (buffer, buffer, 60));
  ptr += written;
  written = sprintf (ptr, padd ("MARKER NAME", buffer, 20));
  ptr += written;
  written = sprintf (ptr, padd ("Number of Antenna marker", buffer, 60));
  ptr += written;
  written = sprintf (ptr, padd ("MARKER NUMBER", buffer, 20));
  ptr += written;
  written = sprintf (ptr, padd ("John J. Doe", buffer, 20));
  ptr += written;
  written = sprintf (ptr, padd ("John's boss", buffer, 40));
  ptr += written;
  written = sprintf (ptr, "OBSERVER / AGENCY   ");
  ptr += written;

  written = sprintf (ptr, "%03d%17c", prod_id, 32);
  if (written > 20)
    written = 20;
  ptr += written;
  written = sprintf (ptr, "%s  ", padd (description, buffer, 18));
  ptr += 20;
  written = sprintf (ptr, "%4.2f%16c", version, 32);
  if (written > 20)
    written = 20;
  ptr += written;
  written = sprintf (ptr, "REC # / TYPE / VERS ");
  ptr += written;


  written = sprintf (ptr, "%d%19c", 0, 32);
  ptr += written;
  written = sprintf (ptr, padd ("OpenGPS Antenna", buffer, 40));
  ptr += written;
  written = sprintf (ptr, padd ("ANT # / TYPE", buffer, 20));
  ptr += written;

  if (GIVEN_XYZ)
    padd ("** Position provided by user in command line", buffer, 60);
  else
    padd ("** Position from first 3D fix of the receiver", buffer, 60);
  written = sprintf (ptr, buffer);
  ptr += written;
  written = sprintf (ptr, "COMMENT             ");
  ptr += written;

  written =
    sprintf (ptr, "%14.4f%14.4f%14.4f%18c", xyz[0], xyz[1], xyz[2], 32);
  ptr += written;
  written = sprintf (ptr, "APPROX POSITION XYZ ");
  ptr += written;

  written = sprintf (ptr, "%14.4f%14.4f%14.4f%18c", 0.0, 0.0, 0.0, 32);
  ptr += written;
  written = sprintf (ptr, "ANTENNA: DELTA H/E/N");
  ptr += written;


  written = sprintf (ptr, "%6d%6d%48cWAVELENGTH FACT L1/2", L1_FACTOR, 0, 32);
  ptr += written;



  written = sprintf (ptr, "%6d", N_OBS);
  ptr += written;

  for (k = 0, mask = 1; k < 3; k++, mask *= 2)
  {
    if (OBS_MASK & mask)
    {
      written = sprintf (ptr, "%6s", obs[k]);
      ptr += written;
    }
  }
  for (k = N_OBS; k < 9; k++)
  {
    written = sprintf (ptr, "%6c", 32);
    ptr += written;
  }
  written = sprintf (ptr, "# / TYPES OF OBSERV ");
  ptr += written;


  if (RESET_CLOCK)
  {
    dt = first_obs - floor (first_obs + 0.5);
    dt = floor (dt * 1e9) / 1e9;
    first_obs -= dt;
  }

  get_current_date (wdays, first_obs, &gmt);
  written = sprintf (ptr, "%6d%6d", 1900 + gmt.tm_year, gmt.tm_mon + 1);
  ptr += written;
  written = sprintf (ptr, "%6d%6d%6d", gmt.tm_mday, gmt.tm_hour, gmt.tm_min);
  ptr += written;
  secs = (gmt.tm_sec) + first_obs - floor (first_obs);
  written = sprintf (ptr, "%12.6f%6cGPS%9c", secs, 32, 32);
  ptr += written;
  written = sprintf (ptr, "TIME OF FIRST OBS   ");
  ptr += written;

  written = sprintf (ptr, "%6d%54cINTERVAL%12c", INTERVAL, 32, 32);
  ptr += written;
  written = sprintf (ptr, "%60cEND OF HEADER       ", 32);
  ptr += written;


  nchars = (ptr - header);
  lines = nchars / 80;
  // printf("Number of chars %d -> lines %d\n",nchars,lines);

  for (l = 0; l < lines; l++, fprintf (fd, "\n"))
    for (k = 0; k < 80; k++)
      fprintf (fd, "%c", header[l * 80 + k]);

  free ((char *) header);
}



// //////////////////////////////////////////////////


void
print_rinex_info (ULONG wdays, double tow, rinex_obs epoch[], FILE * fd)
{
  int k, N_used;
  double frac, phase, pr;
  int snr;
  struct tm gmt;

  double dt;

//  printf("TOW %.0f Start %d Last %d\n",tow,START,START+ELAPSED);

  for (k = 0, N_used = 0; k < 32; k++)
  {
//    if (epoch[k].used)
//      printf("print_rinex_info: epoch[%d].used = %d\n", k, epoch[k].used);
    if (epoch[k].used >= DUMP)
      N_used++;
  }

//  printf("N_used = %d, DUMP = %d\n", N_used, DUMP);

  if (N_used)
  {
    if (RESET_CLOCK)
    {
      dt = tow - floor (tow + 0.5);
      dt = floor (dt * 1e9) / 1e9;
    }
    else
      dt = 0.0;

    get_current_date (wdays, tow - dt, &gmt);
    frac = (tow - dt) - floor (tow - dt);
    fprintf (fd, " %02d %02d", (1900 + gmt.tm_year) % 100, gmt.tm_mon + 1);
    fprintf (fd, " %02d %02d %02d", gmt.tm_mday, gmt.tm_hour, gmt.tm_min);
    fprintf (fd, "%11.7f", (double) gmt.tm_sec + frac);
    // fprintf(fd,"%11.7f",(double)gmt.tm_sec+frac,32,32);

    fprintf (fd, "%3d%3d", 0, N_used);
    for (k = 0; k < 32; k++)
      if (epoch[k].used >= DUMP)
        fprintf (fd, "G%2d", k + 1);
    for (k = 0; k < 12 - N_used; k++)
      fprintf (fd, "%3c", 32);

    // if(RESET_CLOCK) fprintf(fd,"%12.9f",dt); 
    fprintf (fd, "\n");

    for (k = 0; k < 32; k++)
    {

//      if ( epoch[k].used)
//        printf("epoch[%d].used= %d\n", k, epoch[k].used);

      if (epoch[k].used >= DUMP)
      {
        snr = (NO_SNR) ? 0 : get_q_code (epoch[k].db);

        pr = epoch[k].prange - c * dt;
        phase = epoch[k].phase - L1 * dt;

        /*
         * if(N_OBS>=1) { if(epoch[k].used==DUMP_PHASE_ONLY)
         * fprintf(fd,"%16c",32); else
         * fprintf(fd,"%14.3f%1c%1d",pr,32,snr); } if(N_OBS>=2)
         * fprintf(fd,"%14.3f%1c%1d",phase,32,snr);
         * 
         * if( (N_OBS>=3) && (epoch[k].doppler!=-1))
         * fprintf(fd,"%14.3f%1c%1d",-epoch[k].doppler,32,snr); 
         */

        if (OBS_MASK & 1)       // Pseudoranges
        {
          if (epoch[k].used == DUMP_PHASE_ONLY)
            fprintf (fd, "%16c", 32);
          else
            fprintf (fd, "%14.3f%1c%1d", pr, 32, snr);
        }

        if (OBS_MASK & 2)       // L1 Phase
          fprintf (fd, "%14.3f%1c%1d", phase, 32, snr);

        if ((OBS_MASK & 4) && (epoch[k].doppler != -1)) // Doppler
          fprintf (fd, "%14.3f%1c%1d", -epoch[k].doppler, 32, snr);

        fprintf (fd, "\n");
      }
    }
  }

  return;
}


void
add_0x1a_to_epoch (rinex_obs epoch[], type_rec0x1a chan[])
{
  int k;
  BYTE sv;

  for (k = 0; k < 12; k++)
  {
    sv = chan[k].sv;
    if (sv >= 32)
      continue;
    if (epoch[sv].db == chan[k].db)
      epoch[sv].elev = chan[k].elev;
  }
}




void
get_session_number (char *name, char *ext)
{
  int k;
  FILE *fd;
  char fich[64];

  for (k = 1; k < 10; k++)
  {
    sprintf (fich, "%s%1d.%s%c", name, k, ext, 0);
    fd = fopen (fich, "r");
    if (fd == NULL)
      break;
    fclose (fd);
  }

  strcpy (name, fich);

}

void
get_rinex_file_name (char *station, ULONG week_days, ULONG week_secs, 
  char *filename, char type)
//     char *station, *filename, type;
//     ULONG week_days, week_secs;
{
  struct tm date;
  char ext[8];

  // printf("Week Days %d Week Sec %d\n",week_days,week_secs);

  get_current_date (week_days, (double) week_secs, &date);
  sprintf (filename, "%4s%03d%c", station, date.tm_yday + 1, 0);
  sprintf (ext, "%02d%c%c", (1900 + date.tm_year) % 100, type, 0);
  get_session_number (filename, ext);

  return;
}



/* 
 * verify time tags
 */
void
verify_tt (FILE * org)
{
  ULONG check[32][2], cc;
  BYTE flag[32], ff;

  float tow[32], current_tow;
  // BYTE flag38[32];

  BYTE id, L, record[256], sv;
  int k;
  type_rec0x38 rec;
  type_rec0x36 rec36;

  for (k = 0; k < 32; k++)
  {
    flag[k] = 0xff;
    tow[k] = -1;
  }

  do
  {
    fread (&id, 1, 1, org);
    fread (&L, 1, 1, org);
    fread (record, 1, L, org);

    switch (id)
    {
    case 0x36:
      rec36 = process_0x36 (record);
      sv = rec36.sv;
      if (sv > 32)
        break;
      if (ONE_SAT && (sv != SELECTED_SV))
        break;

      cc = rec36.c50;
      ff = flag[sv];
      if (ff == 0xff)
      {
        flag[sv] = 0;
        check[sv][1] = cc;
        break;
      }

      if (cc == (check[sv][1] + 30))    // OK
      {
        if (ff == 1)            // print report
        {
          printf ("PRN %02d: 0x36 gap ", sv + 1);
          printf ("(%.1f -> %.1f)\n", check[sv][0] / 50.0,
                  check[sv][1] / 50.0);
          flag[sv] = 0;
        }
        check[sv][0] = check[sv][1];
      }
      else
        flag[sv] = 1;           // Lost 0x36 record
      check[sv][1] = cc;

      break;

    case 0x38:
      rec = process_0x38 (record);
      sv = rec.sv;

      if (sv > 32)
        break;
      if (ONE_SAT && (sv != SELECTED_SV))
        break;

      current_tow = (float) floor (rec.tow + 0.5);

      // printf("%.0f %.0f\n",tow[sv],current_tow);

      if (tow[sv] == -1)
      {
        tow[sv] = current_tow;
        break;
      }


      if (current_tow != (tow[sv] + 1))
      {
        printf ("PRN %02d: ", sv + 1);
        if (current_tow < tow[sv])
          printf ("Anomalous tow %.0f -> %.0f\n", tow[sv], current_tow);
        else if (current_tow == tow[sv])
          printf ("%.0f Duplicado\n", current_tow);
        else
        {
          printf ("Missing %.0f", tow[sv] + 1);
          if (current_tow == (tow[sv] + 2))
            printf ("\n");
          else
            printf (" -> %.0f)\n", current_tow - 1);
          tow[sv] = current_tow;
        }
      }
      else
        tow[sv] = current_tow;

      break;

    default:
      break;
    }
  }
  while (feof (org) == 0);

  if (STDIN == 0)
    fclose (org);
  exit (0);
}

type_rec0x38
choose (type_rec0x38 rec[], int nn, rinex_obs last)
{
  int k;
  type_rec0x38 best;
  float dif[2], DIF, dif_min;
  long int dt;

  // Only one case
  if (nn == 1)
  {
    best = rec[0];
    return best;
  }
  // No previous references (any will do)
  if (last.used == NEVER_USED)
    best = rec[nn - 1];
  else                          // Choose between several
  {
    dif_min = (float) 1e30;
    for (k = 0; k < nn; k++)
    {
      dt = rec[k].tracked - last.tracked;