/home/kopmann/git-mirror/fdhwlib/fdhwlib/gpsoncore/gpsserver.h

Go to the documentation of this file.

/***************************************************************************
                          gpsserver.h  -  description
                             -------------------
    begin                : Mon Dec 9 2002
    copyright            : (C) 2002 by Andreas Kopmann
    email                : kopmann@ipe.fzk.de
 ***************************************************************************/


#ifndef GPSSERVER_H
#define GPSSERVER_H

#include <string>
#include <termios.h>

// Version control
// Initial release of the GPS Clock, operating from
// mid of 2003 until march 2004.
//#define GPS_VER 100
//#define GPS_MIN_VER 100

// Version 3.4, changed coding of the GPS Clock state.
// Now the two signals "inhibit" (bit 1) and "exttrig"
// (bit 0) code the four states "normal" (00),
// "exttrig" (01), "veto" (10), "stop" (11).
//#define GPS_VER 340
//#define GPS_MIN_VER 340


//#define GPS_VER 350 // ???
//#define GPS_MIN_VER 350

// GPS Clock sends status message in case of changes in the
// status register, 28-04-2004
//#define GPS_VER 360
//#define GPS_MIN_VER 360


// Enable/Disable of signal inputs, Status Messgage changed.
// Lidar frequency changed to 333Hz (?)
// 13-10-2004 ak
//
//#define GPS_VER 400
//#define GPS_MIN_VER 360


// Lidar frequency changed to 1000Hz (again).
// Known bug:
//   - The gate generators could not be set individually
// 24-04-2006 ak
//
//#define GPS_VER 500
//#define GPS_MIN_VER 360

// Lidar frequency 0 / 20 / 334 / 1000Hz (again).
//- a problem with using several GGs at the same time (independently) 
//  has been removed
//- the new version allows to set the Lidar frequency
//  to 0 Hz (=off), 20 Hz, 334 Hz and (new !) 1 kHz.

// 05-12-2006 ak
//
//#define GPS_VER 600
//#define GPS_MIN_VER 400

// DT 11/2008
//
// An improper behaviour of generators in case of following settings:
// generator repeat rate > 0 (every 2,3 ... sec) and pulse start time = 0

// 16-07-2010 thjm
//
#define GPS_VER 700
#define GPS_MIN_VER 400


/* Version number of the GPS protocol
 */
//#define GPS_PROT_VER 100 // Initial version
#define GPS_PROT_VER 110 // Extented command gettime - transfer both counters
//#define GPS_PROT_VER 120 // Extended get/set generator parameter by status flag


#define DEVICE1   "/dev/oncore.serial.%d"   
#define GPSSERVER_PORT 5198


#define GPSTEST_MAX 10
#define GPSCMD_MAX 50


#include <akutil/simpleserver.h>
#include "gpsclock.h"

#include <sys/types.h>

typedef signed char s_char;
typedef u_int32_t   u_int32;


/*
 * Structure interface between the reference clock support
 * ntp_refclock.c and the driver utility routines
 */
#define MAXSTAGE  60  /* max median filter stages  */
#define NSTAGE    5  /* default median filter stages */
#define BMAX    128  /* max timecode length */
#define GMT    0  /* I hope nobody sees this */
#define MAXDIAL    60  /* max length of modem dial strings */

/*
 * Line discipline flags. These require line discipline or streams
 * modules to be installed/loaded in the kernel. If specified, but not
 * installed, the code runs as if unspecified.
 */
#define LDISC_STD  0x0  /* standard */
#define LDISC_CLK  0x1  /* tty_clk \n intercept */
#define LDISC_CLKPPS  0x2  /* tty_clk \377 intercept */
#define LDISC_ACTS  0x4  /* tty_clk #* intercept */
#define LDISC_CHU  0x8  /* depredated */
#define LDISC_PPS  0x10  /* ppsclock, ppsapi */
#define LDISC_RAW  0x20  /* raw binary */

struct refclockproc {
  //struct  refclockio io;  /* I/O handler structure */
  caddr_t  unitptr;  /* pointer to unit structure */
  u_char  leap;    /* leap/synchronization code */
  u_char  currentstatus;  /* clock status */
  u_char  lastevent;  /* last exception event */
  u_char  type;    /* clock type */
  const char *clockdesc;  /* clock description */

