![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_jjy.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd|
Return to refclock_jjy.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd |
1.1 misho 1: /*
2: * refclock_jjy - clock driver for JJY receivers
3: */
4:
5: /**********************************************************************/
6: /* */
7: /* Copyright (C) 2001-2004, Takao Abe. All rights reserved. */
8: /* */
9: /* Permission to use, copy, modify, and distribute this software */
10: /* and its documentation for any purpose is hereby granted */
11: /* without fee, provided that the following conditions are met: */
12: /* */
13: /* One retains the entire copyright notice properly, and both the */
14: /* copyright notice and this license. in the documentation and/or */
15: /* other materials provided with the distribution. */
16: /* */
17: /* This software and the name of the author must not be used to */
18: /* endorse or promote products derived from this software without */
19: /* prior written permission. */
20: /* */
21: /* THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESSED OR IMPLIED */
22: /* WARRANTIES OF ANY KIND, INCLUDING, BUT NOT LIMITED TO, THE */
23: /* IMPLIED WARRANTIES OF MERCHANTABLILITY AND FITNESS FOR A */
24: /* PARTICULAR PURPOSE. */
25: /* IN NO EVENT SHALL THE AUTHOR TAKAO ABE BE LIABLE FOR ANY DIRECT, */
26: /* INDIRECT, GENERAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES */
27: /* ( INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE */
28: /* GOODS OR SERVICES; LOSS OF USE, DATA OR PROFITS; OR BUSINESS */
29: /* INTERRUPTION ) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, */
30: /* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ( INCLUDING */
31: /* NEGLIGENCE OR OTHERWISE ) ARISING IN ANY WAY OUT OF THE USE OF */
32: /* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
33: /* */
34: /* This driver is developed in my private time, and is opened as */
35: /* voluntary contributions for the NTP. */
36: /* The manufacturer of the JJY receiver has not participated in */
37: /* a development of this driver. */
38: /* The manufacturer does not warrant anything about this driver, */
39: /* and is not liable for anything about this driver. */
40: /* */
41: /**********************************************************************/
42: /* */
43: /* Author Takao Abe */
44: /* Email takao_abe@xurb.jp */
45: /* Homepage http://www.bea.hi-ho.ne.jp/abetakao/ */
46: /* */
47: /* The email address abetakao@bea.hi-ho.ne.jp is never read */
48: /* from 2010, because a few filtering rule are provided by the */
49: /* "hi-ho.ne.jp", and lots of spam mail are reached. */
50: /* New email address for supporting the refclock_jjy is */
51: /* takao_abe@xurb.jp */
52: /* */
53: /**********************************************************************/
54: /* */
55: /* History */
56: /* */
57: /* 2001/07/15 */
58: /* [New] Support the Tristate Ltd. JJY receiver */
59: /* */
60: /* 2001/08/04 */
61: /* [Change] Log to clockstats even if bad reply */
62: /* [Fix] PRECISION = (-3) (about 100 ms) */
63: /* [Add] Support the C-DEX Co.Ltd. JJY receiver */
64: /* */
65: /* 2001/12/04 */
66: /* [Fix] C-DEX JST2000 ( fukusima@goto.info.waseda.ac.jp ) */
67: /* */
68: /* 2002/07/12 */
69: /* [Fix] Portability for FreeBSD ( patched by the user ) */
70: /* */
71: /* 2004/10/31 */
72: /* [Change] Command send timing for the Tristate Ltd. JJY receiver */
73: /* JJY-01 ( Firmware version 2.01 ) */
74: /* Thanks to Andy Taki for testing under FreeBSD */
75: /* */
76: /* 2004/11/28 */
77: /* [Add] Support the Echo Keisokuki LT-2000 receiver */
78: /* */
79: /* 2006/11/04 */
80: /* [Fix] C-DEX JST2000 */
81: /* Thanks to Hideo Kuramatsu for the patch */
82: /* */
83: /* 2009/04/05 */
84: /* [Add] Support the CITIZEN T.I.C JJY-200 receiver */
85: /* */
86: /* 2010/11/20 */
87: /* [Change] Bug 1618 ( Harmless ) */
88: /* Code clean up ( Remove unreachable codes ) in */
89: /* jjy_start() */
90: /* [Change] Change clockstats format of the Tristate JJY01/02 */
91: /* Issues more command to get the status of the receiver */
92: /* when "fudge 127.127.40.X flag1 1" is specified */
93: /* ( DATE,STIM -> DCST,STUS,DATE,STIM ) */
94: /* */
95: /**********************************************************************/
96:
97: #ifdef HAVE_CONFIG_H
98: #include <config.h>
99: #endif
100:
101: #if defined(REFCLOCK) && defined(CLOCK_JJY)
102:
103: #include <stdio.h>
104: #include <ctype.h>
105: #include <string.h>
106: #include <sys/time.h>
107: #include <time.h>
108:
109: #include "ntpd.h"
110: #include "ntp_io.h"
111: #include "ntp_tty.h"
112: #include "ntp_refclock.h"
113: #include "ntp_calendar.h"
114: #include "ntp_stdlib.h"
115:
116: /**********************************************************************/
117: /* */
118: /* The Tristate Ltd. JJY receiver JJY01 */
119: /* */
120: /* Command Response Remarks */
121: /* ------------ ---------------------- --------------------- */
122: /* dcst<CR><LF> VALID|INVALID<CR><LF> */
123: /* stus<CR><LF> ADJUSTED|UNADJUSTED<CR><LF> */
124: /* date<CR><LF> YYYY/MM/DD XXX<CR><LF> */
125: /* time<CR><LF> HH:MM:SS<CR><LF> */
126: /* stim<CR><LF> HH:MM:SS<CR><LF> Reply at just second */
127: /* */
128: /* During synchronization after a receiver is turned on, */
129: /* It replies the past time from 2000/01/01 00:00:00. */
130: /* The function "refclock_process" checks the time and tells */
131: /* as an insanity time. */
132: /* */
133: /**********************************************************************/
134: /* */
135: /* The C-DEX Co. Ltd. JJY receiver JST2000 */
136: /* */
137: /* Command Response Remarks */
138: /* ------------ ---------------------- --------------------- */
139: /* <ENQ>1J<ETX> <STX>JYYMMDD HHMMSSS<ETX> */
140: /* */
141: /**********************************************************************/
142: /* */
143: /* The Echo Keisokuki Co. Ltd. JJY receiver LT2000 */
144: /* */
145: /* Command Response Remarks */
146: /* ------------ ---------------------- --------------------- */
147: /* # Mode 1 (Request&Send) */
148: /* T YYMMDDWHHMMSS<BCC1><BCC2><CR> */
149: /* C Mode 2 (Continuous) */
150: /* YYMMDDWHHMMSS<ST1><ST2><ST3><ST4><CR> */
151: /* <SUB> Second signal */
152: /* */
153: /**********************************************************************/
154: /* */
155: /* The CITIZEN T.I.C CO., LTD. JJY receiver JJY200 */
156: /* */
157: /* Command Response Remarks */
158: /* ------------ ---------------------- --------------------- */
159: /* 'XX YY/MM/DD W HH:MM:SS<CR> */
160: /* XX: OK|NG|ER */
161: /* W: 0(Monday)-6(Sunday) */
162: /* */
163: /**********************************************************************/
164:
165: /*
166: * Interface definitions
167: */
168: #define DEVICE "/dev/jjy%d" /* device name and unit */
169: #define SPEED232 B9600 /* uart speed (9600 baud) */
170: #define SPEED232_TRISTATE_JJY01 B9600 /* UART speed (9600 baud) */
171: #define SPEED232_CDEX_JST2000 B9600 /* UART speed (9600 baud) */
172: #define SPEED232_ECHOKEISOKUKI_LT2000 B9600 /* UART speed (9600 baud) */
173: #define SPEED232_CITIZENTIC_JJY200 B4800 /* UART speed (4800 baud) */
174: #define REFID "JJY" /* reference ID */
175: #define DESCRIPTION "JJY Receiver"
176: #define PRECISION (-3) /* precision assumed (about 100 ms) */
177:
178: /*
179: * JJY unit control structure
180: */
181: struct jjyunit {
182: char unittype ; /* UNITTYPE_XXXXXXXXXX */
183: short operationmode ; /* Echo Keisokuki LT-2000 : 1 or 2 */
184: short version ;
185: short linediscipline ; /* LDISC_CLK or LDISC_RAW */
186: char bPollFlag ; /* Set by jjy_pool and Reset by jjy_receive */
187: int linecount ;
188: int lineerror ;
189: int year, month, day, hour, minute, second, msecond ;
190: /* LDISC_RAW only */
191: #define MAX_LINECOUNT 8
192: #define MAX_RAWBUF 64
193: int lineexpect ;
194: int charexpect [ MAX_LINECOUNT ] ;
195: int charcount ;
196: char rawbuf [ MAX_RAWBUF ] ;
197: };
198:
199: #define UNITTYPE_TRISTATE_JJY01 1
200: #define UNITTYPE_CDEX_JST2000 2
201: #define UNITTYPE_ECHOKEISOKUKI_LT2000 3
202: #define UNITTYPE_CITIZENTIC_JJY200 4
203:
204: /*
205: * Function prototypes
206: */
207: static int jjy_start (int, struct peer *);
208: static void jjy_shutdown (int, struct peer *);
209: static void jjy_poll (int, struct peer *);
210: static void jjy_poll_tristate_jjy01 (int, struct peer *);
211: static void jjy_poll_cdex_jst2000 (int, struct peer *);
212: static void jjy_poll_echokeisokuki_lt2000(int, struct peer *);
213: static void jjy_poll_citizentic_jjy200 (int, struct peer *);
214: static void jjy_receive (struct recvbuf *);
215: static int jjy_receive_tristate_jjy01 (struct recvbuf *);
216: static int jjy_receive_cdex_jst2000 (struct recvbuf *);
217: static int jjy_receive_echokeisokuki_lt2000 (struct recvbuf *);
218: static int jjy_receive_citizentic_jjy200 (struct recvbuf *);
219:
220: static void printableString ( char*, int, char*, int ) ;
221:
222: /*
223: * Transfer vector
224: */
225: struct refclock refclock_jjy = {
226: jjy_start, /* start up driver */
227: jjy_shutdown, /* shutdown driver */
228: jjy_poll, /* transmit poll message */
229: noentry, /* not used */
230: noentry, /* not used */
231: noentry, /* not used */
232: NOFLAGS /* not used */
233: };
234:
235: /*
236: * Start up driver return code
237: */
238: #define RC_START_SUCCESS 1
239: #define RC_START_ERROR 0
240:
241: /*
242: * Local constants definition
243: */
244:
245: #define MAX_LOGTEXT 64
246:
247: /*
248: * Tristate JJY01/JJY02 constants definition
249: */
250:
251: #define TS_JJY01_COMMAND_NUMBER_DATE 1
252: #define TS_JJY01_COMMAND_NUMBER_TIME 2
253: #define TS_JJY01_COMMAND_NUMBER_STIM 3
254: #define TS_JJY01_COMMAND_NUMBER_STUS 4
255: #define TS_JJY01_COMMAND_NUMBER_DCST 5
256:
257: #define TS_JJY01_REPLY_DATE "yyyy/mm/dd www\r\n"
258: #define TS_JJY01_REPLY_STIM "hh:mm:ss\r\n"
259: #define TS_JJY01_REPLY_STUS_YES "adjusted\r\n"
260: #define TS_JJY01_REPLY_STUS_NO "unadjusted\r\n"
261: #define TS_JJY01_REPLY_DCST_VALID "valid\r\n"
262: #define TS_JJY01_REPLY_DCST_INVALID "invalid\r\n"
263:
264: #define TS_JJY01_REPLY_LENGTH_DATE 14 /* Length without <CR><LF> */
265: #define TS_JJY01_REPLY_LENGTH_STIM 8 /* Length without <CR><LF> */
266: #define TS_JJY01_REPLY_LENGTH_STUS_YES 8 /* Length without <CR><LF> */
267: #define TS_JJY01_REPLY_LENGTH_STUS_NO 10 /* Length without <CR><LF> */
268: #define TS_JJY01_REPLY_LENGTH_DCST_VALID 5 /* Length without <CR><LF> */
269: #define TS_JJY01_REPLY_LENGTH_DCST_INVALID 7 /* Length without <CR><LF> */
270:
271: static struct
272: {
273: char commandNumber ;
274: char *commandLog ;
275: char *command ;
276: int commandLength ;
277: } tristate_jjy01_command_sequence[] =
278: {
279: /* dcst<CR><LF> -> VALID<CR><LF> or INVALID<CR><LF> */
280: { TS_JJY01_COMMAND_NUMBER_DCST, "dcst", "dcst\r\n", 6 },
281: /* stus<CR><LF> -> ADJUSTED<CR><LF> or UNADJUSTED<CR><LF> */
282: { TS_JJY01_COMMAND_NUMBER_STUS, "stus", "stus\r\n", 6 },
283: /* date<CR><LF> -> YYYY/MM/DD WWW<CR><LF> */
284: { TS_JJY01_COMMAND_NUMBER_DATE, "date", "date\r\n", 6 },
285: /* stim<CR><LF> -> HH:MM:SS<CR><LF> */
286: { TS_JJY01_COMMAND_NUMBER_STIM, "stim", "stim\r\n", 6 },
287: { 0 , NULL , NULL , 0 }
288: } ;
289:
290:
291: /**************************************************************************************************/
292: /* jjy_start - open the devices and initialize data for processing */
293: /**************************************************************************************************/
294: static int
295: jjy_start ( int unit, struct peer *peer )
296: {
297:
298: struct jjyunit *up ;
299: struct refclockproc *pp ;
300: int fd ;
301: char *pDeviceName ;
302: short iDiscipline ;
303: int iSpeed232 ;
304:
305: #ifdef DEBUG
306: if ( debug ) {
307: printf ( "jjy_start (refclock_jjy.c) : %s mode=%d ", ntoa(&peer->srcadr), peer->ttl ) ;
308: printf ( DEVICE, unit ) ;
309: printf ( "\n" ) ;
310: }
311: #endif
312: /*
313: * Open serial port
314: */
315: pDeviceName = emalloc ( strlen(DEVICE) + 10 );
316: snprintf ( pDeviceName, strlen(DEVICE) + 10, DEVICE, unit ) ;
317:
318: /*
319: * peer->ttl is a mode number specified by "127.127.40.X mode N" in the ntp.conf
320: */
321: switch ( peer->ttl ) {
322: case 0 :
323: case 1 :
324: iDiscipline = LDISC_CLK ;
325: iSpeed232 = SPEED232_TRISTATE_JJY01 ;
326: break ;
327: case 2 :
328: iDiscipline = LDISC_RAW ;
329: iSpeed232 = SPEED232_CDEX_JST2000 ;
330: break ;
331: case 3 :
332: iDiscipline = LDISC_CLK ;
333: iSpeed232 = SPEED232_ECHOKEISOKUKI_LT2000 ;
334: break ;
335: case 4 :
336: iDiscipline = LDISC_CLK ;
337: iSpeed232 = SPEED232_CITIZENTIC_JJY200 ;
338: break ;
339: default :
340: msyslog ( LOG_ERR, "JJY receiver [ %s mode %d ] : Unsupported mode",
341: ntoa(&peer->srcadr), peer->ttl ) ;
342: free ( (void*) pDeviceName ) ;
343: return RC_START_ERROR ;
344: }
345:
346: if ( ! ( fd = refclock_open ( pDeviceName, iSpeed232, iDiscipline ) ) ) {
347: free ( (void*) pDeviceName ) ;
348: return RC_START_ERROR ;
349: }
350: free ( (void*) pDeviceName ) ;
351:
352: /*
353: * Allocate and initialize unit structure
354: */
355: up = emalloc (sizeof(*up));
356: memset ( up, 0, sizeof(*up) ) ;
357: up->linediscipline = iDiscipline ;
358:
359: /*
360: * peer->ttl is a mode number specified by "127.127.40.X mode N" in the ntp.conf
361: */
362: switch ( peer->ttl ) {
363: case 0 :
364: /*
365: * The mode 0 is a default clock type at this time.
366: * But this will be change to auto-detect mode in the future.
367: */
368: case 1 :
369: up->unittype = UNITTYPE_TRISTATE_JJY01 ;
370: up->version = 100 ;
371: /* 2010/11/20 */
372: /* Command sequence is defined by the struct tristate_jjy01_command_sequence, */
373: /* and the following 3 lines are not used in the mode LDISC_CLK. */
374: /* up->lineexpect = 2 ; */
375: /* up->charexpect[0] = 14 ; */ /* YYYY/MM/DD WWW<CR><LF> */
376: /* up->charexpect[1] = 8 ; */ /* HH:MM:SS<CR><LF> */
377: break ;
378: case 2 :
379: up->unittype = UNITTYPE_CDEX_JST2000 ;
380: up->lineexpect = 1 ;
381: up->charexpect[0] = 15 ; /* <STX>JYYMMDD HHMMSSS<ETX> */
382: break ;
383: case 3 :
384: up->unittype = UNITTYPE_ECHOKEISOKUKI_LT2000 ;
385: up->operationmode = 2 ; /* Mode 2 : Continuous mode */
386: up->lineexpect = 1 ;
387: switch ( up->operationmode ) {
388: case 1 :
389: up->charexpect[0] = 15 ; /* YYMMDDWHHMMSS<BCC1><BCC2><CR> */
390: break ;
391: case 2 :
392: up->charexpect[0] = 17 ; /* YYMMDDWHHMMSS<ST1><ST2><ST3><ST4><CR> */
393: break ;
394: }
395: break ;
396: case 4 :
397: up->unittype = UNITTYPE_CITIZENTIC_JJY200 ;
398: up->lineexpect = 1 ;
399: up->charexpect[0] = 23 ; /* 'XX YY/MM/DD W HH:MM:SS<CR> */
400: break ;
401:
402: /* 2010/11/20 */
403: /* The "default:" section of this switch block is never executed, */
404: /* because the former switch block traps the same "default:" case. */
405: /* This "default:" section codes are removed to avoid spending time */
406: /* in the future looking, though the codes are functionally harmless. */
407:
408: }
409:
410: pp = peer->procptr ;
411: pp->unitptr = (caddr_t) up ;
412: pp->io.clock_recv = jjy_receive ;
413: pp->io.srcclock = (caddr_t) peer ;
414: pp->io.datalen = 0 ;
415: pp->io.fd = fd ;
416: if ( ! io_addclock(&pp->io) ) {
417: close ( fd ) ;
418: pp->io.fd = -1 ;
419: free ( up ) ;
420: pp->unitptr = NULL ;
421: return RC_START_ERROR ;
422: }
423:
424: /*
425: * Initialize miscellaneous variables
426: */
427: peer->precision = PRECISION ;
428: peer->burst = 1 ;
429: pp->clockdesc = DESCRIPTION ;
430: memcpy ( (char*)&pp->refid, REFID, strlen(REFID) ) ;
431:
432: return RC_START_SUCCESS ;
433:
434: }
435:
436:
437: /**************************************************************************************************/
438: /* jjy_shutdown - shutdown the clock */
439: /**************************************************************************************************/
440: static void
441: jjy_shutdown ( int unit, struct peer *peer )
442: {
443:
444: struct jjyunit *up;
445: struct refclockproc *pp;
446:
447: pp = peer->procptr ;
448: up = (struct jjyunit *) pp->unitptr ;
449: if ( -1 != pp->io.fd )
450: io_closeclock ( &pp->io ) ;
451: if ( NULL != up )
452: free ( up ) ;
453:
454: }
455:
456:
457: /**************************************************************************************************/
458: /* jjy_receive - receive data from the serial interface */
459: /**************************************************************************************************/
460: static void
461: jjy_receive ( struct recvbuf *rbufp )
462: {
463:
464: struct jjyunit *up ;
465: struct refclockproc *pp ;
466: struct peer *peer;
467:
468: l_fp tRecvTimestamp; /* arrival timestamp */
469: int rc ;
470: char sLogText [ MAX_LOGTEXT ] ;
471: int i, bCntrlChar ;
472:
473: /*
474: * Initialize pointers and read the timecode and timestamp
475: */
476: peer = (struct peer *) rbufp->recv_srcclock ;
477: pp = peer->procptr ;
478: up = (struct jjyunit *) pp->unitptr ;
479:
480: /*
481: * Get next input line
482: */
483: pp->lencode = refclock_gtlin ( rbufp, pp->a_lastcode, BMAX, &tRecvTimestamp ) ;
484:
485: if ( up->linediscipline == LDISC_RAW ) {
486: /*
487: * The reply with <STX> and <ETX> may give a blank line
488: */
489: if ( pp->lencode == 0 && up->charcount == 0 ) return ;
490: /*
491: * Copy received charaters to temporary buffer
492: */
493: for ( i = 0 ;
494: i < pp->lencode && up->charcount < MAX_RAWBUF - 2 ;
495: i ++ , up->charcount ++ ) {
496: up->rawbuf[up->charcount] = pp->a_lastcode[i] ;
497: }
498: while ( up->charcount > 0 && up->rawbuf[0] < ' ' ) {
499: for ( i = 0 ; i < up->charcount - 1 ; i ++ )
500: up->rawbuf[i] = up->rawbuf[i+1] ;
501: up->charcount -- ;
502: }
503: bCntrlChar = 0 ;
504: for ( i = 0 ; i < up->charcount ; i ++ ) {
505: if ( up->rawbuf[i] < ' ' ) {
506: bCntrlChar = 1 ;
507: break ;
508: }
509: }
510: if ( pp->lencode > 0 && up->linecount < up->lineexpect ) {
511: if ( bCntrlChar == 0 &&
512: up->charcount < up->charexpect[up->linecount] )
513: return ;
514: }
515: up->rawbuf[up->charcount] = 0 ;
516: } else {
517: /*
518: * The reply with <CR><LF> gives a blank line
519: */
520: if ( pp->lencode == 0 ) return ;
521: }
522: /*
523: * We get down to business
524: */
525:
526: pp->lastrec = tRecvTimestamp ;
527:
528: up->linecount ++ ;
529:
530: if ( up->lineerror != 0 ) return ;
531:
532: switch ( up->unittype ) {
533:
534: case UNITTYPE_TRISTATE_JJY01 :
535: rc = jjy_receive_tristate_jjy01 ( rbufp ) ;
536: break ;
537:
538: case UNITTYPE_CDEX_JST2000 :
539: rc = jjy_receive_cdex_jst2000 ( rbufp ) ;
540: break ;
541:
542: case UNITTYPE_ECHOKEISOKUKI_LT2000 :
543: rc = jjy_receive_echokeisokuki_lt2000 ( rbufp ) ;
544: break ;
545:
546: case UNITTYPE_CITIZENTIC_JJY200 :
547: rc = jjy_receive_citizentic_jjy200 ( rbufp ) ;
548: break ;
549:
550: default :
551: rc = 0 ;
552: break ;
553:
554: }
555:
556: if ( up->linediscipline == LDISC_RAW ) {
557: if ( up->linecount <= up->lineexpect &&
558: up->charcount > up->charexpect[up->linecount-1] ) {
559: for ( i = 0 ;
560: i < up->charcount - up->charexpect[up->linecount-1] ;
561: i ++ ) {
562: up->rawbuf[i] = up->rawbuf[i+up->charexpect[up->linecount-1]] ;
563: }
564: up->charcount -= up->charexpect[up->linecount-1] ;
565: } else {
566: up->charcount = 0 ;
567: }
568: }
569:
570: if ( rc == 0 )
571: return ;
572:
573: up->bPollFlag = 0 ;
574:
575: if ( up->lineerror != 0 ) {
576: refclock_report ( peer, CEVNT_BADREPLY ) ;
577: strncpy ( sLogText, "BAD REPLY [",
578: sizeof( sLogText ) ) ;
579: if ( up->linediscipline == LDISC_RAW ) {
580: strncat ( sLogText, up->rawbuf,
581: sizeof( sLogText ) -
582: strlen ( sLogText ) - 1 ) ;
583: } else {
584: strncat ( sLogText, pp->a_lastcode,
585: sizeof( sLogText ) -
586: strlen ( sLogText ) - 1 ) ;
587: }
588: sLogText[MAX_LOGTEXT-1] = 0 ;
589: if ( strlen ( sLogText ) < MAX_LOGTEXT - 2 )
590: strncat ( sLogText, "]",
591: sizeof( sLogText ) -
592: strlen ( sLogText ) - 1 ) ;
593: record_clock_stats ( &peer->srcadr, sLogText ) ;
594: return ;
595: }
596:
597: pp->year = up->year ;
598: pp->day = ymd2yd ( up->year, up->month, up->day ) ;
599: pp->hour = up->hour ;
600: pp->minute = up->minute ;
601: pp->second = up->second ;
602: pp->nsec = up->msecond * 1000000;
603:
604: /*
605: * JST to UTC
606: */
607: pp->hour -= 9 ;
608: if ( pp->hour < 0 ) {
609: pp->hour += 24 ;
610: pp->day -- ;
611: if ( pp->day < 1 ) {
612: pp->year -- ;
613: pp->day = ymd2yd ( pp->year, 12, 31 ) ;
614: }
615: }
616: #ifdef DEBUG
617: if ( debug ) {
618: printf ( "jjy_receive (refclock_jjy.c) : %04d/%02d/%02d %02d:%02d:%02d.%1d JST ",
619: up->year, up->month, up->day, up->hour,
620: up->minute, up->second, up->msecond/100 ) ;
621: printf ( "( %04d/%03d %02d:%02d:%02d.%1d UTC )\n",
622: pp->year, pp->day, pp->hour, pp->minute,
623: pp->second, (int)(pp->nsec/100000000) ) ;
624: }
625: #endif
626:
627: /*
628: * Process the new sample in the median filter and determine the
629: * timecode timestamp.
630: */
631:
632: snprintf ( sLogText, sizeof(sLogText),
633: "%04d/%02d/%02d %02d:%02d:%02d.%1d JST",
634: up->year, up->month, up->day,
635: up->hour, up->minute, up->second, up->msecond/100 ) ;
636: record_clock_stats ( &peer->srcadr, sLogText ) ;
637:
638: if ( ! refclock_process ( pp ) ) {
639: refclock_report(peer, CEVNT_BADTIME);
640: return ;
641: }
642:
643: pp->lastref = pp->lastrec;
644: refclock_receive(peer);
645:
646: }
647:
648: /**************************************************************************************************/
649:
650: static int
651: jjy_receive_tristate_jjy01 ( struct recvbuf *rbufp )
652: {
653:
654: static char *sFunctionName = "jjy_receive_tristate_jjy01" ;
655:
656: struct jjyunit *up ;
657: struct refclockproc *pp ;
658: struct peer *peer;
659:
660: char *pBuf ;
661: int iLen ;
662: int rc ;
663:
664: int bOverMidnight = 0 ;
665:
666: char sLogText [ MAX_LOGTEXT ], sReplyText [ MAX_LOGTEXT ] ;
667:
668: char *pCmd ;
669: int iCmdLen ;
670:
671: /*
672: * Initialize pointers and read the timecode and timestamp
673: */
674: peer = (struct peer *) rbufp->recv_srcclock ;
675: pp = peer->procptr ;
676: up = (struct jjyunit *) pp->unitptr ;
677:
678: if ( up->linediscipline == LDISC_RAW ) {
679: pBuf = up->rawbuf ;
680: iLen = up->charcount ;
681: } else {
682: pBuf = pp->a_lastcode ;
683: iLen = pp->lencode ;
684: }
685:
686: switch ( tristate_jjy01_command_sequence[up->linecount-1].commandNumber ) {
687:
688: case TS_JJY01_COMMAND_NUMBER_DATE : /* YYYY/MM/DD WWW */
689:
690: if ( iLen != TS_JJY01_REPLY_LENGTH_DATE ) {
691: up->lineerror = 1 ;
692: break ;
693: }
694:
695: rc = sscanf ( pBuf, "%4d/%2d/%2d", &up->year,
696: &up->month, &up->day ) ;
697: if ( rc != 3 || up->year < 2000 || up->month < 1 ||
698: up->month > 12 || up->day < 1 || up->day > 31 ) {
699: up->lineerror = 1 ;
700: break ;
701: }
702:
703: /*** Start of modification on 2004/10/31 ***/
704: /*
705: * Following codes are moved from the function jjy_poll_tristate_jjy01 in this source.
706: * The Tristate JJY-01 ( Firmware version 1.01 ) accepts "time" and "stim" commands without any delay.
707: * But the JJY-01 ( Firmware version 2.01 ) does not accept these commands continuously,
708: * so this driver issues the second command "stim" after the reply of the first command "date".
709: */
710:
711: /*** 2010/11/20 ***/
712: /*
713: * Codes of a next command issue are moved to the end of this function.
714: */
715:
716: /*** End of modification ***/
717:
718: break ;
719:
720: case TS_JJY01_COMMAND_NUMBER_TIME : /* HH:MM:SS */
721: case TS_JJY01_COMMAND_NUMBER_STIM : /* HH:MM:SS */
722:
723: if ( iLen != TS_JJY01_REPLY_LENGTH_STIM ) {
724: up->lineerror = 1 ;
725: break ;
726: }
727:
728: rc = sscanf ( pBuf, "%2d:%2d:%2d", &up->hour,
729: &up->minute, &up->second ) ;
730: if ( rc != 3 || up->hour > 23 || up->minute > 59 ||
731: up->second > 60 ) {
732: up->lineerror = 1 ;
733: break ;
734: }
735:
736: up->msecond = 0 ;
737: if ( up->hour == 0 && up->minute == 0 &&
738: up->second <= 2 ) {
739: /*
740: * The command "date" and "time" ( or "stim" ) were sent to the JJY receiver separately,
741: * and the JJY receiver replies a date and time separately.
742: * Just after midnight transitions, we ignore this time.
743: */
744: bOverMidnight = 1 ;
745: }
746: break ;
747:
748: case TS_JJY01_COMMAND_NUMBER_STUS :
749:
750: if ( ( iLen == TS_JJY01_REPLY_LENGTH_STUS_YES
751: && strncmp( pBuf, TS_JJY01_REPLY_STUS_YES,
752: TS_JJY01_REPLY_LENGTH_STUS_YES ) == 0 )
753: || ( iLen == TS_JJY01_REPLY_LENGTH_STUS_NO
754: && strncmp( pBuf, TS_JJY01_REPLY_STUS_NO,
755: TS_JJY01_REPLY_LENGTH_STUS_NO ) == 0 ) ) {
756: /* Good */
757: } else {
758: up->lineerror = 1 ;
759: break ;
760: }
761:
762: break ;
763:
764: case TS_JJY01_COMMAND_NUMBER_DCST :
765:
766: if ( ( iLen == TS_JJY01_REPLY_LENGTH_DCST_VALID
767: && strncmp( pBuf, TS_JJY01_REPLY_DCST_VALID,
768: TS_JJY01_REPLY_LENGTH_DCST_VALID ) == 0 )
769: || ( iLen == TS_JJY01_REPLY_LENGTH_DCST_INVALID
770: && strncmp( pBuf, TS_JJY01_REPLY_DCST_INVALID,
771: TS_JJY01_REPLY_LENGTH_DCST_INVALID ) == 0 ) ) {
772: /* Good */
773: } else {
774: up->lineerror = 1 ;
775: break ;
776: }
777:
778: break ;
779:
780: default : /* Unexpected reply */
781:
782: up->lineerror = 1 ;
783: break ;
784:
785: }
786:
787: /* Clockstats Log */
788:
789: printableString( sReplyText, sizeof(sReplyText), pBuf, iLen ) ;
790: snprintf ( sLogText, sizeof(sLogText), "%d: %s -> %c: %s",
791: up->linecount,
792: tristate_jjy01_command_sequence[up->linecount-1].commandLog,
793: ( up->lineerror == 0 )
794: ? ( ( bOverMidnight == 0 )
795: ? 'O'
796: : 'S' )
797: : 'X',
798: sReplyText ) ;
799: record_clock_stats ( &peer->srcadr, sLogText ) ;
800:
801: /* Check before issue next command */
802:
803: if ( up->lineerror != 0 ) {
804: /* Do not issue next command */
805: return 0 ;
806: }
807:
808: if ( bOverMidnight != 0 ) {
809: /* Do not issue next command */
810: return 0 ;
811: }
812:
813: if ( tristate_jjy01_command_sequence[up->linecount].command == NULL ) {
814: /* Command sequence completed */
815: return 1 ;
816: }
817:
818: /* Issue next command */
819:
820: #ifdef DEBUG
821: if ( debug ) {
822: printf ( "%s (refclock_jjy.c) : send '%s'\n",
823: sFunctionName, tristate_jjy01_command_sequence[up->linecount].commandLog ) ;
824: }
825: #endif
826:
827: pCmd = tristate_jjy01_command_sequence[up->linecount].command ;
828: iCmdLen = tristate_jjy01_command_sequence[up->linecount].commandLength ;
829: if ( write ( pp->io.fd, pCmd, iCmdLen ) != iCmdLen ) {
830: refclock_report ( peer, CEVNT_FAULT ) ;
831: }
832:
833: return 0 ;
834:
835: }
836:
837: /**************************************************************************************************/
838:
839: static int
840: jjy_receive_cdex_jst2000 ( struct recvbuf *rbufp )
841: {
842:
843: static char *sFunctionName = "jjy_receive_cdex_jst2000" ;
844:
845: struct jjyunit *up ;
846: struct refclockproc *pp ;
847: struct peer *peer;
848:
849: char *pBuf ;
850: int iLen ;
851: int rc ;
852:
853: /*
854: * Initialize pointers and read the timecode and timestamp
855: */
856: peer = (struct peer *) rbufp->recv_srcclock ;
857: pp = peer->procptr ;
858: up = (struct jjyunit *) pp->unitptr ;
859:
860: if ( up->linediscipline == LDISC_RAW ) {
861: pBuf = up->rawbuf ;
862: iLen = up->charcount ;
863: } else {
864: pBuf = pp->a_lastcode ;
865: iLen = pp->lencode ;
866: }
867:
868: switch ( up->linecount ) {
869:
870: case 1 : /* JYYMMDD HHMMSSS */
871:
872: if ( iLen != 15 ) {
873: #ifdef DEBUG
874: if ( debug >= 2 ) {
875: printf ( "%s (refclock_jjy.c) : Reply length error ( iLen=%d )\n",
876: sFunctionName, iLen ) ;
877: }
878: #endif
879: up->lineerror = 1 ;
880: break ;
881: }
882: rc = sscanf ( pBuf, "J%2d%2d%2d%*1d%2d%2d%2d%1d",
883: &up->year, &up->month, &up->day,
884: &up->hour, &up->minute, &up->second,
885: &up->msecond ) ;
886: if ( rc != 7 || up->month < 1 || up->month > 12 ||
887: up->day < 1 || up->day > 31 || up->hour > 23 ||
888: up->minute > 59 || up->second > 60 ) {
889: #ifdef DEBUG
890: if ( debug >= 2 ) {
891: printf ( "%s (refclock_jjy.c) : Time error (rc=%d) [ %02d %02d %02d * %02d %02d %02d.%1d ]\n",
892: sFunctionName, rc, up->year,
893: up->month, up->day, up->hour,
894: up->minute, up->second,
895: up->msecond ) ;
896: }
897: #endif
898: up->lineerror = 1 ;
899: break ;
900: }
901: up->year += 2000 ;
902: up->msecond *= 100 ;
903: break ;
904:
905: default : /* Unexpected reply */
906:
907: up->lineerror = 1 ;
908: break ;
909:
910: }
911:
912: return 1 ;
913:
914: }
915:
916: /**************************************************************************************************/
917:
918: static int
919: jjy_receive_echokeisokuki_lt2000 ( struct recvbuf *rbufp )
920: {
921:
922: static char *sFunctionName = "jjy_receive_echokeisokuki_lt2000" ;
923:
924: struct jjyunit *up ;
925: struct refclockproc *pp ;
926: struct peer *peer;
927:
928: char *pBuf ;
929: int iLen ;
930: int rc ;
931: int i, ibcc, ibcc1, ibcc2 ;
932:
933: /*
934: * Initialize pointers and read the timecode and timestamp
935: */
936: peer = (struct peer *) rbufp->recv_srcclock ;
937: pp = peer->procptr ;
938: up = (struct jjyunit *) pp->unitptr ;
939:
940: if ( up->linediscipline == LDISC_RAW ) {
941: pBuf = up->rawbuf ;
942: iLen = up->charcount ;
943: } else {
944: pBuf = pp->a_lastcode ;
945: iLen = pp->lencode ;
946: }
947:
948: switch ( up->linecount ) {
949:
950: case 1 : /* YYMMDDWHHMMSS<BCC1><BCC2> or YYMMDDWHHMMSS<ST1><ST2><ST3><ST4> */
951:
952: if ( ( up->operationmode == 1 && iLen != 15 ) ||
953: ( up->operationmode == 2 && iLen != 17 ) ) {
954: #ifdef DEBUG
955: if ( debug >= 2 ) {
956: printf ( "%s (refclock_jjy.c) : Reply length error ( iLen=%d )\n",
957: sFunctionName, iLen ) ;
958: }
959: #endif
960: if ( up->operationmode == 1 ) {
961: #ifdef DEBUG
962: if ( debug ) {
963: printf ( "%s (refclock_jjy.c) : send '#'\n", sFunctionName ) ;
964: }
965: #endif
966: if ( write ( pp->io.fd, "#",1 ) != 1 ) {
967: refclock_report ( peer, CEVNT_FAULT ) ;
968: }
969: }
970: up->lineerror = 1 ;
971: break ;
972: }
973:
974: if ( up->operationmode == 1 ) {
975:
976: for ( i = ibcc = 0 ; i < 13 ; i ++ )
977: ibcc ^= pBuf[i] ;
978: ibcc1 = 0x30 | ( ( ibcc >> 4 ) & 0xF ) ;
979: ibcc2 = 0x30 | ( ( ibcc ) & 0xF ) ;
980: if ( pBuf[13] != ibcc1 || pBuf[14] != ibcc2 ) {
981: #ifdef DEBUG
982: if ( debug >= 2 ) {
983: printf ( "%s (refclock_jjy.c) : BCC error ( Recv=%02X,%02X / Calc=%02X,%02X)\n",
984: sFunctionName,
985: pBuf[13] & 0xFF,
986: pBuf[14] & 0xFF,
987: ibcc1, ibcc2 ) ;
988: }
989: #endif
990: up->lineerror = 1 ;
991: break ;
992: }
993:
994: }
995:
996: rc = sscanf ( pBuf, "%2d%2d%2d%*1d%2d%2d%2d",
997: &up->year, &up->month, &up->day,
998: &up->hour, &up->minute, &up->second ) ;
999: if ( rc != 6 || up->month < 1 || up->month > 12 ||
1000: up->day < 1 || up->day > 31 || up->hour > 23 ||
1001: up->minute > 59 || up->second > 60 ) {
1002: #ifdef DEBUG
1003: if ( debug >= 2 ) {
1004: printf ( "%s (refclock_jjy.c) : Time error (rc=%d) [ %02d %02d %02d * %02d %02d %02d ]\n",
1005: sFunctionName, rc, up->year,
1006: up->month, up->day, up->hour,
1007: up->minute, up->second ) ;
1008: }
1009: #endif
1010: up->lineerror = 1 ;
1011: break ;
1012: }
1013:
1014: up->year += 2000 ;
1015:
1016: if ( up->operationmode == 2 ) {
1017:
1018: /* A time stamp comes on every 0.5 seccond in the mode 2 of the LT-2000. */
1019: up->msecond = 500 ;
1020: pp->second -- ;
1021: if ( pp->second < 0 ) {
1022: pp->second = 59 ;
1023: pp->minute -- ;
1024: if ( pp->minute < 0 ) {
1025: pp->minute = 59 ;
1026: pp->hour -- ;
1027: if ( pp->hour < 0 ) {
1028: pp->hour = 23 ;
1029: pp->day -- ;
1030: if ( pp->day < 1 ) {
1031: pp->year -- ;
1032: pp->day = ymd2yd ( pp->year, 12, 31 ) ;
1033: }
1034: }
1035: }
1036: }
1037:
1038: /* Switch from mode 2 to mode 1 in order to restraint of useless time stamp. */
1039: #ifdef DEBUG
1040: if ( debug ) {
1041: printf ( "%s (refclock_jjy.c) : send '#'\n",
1042: sFunctionName ) ;
1043: }
1044: #endif
1045: if ( write ( pp->io.fd, "#",1 ) != 1 ) {
1046: refclock_report ( peer, CEVNT_FAULT ) ;
1047: }
1048:
1049: }
1050:
1051: break ;
1052:
1053: default : /* Unexpected reply */
1054:
1055: #ifdef DEBUG
1056: if ( debug ) {
1057: printf ( "%s (refclock_jjy.c) : send '#'\n",
1058: sFunctionName ) ;
1059: }
1060: #endif
1061: if ( write ( pp->io.fd, "#",1 ) != 1 ) {
1062: refclock_report ( peer, CEVNT_FAULT ) ;
1063: }
1064:
1065: up->lineerror = 1 ;
1066: break ;
1067:
1068: }
1069:
1070: return 1 ;
1071:
1072: }
1073:
1074: /**************************************************************************************************/
1075:
1076: static int
1077: jjy_receive_citizentic_jjy200 ( struct recvbuf *rbufp )
1078: {
1079:
1080: static char *sFunctionName = "jjy_receive_citizentic_jjy200" ;
1081:
1082: struct jjyunit *up ;
1083: struct refclockproc *pp ;
1084: struct peer *peer;
1085:
1086: char *pBuf ;
1087: int iLen ;
1088: int rc ;
1089: char cApostrophe, sStatus[3] ;
1090: int iWeekday ;
1091:
1092: /*
1093: * Initialize pointers and read the timecode and timestamp
1094: */
1095: peer = (struct peer *) rbufp->recv_srcclock ;
1096: pp = peer->procptr ;
1097: up = (struct jjyunit *) pp->unitptr ;
1098:
1099: if ( up->linediscipline == LDISC_RAW ) {
1100: pBuf = up->rawbuf ;
1101: iLen = up->charcount ;
1102: } else {
1103: pBuf = pp->a_lastcode ;
1104: iLen = pp->lencode ;
1105: }
1106:
1107: /*
1108: * JJY-200 sends a timestamp every second.
1109: * So, a timestamp is ignored unless it is right after polled.
1110: */
1111: if ( ! up->bPollFlag )
1112: return 0 ;
1113:
1114: switch ( up->linecount ) {
1115:
1116: case 1 : /* 'XX YY/MM/DD W HH:MM:SS<CR> */
1117:
1118: if ( iLen != 23 ) {
1119: #ifdef DEBUG
1120: if ( debug >= 2 ) {
1121: printf ( "%s (refclock_jjy.c) : Reply length error ( iLen=%d )\n",
1122: sFunctionName, iLen ) ;
1123: }
1124: #endif
1125: up->lineerror = 1 ;
1126: break ;
1127: }
1128:
1129: rc = sscanf ( pBuf, "%c%2s %2d/%2d/%2d %1d %2d:%2d:%2d",
1130: &cApostrophe, sStatus, &up->year,
1131: &up->month, &up->day, &iWeekday,
1132: &up->hour, &up->minute, &up->second ) ;
1133: sStatus[2] = 0 ;
1134: if ( rc != 9 || cApostrophe != '\'' ||
1135: strcmp( sStatus, "OK" ) != 0 || up->month < 1 ||
1136: up->month > 12 || up->day < 1 || up->day > 31 ||
1137: iWeekday > 6 || up->hour > 23 || up->minute > 59 ||
1138: up->second > 60 ) {
1139: #ifdef DEBUG
1140: if ( debug >= 2 ) {
1141: printf ( "%s (refclock_jjy.c) : Time error (rc=%d) [ %c %2s %02d %02d %02d %d %02d %02d %02d ]\n",
1142: sFunctionName, rc, cApostrophe,
1143: sStatus, up->year, up->month,
1144: up->day, iWeekday, up->hour,
1145: up->minute, up->second ) ;
1146: }
1147: #endif
1148: up->lineerror = 1 ;
1149: break ;
1150: }
1151:
1152: up->year += 2000 ;
1153: up->msecond = 0 ;
1154:
1155: break ;
1156:
1157: default : /* Unexpected reply */
1158:
1159: up->lineerror = 1 ;
1160: break ;
1161:
1162: }
1163:
1164: return 1 ;
1165:
1166: }
1167:
1168: /**************************************************************************************************/
1169: /* jjy_poll - called by the transmit procedure */
1170: /**************************************************************************************************/
1171: static void
1172: jjy_poll ( int unit, struct peer *peer )
1173: {
1174:
1175: struct jjyunit *up;
1176: struct refclockproc *pp;
1177:
1178: pp = peer->procptr;
1179: up = (struct jjyunit *) pp->unitptr ;
1180:
1181: if ( pp->polls > 0 && up->linecount == 0 ) {
1182: /*
1183: * No reply for last command
1184: */
1185: refclock_report ( peer, CEVNT_TIMEOUT ) ;
1186: }
1187:
1188: #ifdef DEBUG
1189: if ( debug ) {
1190: printf ( "jjy_poll (refclock_jjy.c) : %ld\n", pp->polls ) ;
1191: }
1192: #endif
1193:
1194: pp->polls ++ ;
1195:
1196: up->bPollFlag = 1 ;
1197: up->linecount = 0 ;
1198: up->lineerror = 0 ;
1199: up->charcount = 0 ;
1200:
1201: switch ( up->unittype ) {
1202:
1203: case UNITTYPE_TRISTATE_JJY01 :
1204: jjy_poll_tristate_jjy01 ( unit, peer ) ;
1205: break ;
1206:
1207: case UNITTYPE_CDEX_JST2000 :
1208: jjy_poll_cdex_jst2000 ( unit, peer ) ;
1209: break ;
1210:
1211: case UNITTYPE_ECHOKEISOKUKI_LT2000 :
1212: jjy_poll_echokeisokuki_lt2000 ( unit, peer ) ;
1213: break ;
1214:
1215: case UNITTYPE_CITIZENTIC_JJY200 :
1216: jjy_poll_citizentic_jjy200 ( unit, peer ) ;
1217: break ;
1218:
1219: default :
1220: break ;
1221:
1222: }
1223:
1224: }
1225:
1226: /**************************************************************************************************/
1227:
1228: static void
1229: jjy_poll_tristate_jjy01 ( int unit, struct peer *peer )
1230: {
1231:
1232: static char *sFunctionName = "jjy_poll_tristate_jjy01" ;
1233:
1234: struct jjyunit *up;
1235: struct refclockproc *pp;
1236:
1237: char *pCmd ;
1238: int iCmdLen ;
1239:
1240: pp = peer->procptr;
1241: up = (struct jjyunit *) pp->unitptr ;
1242:
1243: if ( ( pp->sloppyclockflag & CLK_FLAG1 ) == 0 ) {
1244: up->linecount = 2 ;
1245: }
1246:
1247: #ifdef DEBUG
1248: if ( debug ) {
1249: printf ( "%s (refclock_jjy.c) : flag1=%X CLK_FLAG1=%X up->linecount=%d\n",
1250: sFunctionName, pp->sloppyclockflag, CLK_FLAG1,
1251: up->linecount ) ;
1252: }
1253: #endif
1254:
1255: /*
1256: * Send a first command
1257: */
1258:
1259: #ifdef DEBUG
1260: if ( debug ) {
1261: printf ( "%s (refclock_jjy.c) : send '%s'\n",
1262: sFunctionName,
1263: tristate_jjy01_command_sequence[up->linecount].commandLog ) ;
1264: }
1265: #endif
1266:
1267: pCmd = tristate_jjy01_command_sequence[up->linecount].command ;
1268: iCmdLen = tristate_jjy01_command_sequence[up->linecount].commandLength ;
1269: if ( write ( pp->io.fd, pCmd, iCmdLen ) != iCmdLen ) {
1270: refclock_report ( peer, CEVNT_FAULT ) ;
1271: }
1272:
1273: }
1274:
1275: /**************************************************************************************************/
1276:
1277: static void
1278: jjy_poll_cdex_jst2000 ( int unit, struct peer *peer )
1279: {
1280:
1281: struct refclockproc *pp;
1282:
1283: pp = peer->procptr;
1284:
1285: /*
1286: * Send "<ENQ>1J<ETX>" command
1287: */
1288:
1289: #ifdef DEBUG
1290: if ( debug ) {
1291: printf ( "jjy_poll_cdex_jst2000 (refclock_jjy.c) : send '<ENQ>1J<ETX>'\n" ) ;
1292: }
1293: #endif
1294:
1295: if ( write ( pp->io.fd, "\0051J\003", 4 ) != 4 ) {
1296: refclock_report ( peer, CEVNT_FAULT ) ;
1297: }
1298:
1299: }
1300:
1301: /**************************************************************************************************/
1302:
1303: static void
1304: jjy_poll_echokeisokuki_lt2000 ( int unit, struct peer *peer )
1305: {
1306:
1307: struct jjyunit *up;
1308: struct refclockproc *pp;
1309:
1310: char sCmd[2] ;
1311:
1312: pp = peer->procptr;
1313: up = (struct jjyunit *) pp->unitptr ;
1314:
1315: /*
1316: * Send "T" or "C" command
1317: */
1318:
1319: switch ( up->operationmode ) {
1320: case 1 : sCmd[0] = 'T' ; break ;
1321: case 2 : sCmd[0] = 'C' ; break ;
1322: }
1323: sCmd[1] = 0 ;
1324:
1325: #ifdef DEBUG
1326: if ( debug ) {
1327: printf ( "jjy_poll_echokeisokuki_lt2000 (refclock_jjy.c) : send '%s'\n", sCmd ) ;
1328: }
1329: #endif
1330:
1331: if ( write ( pp->io.fd, sCmd, 1 ) != 1 ) {
1332: refclock_report ( peer, CEVNT_FAULT ) ;
1333: }
1334:
1335: }
1336:
1337: /**************************************************************************************************/
1338:
1339: static void
1340: jjy_poll_citizentic_jjy200 ( int unit, struct peer *peer )
1341: {
1342:
1343: /* Do nothing ( up->bPollFlag is set by the jjy_poll ) */
1344:
1345: }
1346:
1347: /**************************************************************************************************/
1348:
1349: static void
1350: printableString ( char *sOutput, int iOutputLen, char *sInput, int iInputLen )
1351: {
1352:
1353: char *printableControlChar[] = {
1354: "<NUL>", "<SOH>", "<STX>", "<ETX>",
1355: "<EOT>", "<ENQ>", "<ACK>", "<BEL>",
1356: "<BS>" , "<HT>" , "<LF>" , "<VT>" ,
1357: "<FF>" , "<CR>" , "<SO>" , "<SI>" ,
1358: "<DLE>", "<DC1>", "<DC2>", "<DC3>",
1359: "<DC4>", "<NAK>", "<SYN>", "<ETB>",
1360: "<CAN>", "<EM>" , "<SUB>", "<ESC>",
1361: "<FS>" , "<GS>" , "<RS>" , "<US>" ,
1362: " " } ;
1363:
1364: int i, j, n ;
1365:
1366: for ( i = j = 0 ; i < iInputLen && j < iOutputLen ; i ++ ) {
1367: if ( isprint( sInput[i] ) ) {
1368: n = 1 ;
1369: if ( j + 1 >= iOutputLen )
1370: break ;
1371: sOutput[j] = sInput[i] ;
1372: } else if ( ( sInput[i] & 0xFF ) <
1373: COUNTOF(printableControlChar) ) {
1374: n = strlen( printableControlChar[sInput[i] & 0xFF] ) ;
1375: if ( j + n + 1 >= iOutputLen )
1376: break ;
1377: strncpy( sOutput + j,
1378: printableControlChar[sInput[i] & 0xFF],
1379: (size_t)iOutputLen - j ) ;
1380: } else {
1381: n = 5 ;
1382: if ( j + n + 1 >= iOutputLen ) break ;
1383: snprintf( sOutput + j, (size_t)iOutputLen - j,
1384: "<x%X>", sInput[i] & 0xFF ) ;
1385: }
1386: j += n ;
1387: }
1388:
1389: sOutput[min(j, iOutputLen - 1)] = '\0' ;
1390:
1391: }
1392:
1393: /**************************************************************************************************/
1394:
1395: #else
1396: int refclock_jjy_bs ;
1397: #endif /* REFCLOCK */