gpsppssync_main.cpp

Go to the documentation of this file.

/**
\file    gpsppssync_main.cpp
\brief   The main function for gpsppssync.

\author  Glenn D. MacGougan (GDM)
\date    2008-12-22
\since   2008-12-22

\b "LICENSE INFORMATION" \n
Copyright (c) 2008 - All rights reserved. \n

Redistribution and use in source and binary forms, with or without
modification, are permitted provided the following conditions are met: \n

- Redistributions of source code must retain the above copyright
  notice, this list of conditions and the following disclaimer. \n
- Redistributions in binary form must reproduce the above copyright
  notice, this list of conditions and the following disclaimer in the
  documentation and/or other materials provided with the distribution. \n
- The name(s) of the contributor(s) may not be used to endorse or promote 
  products derived from this software without specific prior written 
  permission. \n

THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS 
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
SUCH DAMAGE.
*/

#include <windows.h>
#include <process.h>
#include <math.h>
#include <string> // for std::string
#include <time.h>
#include <queue>
#include "SerialPortClass.h"
#include "novatel.h"
#include "time_conversion.h"
#include "gpsppssync_OptionFile.h"
#include "gnss_error.h"

#define PACKET_SIZE (16384)
#define BIG_BUFFER_SIZE (1024*1024) // 1 MB

using namespace std;


struct stUTC
{
  unsigned short year;     // Universal Time Coordinated    [year]
  unsigned char  month;    // Universal Time Coordinated    [1-12 months] 
  unsigned char  day;      // Universal Time Coordinated    [1-31 days]
  unsigned char  hour;     // Universal Time Coordinated    [hours]
  unsigned char  minute;   // Universal Time Coordinated    [minutes]
  float          seconds;  // Universal Time Coordinated    [s]

  stUTC(): year(0), month(0), day(0), hour(0), minute(0), seconds(0.0){}
};

struct stPCTime
{
  unsigned short  utc_year;     // Universal Time Coordinated    [year]
  unsigned char   utc_month;    // Universal Time Coordinated    [1-12 months] 
  unsigned char   utc_day;      // Universal Time Coordinated    [1-31 days]
  unsigned char   utc_hour;     // Universal Time Coordinated    [hours]
  unsigned char   utc_minute;   // Universal Time Coordinated    [minutes]
  float           utc_seconds;  // Universal Time Coordinated    [s]
  unsigned char   utc_offset;
  unsigned short  gps_week;
  double          gps_tow;
  double          jd;
};



/// A non-threaded function to open a com port to an oem3 and sync the PC time to GPS time
/// using serial communications to establish coarse time, then using the PPS which is connected
/// to pin 9 of the serial link to establish fine time.
bool PerformGPSPCTimeSync_NovAtelOEM3( 
  const unsigned SerialPortNumber, //!< The COM port number.
  const unsigned SerialPortNumberOnReceiver, //!< The COM port number to log data from on the receiver.
  const bool PerformPPSTest,       //!< A boolean to indicate if the pulse per second (on pin 9, ring indicator pin) is to be used for fine time synchronization.
  const bool AllowTimeForHyperTerminalComparison //!< A boolean to indicate if 40s with time display and audible dings are to be used to check the synchronization manually.
  );

/// A non-threaded function to open a com port to an oem4 and sync the PC time to GPS time
/// using serial communications to establish coarse time, then using the PPS which is connected
/// to pin 9 of the serial link to establish fine time.
bool PerformGPSPCTimeSync_NovAtelOEM4( 
  const unsigned SerialPortNumber, //!< The COM port number.
  const unsigned SerialPortNumberOnReceiver, //!< The COM port number to log data from on the receiver.
  const bool PerformPPSTest,       //!< A boolean to indicate if the pulse per second (on pin 9, ring indicator pin) is to be used for fine time synchronization.
  const bool AllowTimeForHyperTerminalComparison //!< A boolean to indicate if 40s with time display and audible dings are to be used to check the synchronization manually.
  );


/// Send a message to the receiver. Echo the command to the terminal.
bool SendCommand( SerialPort& port, std::string msg );