  char  a_lastcode[BMAX]; /* last timecode received */
  u_short  lencode;  /* length of last timecode */

  int  year;    /* year of eternity */
  int  day;    /* day of year */
  int mday;   /* day of month */
  int month;  /* month */
  int  hour;    /* hour of day */
  int  minute;    /* minute of hour */
  int  second;    /* second of minute */
  int  msec;    /* millisecond of second */
  int  usec;    /* microsecond of second (alt) */
  u_long nsec;   /* nanoseconds */
  u_long  yearstart;  /* beginning of year */
  int  coderecv;  /* put pointer */
  int  codeproc;  /* get pointer */
  //l_fp  lastref;  /* timecode timestamp */
  //l_fp  lastrec;  /* local timestamp */
  double  offset;    /* mean offset */
  double  disp;    /* sample dispersion */
  double  jitter;    /* jitter (mean squares) */
  double  filter[MAXSTAGE]; /* median filter */

  /*
   * Configuration data
   */
  double  fudgetime1;  /* fudge time1 */
  double  fudgetime2;  /* fudge time2 */
  u_int32  refid;    /* reference identifier */
  u_char  sloppyclockflag; /* fudge flags */

  /*
   * Status tallies
    */
  u_long  timestarted;  /* time we started this */
  u_long  polls;    /* polls sent */
  u_long  noreply;  /* no replies to polls */
  u_long  badformat;  /* bad format reply */
  u_long  baddata;  /* bad data reply */
};


struct peer {
  struct peer *next;  /* pointer to next association */
  struct peer *ass_next;  /* link pointer in associd hash */
  //struct sockaddr_in srcadr; /* address of remote host */
  //struct interface *dstadr; /* pointer to address on local host */
  //associd_t associd;  /* association ID */
  u_char  version;  /* version number */
  u_char  hmode;    /* local association mode */
  u_char  hpoll;    /* local poll interval */
  u_char  kpoll;    /* last poll interval */
  u_char  minpoll;  /* min poll interval */
  u_char  maxpoll;  /* max poll interval */
  u_char  burst;    /* packets remaining in burst */
  u_int  flags;    /* association flags */
  u_char  cast_flags;  /* additional flags */
  u_int  flash;    /* protocol error test tally bits */
  u_char  last_event;  /* last peer error code */
  u_char  num_events;  /* number of error events */
  u_char  ttlmax;    /* max ttl/refclock mode */

  /*
   * Variables used by reference clock support
   */
  struct refclockproc *procptr; /* refclock structure pointer */
  u_char  refclktype;  /* reference clock type */
  u_char  refclkunit;  /* reference clock unit number */
  u_char  sstclktype;  /* clock type for system status word */

  /*
   * Variables set by received packet
   */
  u_char  leap;    /* local leap indicator */
  u_char  pmode;    /* remote association mode */
  u_char  stratum;  /* remote stratum */
  s_char  precision;  /* remote clock precision */
  u_char  ppoll;    /* remote poll interval */
  u_int32  refid;    /* remote reference ID */
  //l_fp  reftime;  /* update epoch */

  /*
   * Variables used by authenticated client
   */
  //keyid_t keyid;    /* current key ID */
#ifdef AUTOKEY
#define clear_to_zero assoc
  associd_t assoc;  /* peer association ID */
  u_int32  crypto;    /* peer status word */
#ifdef PUBKEY
  struct  value pubkey;  /* public key */
  struct  value certif;  /* certificate */
  u_char  *keystr;  /* host name */
#endif /* PUBKEY */
  keyid_t  pkeyid;    /* previous key ID */
  keyid_t  hcookie;  /* host cookie */
  struct cookie pcookie;  /* peer cookie */
  struct autokey recauto;  /* autokey */
  u_int32  cmmd;    /* peer command */
  /*
   * Variables used by authenticated server
   */
  keyid_t  *keylist;  /* session key ID list */
  int  keynumber;  /* current key number */
  struct autokey sndauto;  /* autokey */
#else /* AUTOKEY */
#define clear_to_zero status
#endif /* AUTOKEY */

