How to build new PARSE clocks

The struct clockformat is the interface to the rest of the parse driver - it holds all information necessary for finding the clock message and doing the appropriate time stamping.

struct clockformat
        {
          u_long (*input)();
          /* input routine - your routine - cvt_ */
          u_long (*convert)();
          /* conversion routine - your routine - cvt_ */
          /* routine for handling RS232 sync events (time stamps) - usually sync_simple */
          u_long (*syncpps)(); 
          /* PPS input routine - usually pps_one */
          void           *data;
          /* local parameters - any parameters/data/configuration info your conversion
             routine might need */
          char           *name;
          /* clock format name - Name of the time code */
          unsigned short  length;
          /* maximum length of data packet for your clock format */
          u_long   flags;
         /* information for the parser what to look for */
        };

The above should have given you some hints on how to build a clk_*.c file with the time code conversion. See the examples and pick a clock closest to yours and tweak the code to match your clock.

In order to make your clk_*.c file usable a reference to the clockformat structure must be put into parse_conf.c.

2. TTY setup and initialisation/configuration will be done in ntpd/refclock_parse.c.

   Find out the exact tty settings for your clock (baud rate, parity, stop bits, character size, …) and note them in terms of termio*.h c_cflag macros.

   In ntpd/refclock_parse.c fill out a new the struct clockinfo element (that allocates a new “IP” address - see comments) (see all the other clocks for example).

   struct clockinfo
             {
              u_long  cl_flags;             /* operation flags (io modes) */
        	 PARSE_F_PPSPPS       use loopfilter PPS code (CIOGETEV)
        	 PARSE_F_PPSONSECOND  PPS pulses are on second
        	 usually flags stay 0 as they are used only for special setups

            void  (*cl_poll)();           /* active poll routine */
                 The routine to call when the clock needs data sent to it in order to
                 get a time code from the clock (e.g. Trimble clock)

            int   (*cl_init)();           /* active poll init routine */
                 The routine to call for very special initializations.

            void  (*cl_event)();          /* special event handling (e.g. reset clock) */
                 What to do, when an event happens - used to re-initialize clocks on timeout.

            void  (*cl_end)();            /* active poll end routine */
                 The routine to call to undo any special initialisation (free memory/timers)

            void   *cl_data;              /* local data area for "poll" mechanism */
                 local data for polling routines

            u_fp    cl_rootdelay;         /* rootdelay */
                 NTP rootdelay estimate (usually 0)

        	     u_long  cl_basedelay;         /* current offset - unsigned l_fp
                                                      fractional part (fraction) by
                                                      which the RS232 time code is
                                                      delayed from the actual time. */

            u_long  cl_ppsdelay;          /* current PPS offset - unsigned l_fp fractional
                 time (fraction) by which the PPS time stamp is delayed (usually 0)
           part */

            char   *cl_id;                /* ID code (usually "DCF") */
                 Refclock id - (max 4 chars)

            char   *cl_description;       /* device name */
                 Name of this device.

            char   *cl_format;            /* fixed format */
                 If the data format cann not ne detected automatically this is the name
        	 as in clk_*.c clockformat.

            u_char  cl_type;              /* clock type (ntp control) */
                 Type if clock as in clock status word (ntp control messages) - usually 0

            u_long  cl_maxunsync;         /* time to trust oscillator after losing synch
          */
                 seconds a clock can be trusted after losing synchronisation.

            u_long  cl_speed;             /* terminal input & output baudrate */
            u_long  cl_cflag;             /* terminal io flags */
            u_long  cl_iflag;             /* terminal io flags */
            u_long  cl_oflag;             /* terminal io flags */
            u_long  cl_lflag;             /* terminal io flags */
                 termio*.h tty modes.

            u_long  cl_samples;           /* samples for median filter */
            u_long  cl_keep;              /* samples for median filter to keep */
                 median filter parameters - smoothing and rejection of bad samples
          } clockinfo[] = {
          ...,,...
          { < your parameters> },
          };

Well, this is very sketchy, I know. But I hope it helps a little bit. The best way is to look which clock comes closest to your and tweak that code.

Two sorts of clocks are used with parse. Clocks that automatically send their time code (once a second) do not need entries in the poll routines because they send the data all the time. The second sort are the clocks that need a command sent to them in order to reply with a time code (like the Trimble clock).

For questions: kardel@acm.org.

Please include an exact description on how your clock works. (initialisation, TTY modes, strings to be sent to it, responses received from the clock).