int main( int argc, char* argv[] )
{
  try
  {
    gpsppssync_OptionFile opt;
    char buffer[8192];   // A c style string buffer.
    unsigned i = 0;
    
    // set the buffer to zero.
    memset( buffer, 0, 512 );

    // Check the arguments
    if( argc != 2 )
    {
      printf( "USAGE: gpsppssync <option filename>\n" );
      return 0;
    }
    
    // Get the options.
    if( !opt.ReadAndInterpretOptions( argv[1] ) )
    {
      printf( "opt.ReadFromFile returned false.\n" );
      return -1;
    }

    if( opt.m_ReceiverType.compare( "NOVATELOEM3" ) == 0 )
    {
      if( !PerformGPSPCTimeSync_NovAtelOEM3( opt.m_SerialPortNumber, opt.m_ReceiverSerialPortNumber, opt.m_PerformPPSTest, opt.m_AllowTimeForHyperTerminalComparison ) )
      {
        printf( "PerformGPSPCTimeSync_NovAtelOEM3 returned false.\n" );
        return -1;
      }
    }
    else if( opt.m_ReceiverType.compare( "NOVATELOEM4" ) == 0 || opt.m_ReceiverType.compare( "NOVATELOEMV" ) == 0 )
    {
      if( !PerformGPSPCTimeSync_NovAtelOEM4( opt.m_SerialPortNumber, opt.m_ReceiverSerialPortNumber, opt.m_PerformPPSTest, opt.m_AllowTimeForHyperTerminalComparison ) )
      {
        printf( "PerformGPSPCTimeSync_NovAtelOEM4 returned false.\n" );
        return -1;
      }
    }

    printf( "Shutting down.\n" );
    Sleep(1500);
  }
  catch( ... )
  {

  }
  return 0;
}