  /*
   * Ephemeral state variables
   */
  u_char  status;    /* peer status */
  u_char  pollsw;    /* what it says */
  u_char  ttl;            /* ttl for manycast mode */
  u_char  reach;    /* reachability register */
  u_char  unreach;  /* unreachable count */
  u_long  epoch;    /* reference epoch */
  u_short  filter_nextpt;  /* index into filter shift register */
//  double  filter_delay[NTP_SHIFT]; /* delay shift register */
//  double  filter_offset[NTP_SHIFT]; /* offset shift register */
//  double  filter_disp[NTP_SHIFT]; /* dispersion shift register */
//  u_long  filter_epoch[NTP_SHIFT]; /* epoch shift register */
//  u_char  filter_order[NTP_SHIFT]; /* filter sort index */
//  l_fp  org;    /* originate time stamp */
//  l_fp  rec;    /* receive time stamp */
//  l_fp  xmt;    /* transmit time stamp */
  double  offset;    /* peer clock offset */
  double  delay;    /* peer roundtrip delay */
  double  jitter;    /* peer jitter (squares) */
  double  disp;    /* peer dispersion */
  double  estbdelay;  /* clock offset to broadcast server */

  /*
   * Variables set by received packet
   */
  double  rootdelay;  /* roundtrip delay to primary clock */
  double  rootdispersion;  /* dispersion to primary clock */

  /*
   * End of clear-to-zero area
   */
  u_long  update;    /* receive epoch */
#define end_clear_to_zero update
  u_long  outdate;  /* send time last packet */
  u_long  nextdate;  /* send time next packet */
  u_long  nextaction;  /* peer local activity timeout (refclocks mainly) */
//  void (*action) P((struct peer *)); /* action timeout function */
  /*
   * Statistic counters
   */
  u_long  timereset;  /* time stat counters were reset */
  u_long  timereceived;  /* last packet received time */
  u_long  timereachable;  /* last reachable/unreachable time */

  u_long  sent;    /* packets sent */
  u_long  received;  /* packets received */
  u_long  processed;  /* packets processed by the protocol */
  u_long  badauth;  /* packets cryptosum failed */
  u_long  bogusorg;  /* packets bogus origin */
  u_long  oldpkt;    /* packets duplicate packet */
  u_long  seldisptoolarge; /* packets dispersion to large*/
  u_long  selbroken;  /* not used */
};

/*
 * Values for peer.leap, sys_leap
 */
#define  LEAP_NOWARNING  0x0  /* normal, no leap second warning */
#define  LEAP_ADDSECOND  0x1  /* last minute of day has 61 seconds */
#define  LEAP_DELSECOND  0x2  /* last minute of day has 59 seconds */
#define  LEAP_NOTINSYNC  0x3  /* overload, clock is free running */



enum receive_state {
  ONCORE_NO_IDEA,
  ONCORE_ID_SENT,
  ONCORE_RESET_SENT,
  ONCORE_TEST_SENT,
  ONCORE_INIT,
  ONCORE_ALMANAC,
  ONCORE_RUN
};

enum site_survey_state {
  ONCORE_SS_UNKNOWN,
  ONCORE_SS_TESTING,
  ONCORE_SS_HW,
  ONCORE_SS_SW,
  ONCORE_SS_SAVE,
  ONCORE_SS_DONE
};


enum oncore_model {
  ONCORE_BASIC,
  ONCORE_PVT6,
  ONCORE_VP,
  ONCORE_UT,
  ONCORE_UTPLUS,
  ONCORE_GT,
  ONCORE_GTPLUS,
  ONCORE_SL,
  ONCORE_M12,
  ONCORE_UNKNOWN
};


struct RSM {
  u_char  posn0D;
  u_char  posn2D;
  u_char  posn3D;
  u_char  bad_almanac;
  u_char  bad_fix;
};


enum posn_mode {
  MODE_UNKNOWN,
  MODE_0D,
  MODE_2D,
  MODE_3D
};


struct secTiming{
  unsigned int gpsSec; // Name of the second
  unsigned int oncoreSec; // Oncore counter
  unsigned int augerSec; // Second counter of the timing unit
  unsigned int pcSec;  // Second counter of the PC while reading
  int pcMiliSec;        // Arival of the message
  int leapSec;          // Leap seconds

  int phase;            // Phase
  //int mSec;             // ms
  //int uSec;             // us
  //int n125Sec;          // 12.5 ns
  int count;            // counter [12.5ns]
  int sawtooth;         // neagtive sawtooth parameter

  double T10;           // (Real) length of the "10MHz" signal [ns]
  double offset;        // Offset between 1pps signal and "10MHz" signal [ns]

  int quality;          // Quality of the values
                        // ???
  int ptrCapture;       // Pointer to the first capture timestamp
                        // in the capture buffer
  int nCapture;         // Number of capture values during this second

};



struct posData {
  int latitude;         //< Latutude
  int longitude;        //< Longitude
  int height;         //< Height
  std::string name;          //< Name
  int id;                    //< Id of the eyestation (1..4)
};

#define T_BUFFER_LEN 100    //< Number of elements in the timing buffer
#define T_CAPTURE_LEN 100   //< Number of time stamps in the capture buffer
#define POS_DATABASE_LEN 10 //< Number of elements in the position data base



enum deviceId {
   GPSSERVER,
   GPSCLOCKMAX,
   GPSCLOCKMIN,
   GPSCLOCK,
   ONCORE
};


struct cmd_desc {
  const char *name;
  u_char     *data;
  int        len;   
};




class shell;
class cmds;
class GpsClock;
class SimpleSocket;
class procDuration;

/* Site survey parameters (not active at the moment):
  *  - startup Define the startup mode. Known modes are listen , set
  *    position name and survey position name.
  *    <pre>
  *    startup = listen | set <name> | survey < name >
  *    </pre>
  *  - selftest Selftest at startup.
  *
  *  - nSurvey Number of measurements used for the site survey
  *  - noHwSurvey The standard survey method is hardware, force software survey
  *  - resetBeforeSurvey Perform gpsclock reset before starting with the
  *    site survey
  *
  *
  *
  */
  

class GpsServer : public SimpleServer  {
public: 
  GpsServer(char *inifile = "FE.ini");
  GpsServer(char *inifile, int port);
  ~GpsServer();


  bool noParameters;

  int handle_timeout();

   void setParameter();

  void requestStatus();
  
  void initGpsserver();

  void getServerVersion(int& ver,int *min_ver=NULL,int *max_ver=NULL);
  
  void setServerVersion(int ver, const char *buildnote=0);

  void oncore_requestPositionHoldMode();
 
  void oncore_enablePositionHoldMode();

  void oncore_disablePositionHoldMode();
 
  void run(int debugLevel = 0, int unit = -1, int runDaemon = 0);

  int read_from_client(int fd);

  using SimpleServer::executeCmd;
  
  void executeCmd(int client, short cmd, unsigned int *arg, short n);

  int read_from_keyboard();

//private:
public:

  int refclock_open(char *dev,  int speed,  int lflags);
  
  int refclock_ioctl(int fd, int flags);

  int refclock_close();
  
  int oncore_start();

  void oncore_sendmsg(u_char *ptr, size_t len);

  void auger_sendmsg(u_char *ptr, size_t len);


  void oncore_setTimezone(int tz);

  void oncore_getTimezone();
  
  void oncore_selftest();
 
  void oncore_getId();

  void oncore_reset();

  void auger_captureMonitor();

  void oncore_setInitialTime();