bool PerformGPSPCTimeSync_NovAtelOEM3( 
  const unsigned SerialPortNumber, //!< The COM port number.
  const unsigned SerialPortNumberOnReceiver, //!< The COM port number to log data from on the receiver.
  const bool PerformPPSTest,       //!< A boolean to indicate if the pulse per second (on pin 9, ring indicator pin) is to be used for fine time synchronization.
  const bool AllowTimeForHyperTerminalComparison //!< A boolean to indicate if 40s with time display and audible dings are to be used to check the synchronization manually.
  )
{
  SerialPort port;
  unsigned char readbuf[PACKET_SIZE];
  unsigned char buffer[PACKET_SIZE];
  unsigned char message[PACKET_SIZE];
  unsigned messageLength = 0;
  unsigned nrBytesRead = 0;
  unsigned nrBytesInBuffer = 0;
  unsigned offset = 0;
  BOOL result = 0;
  BOOL wasEndOfBufferReached = FALSE;
  BOOL wasMessageFound = FALSE;
  unsigned startPosition = 0;
  unsigned messageID = 0;
  unsigned nrBadCheckums = 0;
  int method = 0;
  unsigned count = 0;
  unsigned i = 0;
  std::string msg;
  
  stUTC utc;

  double rs232_transmission_time = 0;
  
  stPCTime pc_time;

  // A container for the POSB message info.
  struct
  {
    unsigned short gps_week;
    double gps_tow;
    double lat;
    double lon;
    double hgt;
    double lat_std;
    double lon_std;
    double hgt_std;
    double undulation;
    unsigned datum_id;
    NOVATELOEM3_enumSolutionStatus status;    
  } posb;

  // A container for the TM1B messsage info.
  struct
  {
    unsigned short gps_week;
    double gps_tow;
    double clk_offset;
    double clk_offset_std;
    double utc_offset; 
    BOOL is_clk_stabilized;
  } tm1b;
  
  clock_t c0;
  clock_t c1;
  double elapsed_time_s = 0;
  bool isPositionValid = false;

  bool coarse_sync_success = false;
  bool pps_sync_success = false;
  bool ring_detected = false;
  bool wasDataReceived = false;
  unsigned pulse_count = 0;

  // Operate this thread at high class priority and high thread priority so that the 
  // time synchronization is accurate.
  //SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS );
  SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS );  
  SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL );

  if( !port.Open( (unsigned short)SerialPortNumber, SERIALPORT_BAUD_115200 ) )
  {
    printf( "Unable to open port %d.", SerialPortNumber );
    return false;
  }
  Sleep(50);

  printf( "Performing GPS - PC time synchronization.\n" );

  sprintf( (char*)message, "unlogall COM%d\r", SerialPortNumberOnReceiver );
  msg = (char*)message;
  SendCommand( port, msg );

  // First ensure the receiver has a valid position.
  sprintf( (char*)message, "log com%d POSB ontime 2.0\r", SerialPortNumberOnReceiver );
  msg = (char*)message;
  SendCommand( port, msg );

  // Flush the com port input buffer
  memset( readbuf, 0, PACKET_SIZE );
  if( !port.Read( readbuf, PACKET_SIZE, nrBytesRead ) )
  {
    printf( "port.Read returned false. port %d.\n", SerialPortNumber );
    return false;
  }
  if( !port.Read( readbuf, PACKET_SIZE, nrBytesRead ) )
  {
    printf( "port.Read returned false. port %d.\n", SerialPortNumber );
    return false;
  }

  c0 = clock();
  while( elapsed_time_s < 30.0 && isPositionValid == false )
  {
    memset( readbuf, 0, PACKET_SIZE );
    if( !port.Read( readbuf, PACKET_SIZE, nrBytesRead ) )
    {
      printf( "port.Read returned false. port %d.\n", SerialPortNumber );
      return false;
    }

    if( nrBytesRead > 0 )
    {
      printf( "%d bytes read.\n", nrBytesRead );
      if( nrBytesRead + offset > PACKET_SIZE )
      {
        printf( "Unexpected.\n");
        return false;
      }
      memcpy( buffer+offset, readbuf, nrBytesRead );
      nrBytesInBuffer += nrBytesRead;
      offset = nrBytesInBuffer;

      if( nrBytesInBuffer > 12 )
      {
        result = NOVATELOEM3_FindNextMessageInBuffer(
          buffer,
          PACKET_SIZE,
          message,
          PACKET_SIZE,
          &wasEndOfBufferReached,
          &wasMessageFound,
          &startPosition,
          &messageLength,
          &messageID,
          &nrBadCheckums
          );
      }
      
      if( wasMessageFound && messageID == NOVATELOEM3_POSB )
      {
        result = NOVATELOEM3_DecodePOSB(
          message,
          messageLength,
          &posb.gps_week,
          &posb.gps_tow,
          &posb.lat,
          &posb.lon,
          &posb.hgt,
          &posb.undulation,
          &posb.datum_id,
          &posb.lat_std,
          &posb.lon_std,
          &posb.hgt_std,
          &posb.status
          );

        if( posb.status == NOVATELOEM3_SOLUTIONSTATUS_OK )
        {
          isPositionValid = true;
          continue;
        }
        else
        {
          offset = 0;
        }
      }
      else
      {
        offset = 0;
      
      }
    }
    Sleep(60);
    c1 = clock();
    elapsed_time_s = ((double)(c1-c0))/((double)CLOCKS_PER_SEC);
  }

  if( !isPositionValid )
  {
    printf( "The receiver position is not yet valid. Try again.\n" );
    return true;
  }
  else
  {
    printf( "A valid receiver position was verified.\n" );
  }

  // Get the receiver to log only TM1B messages ontime 5.0
  sprintf( (char*)message, "unlogall com%d\r", SerialPortNumberOnReceiver );
  msg = (char*)message;  
  SendCommand( port, msg );

  sprintf( (char*)message, "log com%d TM1B ontime 5.0\r", SerialPortNumberOnReceiver );
  msg = (char*)message;
  SendCommand( port, msg );
  Sleep(1500);

  // Flush the com port input buffer
  if( !port.Read( readbuf, PACKET_SIZE, nrBytesRead ) )
  {
    printf( "port.Read returned false. port %d.\n", SerialPortNumber );    
    return false;
  }
  if( !port.Read( readbuf, PACKET_SIZE, nrBytesRead ) )
  {
    printf( "port.Read returned false. port %d.\n", SerialPortNumber );    
    return false;
  }
  
  coarse_sync_success = false;
  tm1b.is_clk_stabilized = FALSE;
  c0 = clock();
  elapsed_time_s = 0;
  while( elapsed_time_s < 30.0 && coarse_sync_success == false )
  {
    memset( readbuf, 0, PACKET_SIZE );
    if( !port.Read( readbuf, PACKET_SIZE, nrBytesRead ) )
    {
      printf( "port.Read returned false. port %d.\n", SerialPortNumber );
      return false;
    }

    if( nrBytesRead > 0 )
    {
      printf( "%d bytes read.\n", nrBytesRead );
      if( nrBytesRead + offset > PACKET_SIZE )
      {
        printf( "Unexpected.\n");
        return false;
      }
      memcpy( buffer+offset, readbuf, nrBytesRead );
      nrBytesInBuffer += nrBytesRead;
      offset = nrBytesInBuffer;

      if( nrBytesInBuffer > 12 )
      {
        result = NOVATELOEM3_FindNextMessageInBuffer(
          buffer,
          PACKET_SIZE,
          message,
          PACKET_SIZE,
          &wasEndOfBufferReached,
          &wasMessageFound,
          &startPosition,
          &messageLength,
          &messageID,
          &nrBadCheckums
          );
      }
      
      if( wasMessageFound && messageID == NOVATELOEM3_TM1B )
      {
        result = NOVATELOEM3_DecodeTM1B(
          message,
          messageLength,
          &tm1b.gps_week,
          &tm1b.gps_tow,
          &tm1b.clk_offset,
          &tm1b.clk_offset_std,
          &tm1b.utc_offset,
          &tm1b.is_clk_stabilized
          );

        if( tm1b.is_clk_stabilized )
        {
          tm1b.gps_week += 1024;
          result = TIMECONV_GetUTCTimeFromGPSTime(
            tm1b.gps_week,
            tm1b.gps_tow,
            &utc.year,
            &utc.month,
            &utc.day,
            &utc.hour,
            &utc.minute,
            &utc.seconds 
            );
          if( !result )
          {
            printf( "TIMECONV_GetUTCTimeFromGPSTime returned false.\n" );
            return false;
          }
          
          rs232_transmission_time = messageLength * 9.0 / 115200.0; // [s], 8 bits per byte + 1 stop bit
            
          utc.seconds -= (float)rs232_transmission_time;

          if( utc.seconds < 0 )
          {
            utc.seconds += 60.0;
            if( utc.minute == 0 )
            {
              utc.minute = 59;
              if( utc.hour == 0 )
              {
                printf( "Too close to midnight to proceed.\n" );                
                return true;
              }
              else
              {
                utc.hour--;
              }
            }
            else
            {
              utc.minute--;
            }
          }

          // Set the PC time
          result = TIMECONV_SetSystemTime(
            utc.year,
            utc.month,
            utc.day,
            utc.hour,
            utc.minute,
            utc.seconds
            );              

          if( !result )
          {
            printf("TIMECONV_SetSystemTime returned FALSE.");            
            return false;
          }
          else
          {
            printf( "Coarse synchronization performed using TM1B message.\n" );
            coarse_sync_success = true;            
            continue;
          }
        }
        else
        {
          offset = 0;
        }
      }
      else
      {
        offset = 0;      
      }
    }
    Sleep(5);
    c1 = clock();
    elapsed_time_s = ((double)(c1-c0))/((double)CLOCKS_PER_SEC);
  }

  if( !coarse_sync_success )
  {
    printf( "Unable to achieve coarse synchronization. Please try again.\n" );
    return false;
  }

  sprintf( (char*)message, "unlogall com%d\r", SerialPortNumberOnReceiver );
  msg = (char*)message;
  SendCommand( port, msg );

  // Perform fine time synchronization.
  c0 = clock();
  elapsed_time_s = 0;
  while( elapsed_time_s < 30.0 && pps_sync_success == false )
  {
    double seconds = 0;
    port.WaitOnRingIndicator( 990, ring_detected );
    if( ring_detected )
    {
      result = TIMECONV_GetSystemTime(
        &pc_time.utc_year,
        &pc_time.utc_month, 
        &pc_time.utc_day,
        &pc_time.utc_hour,
        &pc_time.utc_minute,
        &pc_time.utc_seconds, 
        &pc_time.utc_offset, 
        &pc_time.jd, 
        &pc_time.gps_week, 
        &pc_time.gps_tow 
        );
      if( !result )
      {
        printf( "TIMECONV_GetSystemTime return false." );
        return false;
      }
      seconds = pc_time.utc_seconds;      

      pc_time.utc_seconds = floor( pc_time.utc_seconds + 1 );
      if( pc_time.utc_seconds == 60 )
      {
        pc_time.utc_seconds = 0;
        pc_time.utc_minute++;
        if( pc_time.utc_minute == 60 )
        {
          pc_time.utc_minute = 0;
          pc_time.utc_hour++;
          if( pc_time.utc_hour == 24 )
          {
            printf( "Too close to midnight to proceed\n" );
            return false;
          }
        }
      }

      pulse_count++;
      if( pulse_count == 5 )
      {
        result = TIMECONV_SetSystemTime(
          pc_time.utc_year,
          pc_time.utc_month,
          pc_time.utc_day,
          pc_time.utc_hour,
          pc_time.utc_minute,
          floor(pc_time.utc_seconds) 
          );
        if( !result )
        {
          printf( "TIMECONV_GetSystemTime return false." );
          return false;
        }
        else
        {
          pps_sync_success = true;
        }      
      }
      else
      {
        printf( "Pulse detected: Synchronizing in %d s.\n", 5-pulse_count );
      }
    }    
    else
    {
      printf( "%.0fs Remaining. Listening pin 9, ring indicator pin, of COM%d for PPS\n", 30.0 - elapsed_time_s, port.GetPortNumber() );
    }
    c1 = clock();
    elapsed_time_s = ((double)(c1-c0))/((double)CLOCKS_PER_SEC);
  }

  if( pps_sync_success )
  {
    printf( "Sync to PPS successful.\n" );
  }
  else
  {
    printf( "Failted to sync to PPS. Please try again.\n" );
    return true;
  }

  double mean_diff = 0;
  if( PerformPPSTest )
  {
    int pulsenr = 0;
    bool initc2 = true;
    clock_t c2;
    clock_t c3;
    double dt = 0;
    double diff = 0;    

    printf( "Performing PPS test.\n" );

    // Perform fine time synchronization.
    c0 = clock();
    elapsed_time_s = 0;
    while( elapsed_time_s < 60.0 )
    {
      port.WaitOnRingIndicator( 1005, ring_detected );      
      if( ring_detected )
      {
        if( initc2 )
        {
          c3 = c2 = clock();
          initc2 = false;
        }
        else
        {
          c3 = clock();
        }
        result = TIMECONV_GetSystemTime(
          &pc_time.utc_year,
          &pc_time.utc_month, 
          &pc_time.utc_day,
          &pc_time.utc_hour,
          &pc_time.utc_minute,
          &pc_time.utc_seconds, 
          &pc_time.utc_offset, 
          &pc_time.jd, 
          &pc_time.gps_week, 
          &pc_time.gps_tow 
        );
        if( !result )
        {
          printf( "TIMECONV_GetSystemTime return false." );
          return false;
        }
        dt = ((double)(c3-c2))/((double)CLOCKS_PER_SEC);
        if( pc_time.gps_tow - floor( pc_time.gps_tow ) > 0.5 )
          diff = -(floor( pc_time.gps_tow + 0.5 ) - pc_time.gps_tow)*1000.0;
        else
          diff = (pc_time.gps_tow - floor( pc_time.gps_tow ))*1000.0;

        mean_diff += diff;

        printf( "Pulse:%2d, dt:%.3f, PC(hh:mm:ss.sss): %02d:%02d:%06.3f difference:%.0f ms\n", pulsenr, dt, pc_time.utc_hour, pc_time.utc_minute, pc_time.utc_seconds, diff );
        pulsenr++;        
      }
      else
      {
        printf( "No ring.\n" );
      }
      c1 = clock();
      elapsed_time_s = ((double)(c1-c0))/((double)CLOCKS_PER_SEC);
    }
    printf( "Over 60 seconds, the difference in elapsed PC time is %.3f s\n", dt-60.0 );
    mean_diff/= (double)pulsenr;
    printf( "The mean pulse to pc time difference is: %.3f ms\n", mean_diff );
  }


  if( AllowTimeForHyperTerminalComparison )
  {
    sprintf( (char*)message, "log com%d gpzda ontime 1.0\r", SerialPortNumberOnReceiver );
    msg = (char*)message;
    SendCommand( port, msg );

    sprintf( (char*)message, "log com%d posa ontime 1.0\r", SerialPortNumberOnReceiver );
    msg = (char*)message;
    SendCommand( port, msg );
  }

  port.Close();

  
  if( AllowTimeForHyperTerminalComparison )
  {  
    printf( "The serial port is now closed you may open the port with hyperterminal for comparison.\n" );
    if( pps_sync_success )
    {
      count = 0;
      while( count < 40 )
      {
        TIMECONV_GetSystemTime(
          &pc_time.utc_year,
          &pc_time.utc_month,
          &pc_time.utc_day,
          &pc_time.utc_hour,
          &pc_time.utc_minute,
          &pc_time.utc_seconds,
          &pc_time.utc_offset,
          &pc_time.jd,
          &pc_time.gps_week,
          &pc_time.gps_tow
          );
        if( fabs(pc_time.utc_seconds - floor(pc_time.utc_seconds)) < 0.05 )
        {
          printf( "%02d:%02d:%.3f\t\t\t %d %.3f\n", pc_time.utc_hour, pc_time.utc_minute, pc_time.utc_seconds, pc_time.gps_week, pc_time.gps_tow );
          printf( "\a" );
          count++;
          Sleep(980);
        }
        Sleep(2);
      }
    }    
  }

  SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS );  
  SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL );

  return true; 
}