  void oncore_setInitialPosition(char *pos);

        
//protected:
public:

static u_char oncore_cmd_Ad[];
static u_char oncore_cmd_Ae[];
static u_char oncore_cmd_Af[];
static u_char oncore_cmd_Ga[];

static u_char oncore_cmd_At0[];  /* Posn Hold off */
static u_char oncore_cmd_At1[];  /* Posn Hold on  */
static u_char oncore_cmd_At2[];  /* Start Site Survey */
static u_char oncore_cmd_At[];  /* Request Site Survey state */

static u_char oncore_cmd_As[];
static u_char oncore_cmd_Asx[];
static u_char oncore_cmd_Au[];

static u_char oncore_cmd_Av0[];
static u_char oncore_cmd_Av1[];

static u_char oncore_cmd_Gd0[];  /* 3D */
static u_char oncore_cmd_Gd1[];  /* 0D */
static u_char oncore_cmd_Gd2[];  /* 2D */

static u_char oncore_cmd_Aw[];  // Request time mode
static u_char oncore_cmd_Aw0[];  // Set to GPS
static u_char oncore_cmd_Aw1[];  // Set to UTC

static u_char oncore_cmd_Aa[];  // Request initial time

static u_char oncore_cmd_Aa0[];  // Set initial time

static u_char oncore_cmd_Ab[];  // Request time zone

static u_char oncore_cmd_Ab0[];  // Set time zone UTC

static u_char oncore_cmd_Ab_set[];  // Set time zone

static u_char oncore_cmd_Ac[];  // Set initial date
                                      

static u_char oncore_cmd_Be[];
static u_char oncore_cmd_Be0[]; // oupt response message once (polled)

static u_char oncore_cmd_Ay[];
static u_char oncore_cmd_Ayx[];

static u_char oncore_cmd_Az[];
static u_char oncore_cmd_Azx[];

static u_char oncore_cmd_AB[];

static u_char oncore_cmd_Bb[];

static u_char oncore_cmd_Bj[];
static u_char oncore_cmd_Gj[];

static u_char oncore_cmd_Cf[];

static u_char oncore_cmd_Cg[];

static u_char oncore_cmd_Cj[];

static u_char oncore_cmd_Ea[];
static u_char oncore_cmd_Ba[];
static u_char oncore_cmd_Ha[];
static u_char oncore_cmd_Ea0[];
static u_char oncore_cmd_Ea1[];
static u_char oncore_cmd_Ba0[];

static u_char oncore_cmd_Ek[];  /* just turn off */

static u_char oncore_cmd_En[];
static u_char oncore_cmd_En0[];
static u_char oncore_cmd_EnDef[];
static u_char oncore_cmd_Bn[];
static u_char oncore_cmd_Bn0[];

static u_char oncore_cmd_Ca[];  /*  6 Chan */
static u_char oncore_cmd_Fa[];  /*  8 Chan */
static u_char oncore_cmd_Ia[];  /* 12 Chan */


// UTC offset status message
static u_char oncore_cmd_Bo0[]; // output UTC offset once (polled)
static u_char oncore_cmd_Bo1[]; // output UTC offset every time it is updated


// Auger specific functions

static u_char auger_cmd_gen_parameter[]; // Set begin/end of trigger time window

static u_char auger_cmd_gen_read[];

static u_char auger_cmd_A[]; // Request time window control register

static u_char auger_cmd_S[]; //
static u_char auger_cmd_S400[]; // version 4.0


static u_char auger_cmd_B[]; // Set begin of comm. time window

static u_char auger_cmd_E[]; // Set end of comm. time window


static u_char auger_cmd_F[];    // Enable sending timing information

static u_char auger_cmd_D[];   //  Disable sending timing information


static u_char auger_cmd_T[]; // Set second counter

static u_char auger_cmd_G[]; // Request second counter


static u_char auger_cmd_I[]; // Set software inhibit
static u_char auger_cmd_R[]; // Release software inhibit


static u_char auger_cmd_C[]; // Get next captured time stamp
static u_char auger_cmd_N[];  // Get number of captured pulses


static u_char auger_cmd_P[];  // Set frequency of internal generators ???

//private:
public:



static struct msg_desc oncore_messages[];
static struct msg_desc auger_messages[];


static struct cmd_desc cmd_list[];

  int getNCmds();

private:

  void receiveMessages();


  void oncore_receive(
              //struct recvbuf *rbufp
              char *buf,
              int len
       );

  void oncore_consume(
              //struct instance *instance
      );


  void oncore_update_state();     
      
  void oncore_msg_any(
               // struct instance *instance,
               u_char *buf,
              size_t len,
              int idx
          );

  void auger_msg_any(
               // struct instance *instance,
               u_char *buf,
              size_t len,
              int idx
          );



public:

  void display(FILE *fout, char *line, int helpLevel);

  //void displayMsg(unsigned char *buf, int len);
  

  void oncore_msg_Cb(
         //struct instance *instance,
         u_char *buf,
         size_t len
        );


  void oncore_msg_Cj(
               //struct instance *instance,
               u_char *buf,
               size_t len
          );

  void oncore_msg_Cj_id(
               //struct instance *instance,
               u_char *buf,
               size_t len
          );

  void oncore_msg_Cj_init(
              //struct instance *instance,
              u_char *buf,
              size_t len
          );


  void oncore_msg_Cf(
              //struct instance *instance,
              u_char *buf,
              size_t len
         );



  void oncore_msg_CaFaIa(
                //struct instance *instance,
                u_char *buf,
                size_t len
         );