bool PerformGPSPCTimeSync_NovAtelOEM4( 
  const unsigned SerialPortNumber, //!< The COM port number.
  const unsigned SerialPortNumberOnReceiver, //!< The COM port number to log data from on the receiver.
  const bool PerformPPSTest,       //!< A boolean to indicate if the pulse per second (on pin 9, ring indicator pin) is to be used for fine time synchronization.
  const bool AllowTimeForHyperTerminalComparison //!< A boolean to indicate if 40s with time display and audible dings are to be used to check the synchronization manually.
  )
{
  SerialPort port;
  unsigned char readbuf[PACKET_SIZE];
  unsigned char buffer[PACKET_SIZE];
  unsigned char message[PACKET_SIZE];
  unsigned short messageLength = 0;
  unsigned nrBytesRead = 0;
  unsigned nrBytesInBuffer = 0;
  unsigned offset = 0;
  BOOL result = 0;
  BOOL wasEndOfBufferReached = FALSE;
  BOOL wasMessageFound = FALSE;
  unsigned startPosition = 0;
  unsigned short messageID = 0;
  unsigned nrBadCRC = 0;
  int method = 0;
  unsigned count = 0;
  unsigned i = 0;
  std::string msg;
  
  stUTC utc;

  double rs232_transmission_time = 0;
  
  stPCTime pc_time;

  NOVATELOEM4_structBinaryHeader  header;   
  NOVATELOEM4_structBestPosition  bestpos;
  NOVATELOEM4_structTime          time_data;
  
  clock_t c0;
  clock_t c1;
  double elapsed_time_s = 0;
  bool isPositionValid = false;

  bool coarse_sync_success = false;
  bool pps_sync_success = false;
  bool ring_detected = false;
  bool wasDataReceived = false;
  unsigned pulse_count = 0;

  // Operate this thread at high class priority and high thread priority so that the 
  // time synchronization is accurate.
  //SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS );
  SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS );  
  SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL );

  if( !port.Open( (unsigned short)SerialPortNumber, SERIALPORT_BAUD_115200 ) )
  {
    printf( "Unable to open port %d.", SerialPortNumber );
    return false;
  }
  Sleep(50);

  printf( "Performing GPS - PC time synchronization.\n" );

  sprintf( (char*)message, "unlogall COM%d_ALL\r", SerialPortNumberOnReceiver );
  msg = (char*)message;
  SendCommand( port, msg );

  // First ensure the receiver has a valid position.
  sprintf( (char*)message, "log com%d BESTPOSB ontime 2.0\r", SerialPortNumberOnReceiver );
  msg = (char*)message;
  SendCommand( port, msg );
  Sleep(1500);

  // Flush the com port input buffer
  if( !port.Read( readbuf, PACKET_SIZE, nrBytesRead ) )
  {
    printf( "port.Read returned false. port %d.\n", SerialPortNumber );
    return false;
  }
  if( !port.Read( readbuf, PACKET_SIZE, nrBytesRead ) )
  {
    printf( "port.Read returned false. port %d.\n", SerialPortNumber );
    return false;
  }
  
  c0 = clock();
  while( elapsed_time_s < 30.0 && isPositionValid == false )
  {
    memset( readbuf, 0, PACKET_SIZE );
    if( !port.Read( readbuf, PACKET_SIZE, nrBytesRead ) )
    {
      printf( "port.Read returned false. port %d.\n", SerialPortNumber );
      return false;
    }

    if( nrBytesRead > 0 )
    {
      printf( "%d bytes read.\n", nrBytesRead );
      if( nrBytesRead + offset > PACKET_SIZE )
      {
        printf( "Unexpected.\n");
        return false;
      }
      memcpy( buffer+offset, readbuf, nrBytesRead );
      nrBytesInBuffer += nrBytesRead;
      offset = nrBytesInBuffer;

      if( nrBytesInBuffer > 32 )
      {
        result = NOVATELOEM4_FindNextMessageInBuffer(
          buffer,
          PACKET_SIZE,
          message,
          PACKET_SIZE,
          &wasEndOfBufferReached,
          &wasMessageFound,
          &startPosition,
          &messageLength,
          &messageID,
          &nrBadCRC
          );
      }
      
      if( wasMessageFound && messageID == NOVATELOEM4_BESTPOSB )
      {
        result = NOVATELOEM4_DecodeBESTPOSB(
          message,
          messageLength,
          &header,
          &bestpos
          );

        if( bestpos.solution_status == NOVATELOEM4_SOLNSTATUS_SOL_COMPUTED )
        {
          isPositionValid = true;
          continue;
        }
        else
        {
          offset = 0;
        }
      }
      else
      {
        offset = 0;
      
      }
    }
    Sleep(60);
    c1 = clock();
    elapsed_time_s = ((double)(c1-c0))/((double)CLOCKS_PER_SEC);
  }

  if( !isPositionValid )
  {
    printf( "The receiver position is not yet valid. Try again.\n" );
    return true;
  }
  else
  {
    printf( "A valid receiver position was verified.\n" );
  }

  // Get the receiver to log only TIMEB messages ontime 5.0
  sprintf( (char*)message, "unlogall COM%d_ALL\r", SerialPortNumberOnReceiver );
  msg = (char*)message;  
  SendCommand( port, msg );

  sprintf( (char*)message, "log com%d TIMEB ontime 5.0\r", SerialPortNumberOnReceiver );
  msg = (char*)message;
  SendCommand( port, msg );
  Sleep(1500);

  // Flush the com port input buffer
  if( !port.Read( readbuf, PACKET_SIZE, nrBytesRead ) )
  {
    printf( "port.Read returned false. port %d.\n", SerialPortNumber );    
    return false;
  }
  if( !port.Read( readbuf, PACKET_SIZE, nrBytesRead ) )
  {
    printf( "port.Read returned false. port %d.\n", SerialPortNumber );    
    return false;
  }
    
  coarse_sync_success = false;
  time_data.clock_status = NOVATELOEM4_CLOCK_STATUS_UNKNOWN;
  c0 = clock();
  elapsed_time_s = 0;
  while( elapsed_time_s < 30.0 && coarse_sync_success == false )
  {
    memset( readbuf, 0, PACKET_SIZE );
    if( !port.Read( readbuf, PACKET_SIZE, nrBytesRead ) )
    {
      printf( "port.Read returned false. port %d.\n", SerialPortNumber );
      return false;
    }

    if( nrBytesRead > 0 )
    {
      printf( "%d bytes read.\n", nrBytesRead );
      if( nrBytesRead + offset > PACKET_SIZE )
      {
        printf( "Unexpected.\n");
        return false;
      }
      memcpy( buffer+offset, readbuf, nrBytesRead );
      nrBytesInBuffer += nrBytesRead;
      offset = nrBytesInBuffer;

      if( nrBytesInBuffer > 32 )
      {
        result = NOVATELOEM4_FindNextMessageInBuffer(
          buffer,
          PACKET_SIZE,
          message,
          PACKET_SIZE,
          &wasEndOfBufferReached,
          &wasMessageFound,
          &startPosition,
          &messageLength,
          &messageID,
          &nrBadCRC
          );
      }
      
      if( wasMessageFound && messageID == NOVATELOEM4_TIMEB )
      {
        result = NOVATELOEM4_DecodeTIMEB(
          message,
          messageLength,
          &header,
          &time_data
          );

        if( time_data.clock_status == NOVATELOEM4_CLOCK_STATUS_VALID && time_data.isUTCValid )
        {
          utc.year = time_data.utc_year;
          utc.month = time_data.utc_month;
          utc.day = time_data.utc_day;
          utc.hour = time_data.utc_hour;
          utc.minute = time_data.utc_minute;
          utc.seconds = ((float)time_data.utc_milliseconds)/1000.0f;
          
          rs232_transmission_time = messageLength * 9.0 / 115200.0; // [s]
            
          utc.seconds -= (float)rs232_transmission_time;

          if( utc.seconds < 0 )
          {
            utc.seconds += 60.0;
            if( utc.minute == 0 )
            {
              utc.minute = 59;
              if( utc.hour == 0 )
              {
                printf( "Too close to midnight to proceed.\n" );                
                return true;
              }
              else
              {
                utc.hour--;
              }
            }
            else
            {
              utc.minute--;
            }
          }

          result = TIMECONV_SetSystemTime(
            utc.year,
            utc.month,
            utc.day,
            utc.hour,
            utc.minute,
            utc.seconds
            );              

          if( !result )
          {
            printf("TIMECONV_SetSystemTime returned FALSE.");            
            return false;
          }
          else
          {
            printf( "Coarse synchronization performed using TIMEB message.\n" );
            coarse_sync_success = true;            
            continue;
          }
        }
        else
        {
          offset = 0;
        }
      }
      else
      {
        offset = 0;      
      }
    }
    Sleep(5);
    c1 = clock();
    elapsed_time_s = ((double)(c1-c0))/((double)CLOCKS_PER_SEC);
  }

  if( !coarse_sync_success )
  {
    printf( "Unable to achieve coarse synchronization. Please try again.\n" );
    return false;
  }

  sprintf( (char*)message, "unlogall COM%d_ALL\r", SerialPortNumberOnReceiver );
  msg = (char*)message;
  SendCommand( port, msg );

  // Perform fine time synchronization.
  c0 = clock();
  elapsed_time_s = 0;
  while( elapsed_time_s < 30.0 && pps_sync_success == false )
  {
    double seconds = 0;
    port.WaitOnRingIndicator( 990, ring_detected );
    if( ring_detected )
    {
      result = TIMECONV_GetSystemTime(
        &pc_time.utc_year,
        &pc_time.utc_month, 
        &pc_time.utc_day,
        &pc_time.utc_hour,
        &pc_time.utc_minute,
        &pc_time.utc_seconds, 
        &pc_time.utc_offset, 
        &pc_time.jd, 
        &pc_time.gps_week, 
        &pc_time.gps_tow 
        );
      if( !result )
      {
        printf( "TIMECONV_GetSystemTime return false." );
        return false;
      }
      seconds = pc_time.utc_seconds;      

      pc_time.utc_seconds = floor( pc_time.utc_seconds + 1 );
      if( pc_time.utc_seconds == 60 )
      {
        pc_time.utc_seconds = 0;
        pc_time.utc_minute++;
        if( pc_time.utc_minute == 60 )
        {
          pc_time.utc_minute = 0;
          pc_time.utc_hour++;
          if( pc_time.utc_hour == 24 )
          {
            printf( "Too close to midnight to proceed\n" );
            return false;
          }
        }
      }

      pulse_count++;
      if( pulse_count == 5 )
      {
        result = TIMECONV_SetSystemTime(
          pc_time.utc_year,
          pc_time.utc_month,
          pc_time.utc_day,
          pc_time.utc_hour,
          pc_time.utc_minute,
          floor(pc_time.utc_seconds) 
          );
        if( !result )
        {
          printf( "TIMECONV_GetSystemTime return false." );
          return false;
        }
        else
        {
          pps_sync_success = true;
        }      
      }
      else
      {
        printf( "Pulse detected: Synchronizing in %d s.\n", 5-pulse_count );
      }
    }    
    else
    {
      printf( "%.0fs Remaining. Listening pin 9, ring indicator pin, of COM%d for PPS\n", 30.0 - elapsed_time_s, port.GetPortNumber() );
    }
    c1 = clock();
    elapsed_time_s = ((double)(c1-c0))/((double)CLOCKS_PER_SEC);
  }

  if( pps_sync_success )
  {
    printf( "Sync to PPS successful.\n" );
  }
  else
  {
    printf( "Failted to sync to PPS. Please try again.\n" );
    return true;
  }


  double mean_diff = 0;
  if( PerformPPSTest )
  {
    int pulsenr = 0;
    bool initc2 = true;
    clock_t c2;
    clock_t c3;
    double dt = 0;
    double diff = 0;
   
    printf( "Performing PPS test.\n" );

    // Perform fine time synchronization.
    c0 = clock();
    elapsed_time_s = 0;
    while( elapsed_time_s < 60.0 )
    {
      port.WaitOnRingIndicator( 1005, ring_detected );      
      if( ring_detected )
      {
        if( initc2 )
        {
          c3 = c2 = clock();
          initc2 = false;
        }
        else
        {
          c3 = clock();
        }
        result = TIMECONV_GetSystemTime(
          &pc_time.utc_year,
          &pc_time.utc_month, 
          &pc_time.utc_day,
          &pc_time.utc_hour,
          &pc_time.utc_minute,
          &pc_time.utc_seconds, 
          &pc_time.utc_offset, 
          &pc_time.jd, 
          &pc_time.gps_week, 
          &pc_time.gps_tow 
        );
        if( !result )
        {
          printf( "TIMECONV_GetSystemTime return false." );
          return false;
        }
        dt = ((double)(c3-c2))/((double)CLOCKS_PER_SEC);
        if( pc_time.gps_tow - floor( pc_time.gps_tow ) > 0.5 )
          diff = -(floor( pc_time.gps_tow + 0.5 ) - pc_time.gps_tow)*1000.0;
        else
          diff = (pc_time.gps_tow - floor( pc_time.gps_tow ))*1000.0;

        mean_diff += diff;

        printf( "Pulse:%2d, dt:%.3f, PC(hh:mm:ss.sss): %02d:%02d:%06.3f  difference:%.0f ms\n", pulsenr, dt, pc_time.utc_hour, pc_time.utc_minute, pc_time.utc_seconds, diff );
        pulsenr++;        
      }
      else
      {
        printf( "No ring.\n" );
      }
      c1 = clock();
      elapsed_time_s = ((double)(c1-c0))/((double)CLOCKS_PER_SEC);
    }
    printf( "Over 60 seconds, the difference in elapsed PC time is %.3f s\n", dt-60.0 );
    mean_diff/= (double)pulsenr;
    printf( "The mean pulse to pc time difference is: %.3f ms\n", mean_diff );
  }


  if( AllowTimeForHyperTerminalComparison )
  {
    sprintf( (char*)message, "log com%d gpzda ontime 1.0\r", SerialPortNumberOnReceiver );
    msg = (char*)message;
    SendCommand( port, msg );

    sprintf( (char*)message, "log com%d bestposa ontime 1.0\r", SerialPortNumberOnReceiver );
    msg = (char*)message;
    SendCommand( port, msg );
  }

  port.Close();

  
  if( AllowTimeForHyperTerminalComparison )
  {  
    printf( "The serial port is now closed you may open the port with hyperterminal for comparison.\n" );
    if( pps_sync_success )
    {
      count = 0;
      while( count < 40 )
      {
        TIMECONV_GetSystemTime(
          &pc_time.utc_year,
          &pc_time.utc_month,
          &pc_time.utc_day,
          &pc_time.utc_hour,
          &pc_time.utc_minute,
          &pc_time.utc_seconds,
          &pc_time.utc_offset,
          &pc_time.jd,
          &pc_time.gps_week,
          &pc_time.gps_tow
          );
        if( fabs(pc_time.utc_seconds - floor(pc_time.utc_seconds)) < 0.05 )
        {
          printf( "%02d:%02d:%.3f\t\t\t %d %.3f\n", pc_time.utc_hour, pc_time.utc_minute, pc_time.utc_seconds, pc_time.gps_week, pc_time.gps_tow );
          printf( "\a" );
          count++;
          Sleep(980);
        }
        Sleep(2);
      }
    }    
  }

  SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS );  
  SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL );

  return true; 
}

bool SendCommand( SerialPort& port, std::string msg )
{
  unsigned nrBytesRead = 0;
  if( !port.Write( (unsigned char*)msg.c_str(), msg.length() ) )
  {
    printf( "port.Write returned false.\n" );    
    return false;
  }    
  printf( "Command to COM%d:\n%s\n", port.GetPortNumber(), msg.c_str() );
  Sleep(500);
  return true;
}