  void oncore_msg_BaEaHa(
                //struct instance *instance,
                u_char *buf,
                size_t len
        );


  void oncore_msg_BnEn(
                //struct instance *instance,
                u_char *buf,
                size_t len
        );


  void oncore_get_timestamp(
               //struct instance *instance,
               long dt1,  /* tick offset THIS time step */
               long dt2  /* tick offset NEXT time step */
       );


  void oncore_msg_At(
               //struct instance *instance,
               u_char *buf,
               size_t len
         );


  void oncore_msg_Bj(
               //struct instance *instance,
               u_char *buf,
               size_t len
         );


   void oncore_msg_Gj(
               //struct instance *instance,
               u_char *buf,
               size_t len
         );


  void oncore_msg_As(
               //struct instance *instance,
               u_char *buf,
               size_t len
           );


   void oncore_print_As(
               //struct instance *instance
          );


  void oncore_msg_Aa(
               //struct instance *instance,
               u_char *buf,
               size_t len
           );

  void oncore_msg_Ad(
               //struct instance *instance,
               u_char *buf,
               size_t len
           );

  void oncore_msg_Ae(
               //struct instance *instance,
               u_char *buf,
               size_t len
           );

  void oncore_msg_Af(
               //struct instance *instance,
               u_char *buf,
               size_t len
           );
           

  void oncore_msg_Ay(
               //struct instance *instance,
               u_char *buf,
               size_t len
        );



  void oncore_msg_Az(
               // struct instance *instance,
               u_char *buf,
               size_t len
       );


  void oncore_msg_Sz(
               //struct instance *instance,
               u_char *buf,
               size_t len
      );

  bool auger_msg_checkFormat(u_char **buf, size_t *len, char cmd, int reorder=1);


  void auger_msg_A(u_char *buf, size_t);

  void auger_msg_C(u_char *buf, size_t);


  void auger_msg_F(u_char *buf, size_t);

  void auger_msg_G(u_char *buf, size_t);

  void auger_msg_N(u_char *buf, size_t);

  void auger_msg_gen_read(u_char *buf, size_t);

  void displayBuffer();


  void oncore_msg_Bo(u_char *buf, size_t);
  void oncore_msg_Ab(u_char *buf, size_t);
  void oncore_msg_Aw(u_char *buf, size_t);

  void oncore_msg_Ch(u_char *buf, size_t);
  

  void auger_set_time(unsigned int sec);

  void auger_set_time();

  void auger_set_com_start(int milisec);

  void auger_set_com_end(int milisec);

  void auger_set_com_window(int tStart, int tEnd);

  void auger_set_control(int status);

  void auger_set_control(int resetCapture, int lidarFreq,
                         int genMode1, int genMode2, int genMode3, int genMode4,
                         int inMode1, int inMode2, int inMode3, int inMode4,
                         int genStat1, int genStat2, int genStat3, int genStat4, 
                         int inStat1, int inStat2, int inStat3, int inStat4);


  void auger_reset_capture_ram();

  void auger_set_lidar_freq(int freq);

  void auger_set_generator_mode(int no, int mode, int stat);

  void auger_set_input_mode(int no, int mode, int stat=-1);

  void auger_set_generator_parameter(int no, unsigned int startSec, int startSubSec,
                 int stopSubSec, int period, int period2, int n);

  void auger_set_generator_parameter(int no, unsigned int startSec, int startSubSec,
                 int stopSubSec, int period, int period2, int n, int mode, int stat);


  void changeReceiveState(enum receive_state state);

  void changeSiteSurveyState(enum site_survey_state state);

  void oncore_sendAlmanac(char *file = 0);

    
  
//private:



  //fd_set activefds;
  //int maxactivefd;

  int  rcvptr;
  u_char  rcvbuf[500];

  int pps_assert;
  int pps_hardpps;


  int satsTracked; //< Number of tracked satelites

  // --- All variables from struct instance ---
  std::string device;
  int  unit;    
  std::string host; //< Hostname where the master gpsserver is running
  struct  refclockproc *pp;
  struct  peer *peer;

  int  ttyfd;    
  int  ppsfd;    
  SimpleSocket *master; 
  int useSocket;
  int masterfd;  
  struct termios oncoreTio;

  struct termios bufferedTio;
    
      
  int  statusfd;  
#ifdef HAVE_PPSAPI
  pps_handle_t pps_h;
  pps_params_t pps_p;
#endif
  enum receive_state o_state;    
  enum posn_mode mode;      
  enum site_survey_state site_survey;  
  int  Bj_day;

  u_long  delay;    
  long  offset;   
  u_char  *shmem;
  char  *shmem_fname;
  u_int  shmem_Cb;
  u_int  shmem_Ba;
  u_int  shmem_Ea;
  u_int  shmem_Ha;
  u_char  shmem_first;
  u_char  shmem_reset;
  u_char  shmem_Posn;

  double  ss_lat;   //< site survey variable
  double  ss_long;  //< site survey variable
  double  ss_ht;    //< site survey variable
  double  dH;
  int  ss_count;     //< actual number of positions added for site survey
  u_char  posn_set;
  int ss_mode_active; //< Flag to show automatic survey mode
  int ss_reset;       //< Do a reset before starting site survey?!
  int ss_disable_hw;  //< Do not use hardware survey - force software survey

  int receivedAlmanac; // Indicate that the almanac has been received


  enum oncore_model model;
  u_int  version;
  u_int  revision;

  u_char  chan;    
  s_char  traim;    
  u_char  traim_delay;  
  struct  RSM rsm;  
  u_char  printed;
  u_char  polled;
  int  pollcnt;
  u_int  ev_serial;
  int  Rcvptr;
  u_char  Rcvbuf[500];
  u_char  Ea[160];  
  u_char  LastEa[160];
  u_char  En[70];   
  u_char  Cj[300];
  u_char  As;
  u_char  Ay;
  u_char  Az;
  u_char  have_dH;
  u_char  init_type;
  s_char  saw_tooth;
  u_int  timeout;  
  u_char  count;    
  s_char  assert;
  u_int  saw_At;
  // --- end of struct instance ----


  enum startupModeType {
    LISTEN,
    SET,
    SURVEY,
    RESET
  };  

  enum startupModeType startupMode;

  
  unsigned int oncoreUtcSecond;
  unsigned int oncoreUtcSecTmp;
  unsigned int oncoreGpsSecond; // GPS second counter from oncore
  int oncoreDiff;
  unsigned int oncoreError;
  unsigned int augerSecond;
  int augerDiff;  
  int leapSecs; // Difference between UTC and GPS time [s]
  int newLeapSecs; // ???
  int timeMode; // 0 GPS/UT1, 1 UTC
  int timeZone; // [min] Time zone of the time in the messages

  int setAugerCounter; // Flag enbaled when setting is required
  int checkAugerCounter; // Flag to check the auger counter for a while
  int nChecks;  // Number of checks
  int nFailed;  // Number of failed checks

  int debug;
  int debugStored;
  
  
  
  int displayChar;

  struct secTiming tBuffer[T_BUFFER_LEN];
  int ptrTBuffer;

  struct captureTimeStamp tCapture[2][T_CAPTURE_LEN];
  int ptrTCapture[2];

  int useCaptureProxy;

  std::string captureProxyPort;

  std::string captureProxyFormat;
  
  int captureProxyEdge;  
 
  int fdCaptureProxy;

  int displayCaptureMonitor;

  int displayCaptureMonitorStored;

  double captureDelay;

  int adjustSecCounter;            //< Adjust the second counter (0 false, 1 once, 2 if necessary)
  int adjustActive;               //< Adjustment in progress
  int nErrorSecCounter;           //< NUmber of errors in the second counter

  unsigned int augerStatus;      //< Status register of the auger part

  int lidarStartup;               //< Set default lidar frequency at startup of gpsserver (0 no, 1 set)
  int lidarSetFreq;               //< Flag to indicate that the frequency should be set once
  int lidarDefaultFreq;           //< Lidar default frequency set at startup
  int lidarTriggerFreq;           //< Frequency of the LIDAR clock (0, 20, 334, 1000Hz)
  static int lidarModeFreq[];     //< Lidar frequencies
  
  int capturedN;        //< Number of captured time stamps to readout
  unsigned char capturedLeft;     //< Left capture timestamps
  
  bool cmdASend;
  
  int cmdAReceived;              
  
  int lastEdge[2];                  //< Last edge of capture inputs

  int genMode[4];                 //< Generator mode (0 veto, 1 external trigger)
  int genStat[4];                 //< Generator state (0 stopped, 1 active)
  unsigned int genStartSec[4];   //< Generator start second [s]
  int genStartSubSec[4];          //< Generator start subsecond [us]
  int genEndSubSec[4];            //< Generator start subsecond [us]
  int genPeriod[4];               //< Generator periond length [s]
  int genPeriod2[4];              //< Generator periond length [min]
  int genN[4];                    //< Number of pulses

  int inMode[4];                  //< Input mode (0 veto, 1 external trigger)
  int inStat[4];                  //< Input enabled (0 off, 1 on (default))

  bool isInhibit;                 //< Is inhibit of the timing unit active?


  int augerVersion;                    //< Version of the auger FPGA design (*100)

  int serverVersion;           //< Number of the gpsserver (has to be set by calling program)
  std::string serverBuildnote;      //< Build information



  // (G)UI parameter
  int num; //< Numerical input
  int sign; //< Sign of the numerical input


  int nLogInterval; //< Interval of the loging output
  int nLogIntervalStored;
  int nShowData; //< Show n lines of log data
  bool showHeader; //< Display header for the log messages

  int tPCLastMessage; //< PC time of the last F-messages
  unsigned int nSecMessages; //< Number of messages in a second interval

  int pos_id;        //< Id of the location (1 .. 4 eye stations!)
  std::string pos_name;   //< Name of the location
  int pos_lat;  //< Latitude in GPS Clock format
  int pos_long; //< Longitude in GPS Clock format
  int pos_ht;   //< Heigth in GPS Clock format
  int ss_pos_average; //< Number of samples required for site survey?!


  int maxStartupRetries; //< Number of retries to open the gpsclock interface

  struct posData posDatabase[POS_DATABASE_LEN]; //< Postition data base
  int posDatabaseEntries; //< Number of entries found in the database
  int posRadius;     //< Size of the position?!

  int selftest;       //< Flag to perform or omit a selftest

  std::string initial_pos;
  
  GpsClock gpsclock; //< Gps clock routines


  int oncore_positionMode; //< Position mode (from At message)

  
  
  int findCoordinates(char *name, double *latitude, double *longitude, double *height);

  int findPositionName(int *id, std::string *name, double latitude, double longitude, double height);

  int findPositionName(int *id, char *name, double latitude, double longitude, double height);


  int findPositionId(int *id, char *name);

  int findPositionName(int id, std::string *name);
  
  std::string inifile; //< Keep the inifile to be able to add the results from the site survey


  fd_set raw_data_fd_set;
  
  
  std::string line;

  shell *sh;

  cmds *instrSet[1];
  
  u_char almanac[34][28];
  
  int nAlmanacRead;
  
  int nAlmanacWrite;

  // === Internal communications ===

  unsigned int tPC_Ea;
  
  enum cmd {
    OnCj, // receiver id
    OnFa, // selftest
    OnCf, // reset
    OnAt, // position mode
  };

  enum test {
    TestConnection,
    TestReceiver,
    TestInitialization,
    InitSetPosition,
    InitListen,
    GPSTEST_NUM  // Must be the last entry to get the number of tests
  };  

  enum EGpsLoggingMode {
    kLogNone = 0,             // none at all
    kLogConnection = 0x01,    // each connect/disconnect
    kLogGenerator = 0x02,     // 'gpsset gen ...' commands
    kLogInput = 0x04,         // 'gpsset input' and 'gpsset lidar' commands
    kLogInhibit = 0x08,       // 'gpsset inhibit' and 'gpsset relinhibit' cmds
    kLogSeconds = 0x10,       //
  };
  
  int gpsLoggingMode;
  
  int cmdPending[GPSCMD_MAX];  

  
  unsigned short receiverStatus;

  
  int testPhase[GPSTEST_MAX];

  unsigned int testStart[GPSTEST_MAX];
  

  // === Test functions ===
  void startTest(enum test);

  void testStatus();

  void testHandler();
  
  void displayTestHeader(FILE *fout, char *name);

  FILE *ftest;
    
  void testConnection();

  
  void testReceiver();

  
   void testInitialization();


   void initSetPosition();

   void initListen();
      

   void oncore_setPosition(char *pos_name);        
    
};

#endif