contrib/ntp/libntp/icom.c

   1 /*
   2  * Program to control ICOM radios
   3  *
   4  * This is a ripoff of the utility routines in the ICOM software
   5  * distribution. The only function provided is to load the radio
   6  * frequency. All other parameters must be manually set before use.
   7  */
   8 #include "icom.h"
   9 #include <unistd.h>
  10 #include <stdio.h>
  11 #include <fcntl.h>
  12 #include <errno.h>
  13
  14 #include "ntp_tty.h"
  15 #include "l_stdlib.h"
  16
  17 /*
  18  * Scraps
  19  */
  20 #define BMAX 50                 /* max command length */
  21 #define DICOM /dev/icom/        /* ICOM port link */
  22
  23 /*
  24  * FSA definitions
  25  */
  26 #define S_IDLE  0               /* idle */
  27 #define S_HDR   1               /* header */
  28 #define S_TX    2               /* address */
  29 #define S_DATA  3               /* data */
  30 #define S_ERROR 4               /* error */
  31
  32 /*
  33  * Local function prototypes
  34  */
  35 static void doublefreq          P((double, u_char *, int));
  36 static int sndpkt               P((int, int, u_char *, u_char *));
  37 static int sndoctet             P((int, int));
  38 static int rcvoctet             P((int));
  39
  40 /*
  41  * Local variables
  42  */
  43 static int flags;               /* trace flags */
  44 static int state;               /* fsa state */
  45
  46
  47 /*
  48  * icom_freq(fd, ident, freq) - load radio frequency
  49  */
  50 int
  51 icom_freq(                      /* returns 0 (ok), EIO (error) */
  52         int fd,                 /* file descriptor */
  53         int ident,              /* ICOM radio identifier */
  54         double freq             /* frequency (MHz) */
  55         )
  56 {
  57         u_char cmd[BMAX], rsp[BMAX];
  58         int temp;
  59         cmd[0] = V_SFREQ;
  60         if (ident == IC735)
  61                 temp = 4;
  62         else
  63                 temp = 5;
  64         doublefreq(freq * 1e6, &cmd[1], temp);
  65         temp = sndpkt(fd, ident, cmd, rsp);
  66         if (temp < 1 || rsp[0] != ACK)
  67                 return (EIO);
  68         return (0);
  69 }
  70
  71
  72 /*
  73  * doublefreq(freq, y, len) - double to ICOM frequency with padding
  74  */
  75 static void
  76 doublefreq(                     /* returns void */
  77         double freq,            /* frequency */
  78         u_char *x,              /* radio frequency */
  79         int len                 /* length (octets) */
  80         )
  81 {
  82         int i;
  83         char s1[11];
  84         char *y;
  85
  86         sprintf(s1, " %10.0f", freq);
  87         y = s1 + 10;
  88         i = 0;
  89         while (*y != ' ') {
  90                 x[i] = *y-- & 0x0f;
  91                 x[i] = x[i] | ((*y-- & 0x0f) << 4);
  92                 i++;
  93         }
  94         for (; i < len; i++)
  95                 x[i] = 0;
  96         x[i] = FI;
  97 }
  98
  99
 100 /*
 101  * Packet routines
 102  *
 103  * These routines send a packet and receive the response. If an error
 104  * (collision) occurs on transmit, the packet is resent. If an error
 105  * occurs on receive (timeout), all input to the terminating FI is
 106  * discarded and the packet is resent. If the maximum number of retries
 107  * is not exceeded, the program returns the number of octets in the user
 108  * buffer; otherwise, it returns zero.
 109  *
 110  * ICOM frame format
 111  *
 112  * Frames begin with a two-octet preamble PR-PR followyd by the
 113  * transceiver address RE, controller address TX, control code CN, zero
 114  * or more data octets DA (depending on command), and terminator FI.
 115  * Since the bus is bidirectional, every octet output is echoed on
 116  * input. Every valid frame sent is answered with a frame in the same
 117  * format, but with the RE and TX fields interchanged. The CN field is
 118  * set to NAK if an error has occurred. Otherwise, the data are returned
 119  * in this and following DA octets. If no data are returned, the CN
 120  * octet is set to ACK.
 121  *
 122  *      +------+------+------+------+------+--//--+------+
 123  *      |  PR  |  PR  |  RE  |  TX  |  CN  |  DA  |  FI  |
 124  *      +------+------+------+------+------+--//--+------+
 125  */
 126 /*
 127  * icom_open() - open and initialize serial interface
 128  *
 129  * This routine opens the serial interface for raw transmission; that
 130  * is, character-at-a-time, no stripping, checking or monkeying with the
 131  * bits. For Unix, an input operation ends either with the receipt of a
 132  * character or a 0.5-s timeout.
 133  */
 134 int
 135 icom_init(
 136         char *device,           /* device name/link */
 137         int speed,              /* line speed */
 138         int trace               /* trace flags */       )
 139 {
 140         TTY ttyb;
 141         int fd;
 142
 143         flags = trace;
 144         fd = open(device, O_RDWR, 0777);
 145         if (fd < 0)
 146                 return (fd);
 147
 148         tcgetattr(fd, &ttyb);
 149         ttyb.c_iflag = 0;       /* input modes */
 150         ttyb.c_oflag = 0;       /* output modes */
 151         ttyb.c_cflag = IBAUD|CS8|CREAD|CLOCAL;  /* control modes */
 152         ttyb.c_lflag = 0;       /* local modes */
 153         ttyb.c_cc[VMIN] = 0;    /* min chars */
 154         ttyb.c_cc[VTIME] = 5;   /* receive timeout */
 155         cfsetispeed(&ttyb, (u_int)speed);
 156         cfsetospeed(&ttyb, (u_int)speed);
 157         tcsetattr(fd, TCSANOW, &ttyb);
 158         return (fd);
 159 }
 160
 161
 162 /*
 163  * sndpkt(r, x, y) - send packet and receive response
 164  *
 165  * This routine sends a command frame, which consists of all except the
 166  * preamble octets PR-PR. It then listens for the response frame and
 167  * returns the payload to the caller. The routine checks for correct
 168  * response header format; that is, the length of the response vector
 169  * returned to the caller must be at least 2 and the RE and TX octets
 170  * must be interchanged; otherwise, the operation is retried up to
 171  * the number of times specified in a global variable.
 172  *
 173  * The trace function, which is enabled by the P_TRACE bit of the global
 174  * flags variable, prints all characters received or echoed on the bus
 175  * preceded by a T (transmit) or R (receive). The P_ERMSG bit of the
 176  * flags variable enables printing of bus error messages.
 177  *
 178  * Note that the first octet sent is a PAD in order to allow time for
 179  * the radio to flush its receive buffer after sending the previous
 180  * response. Even with this precaution, some of the older radios
 181  * occasionally fail to receive a command and it has to be sent again.
 182  */
 183 static int
 184 sndpkt(                         /* returns octet count */
 185         int fd,                 /* file descriptor */
 186         int r,                  /* radio address */
 187         u_char *cmd,            /* command vector */
 188         u_char *rsp             /* response vector */
 189         )
 190 {
 191         int i, j, temp;
 192
 193         (void)tcflush(fd, TCIOFLUSH);
 194         for (i = 0; i < RETRY; i++) {
 195                 state = S_IDLE;
 196
 197                 /*
 198                  * Transmit packet.
 199                  */
 200                 if (flags & P_TRACE)
 201                         printf("icom T:");
 202                 sndoctet(fd, PAD);      /* send header */
 203                 sndoctet(fd, PR);
 204                 sndoctet(fd, PR);
 205                 sndoctet(fd, r);
 206                 sndoctet(fd, TX);
 207                 for (j = 0; j < BMAX; j++) { /* send body */
 208                         if (sndoctet(fd, cmd[j]) == FI)
 209                                 break;
 210                 }
 211                 while (rcvoctet(fd) != FI); /* purge echos */
 212                 if (cmd[0] == V_FREQT || cmd[0] == V_MODET)
 213                         return (0);     /* shortcut for broadcast */
 214
 215                 /*
 216                  * Receive packet. First, delete all characters
 217                  * preceeding a PR, then discard all PRs. Check that the
 218                  * RE and TX fields are correctly interchanged, then
 219                  * copy the remaining data and FI to the user buffer.
 220                  */
 221                 if (flags & P_TRACE)
 222                         printf("\nicom R:");
 223                 j = 0;
 224                 while ((temp = rcvoctet(fd)) != FI) {
 225                         switch (state) {
 226
 227                         case S_IDLE:
 228                                 if (temp != PR)
 229                                         continue;
 230                                 state = S_HDR;
 231                                 break;
 232
 233                         case S_HDR:
 234                                 if (temp == PR) {
 235                                         continue;
 236                                 } else if (temp != TX) {
 237                                         if (flags & P_ERMSG)
 238                                                 printf(
 239                                                     "icom: TX error\n");
 240                                         state = S_ERROR;
 241                                 }
 242                                 state = S_TX;
 243                                 break;
 244
 245                         case S_TX:
 246                                 if (temp != r) {
 247                                         if (flags & P_ERMSG)
 248                                                 printf(
 249                                                     "icom: RE error\n");
 250                                         state = S_ERROR;
 251                                 }
 252                                 state = S_DATA;
 253                                 break;
 254
 255                         case S_DATA:
 256                                 if (j >= BMAX ) {
 257                                         if (flags & P_ERMSG)
 258                                                 printf(
 259                                             "icom: buffer overrun\n");
 260                                         state = S_ERROR;
 261                                         j = 0;
 262                                 }
 263                                 rsp[j++] = (u_char)temp;
 264                                 break;
 265
 266                         case S_ERROR:
 267                                 break;
 268                         }
 269                 }
 270                 if (flags & P_TRACE)
 271                         printf("\n");
 272                 if (j > 0) {
 273                         rsp[j++] = FI;
 274                         return (j);
 275                 }
 276         }
 277         if (flags & P_ERMSG)
 278                 printf("icom: retries exceeded\n");
 279         return (0);
 280 }
 281
 282
 283 /*
 284  * Interface routines
 285  *
 286  * These routines read and write octets on the bus. In case of receive
 287  * timeout a FI code is returned. In case of output collision (echo
 288  * does not match octet sent), the remainder of the collision frame
 289  * (including the trailing FI) is discarded.
 290  */
 291 /*
 292  * sndoctet(fd, x) - send octet
 293  */
 294 static int
 295 sndoctet(                       /* returns octet */
 296         int fd,                 /* file descriptor */
 297         int x                   /* octet */
 298         )
 299 {
 300         u_char y;
 301
 302         y = (u_char)x;
 303         write(fd, &y, 1);
 304         return (x);
 305 }
 306
 307
 308 /*
 309  * rcvoctet(fd) - receive octet
 310  */
 311 static int
 312 rcvoctet(                       /* returns octet */
 313         int fd                  /* file descriptor */
 314         )
 315 {
 316         u_char y;
 317
 318         if (read(fd, &y, 1) < 1)
 319                 y = FI;         /* come here if timeout */
 320         if (flags & P_TRACE && y != PAD)
 321                 printf(" %02x", y);
 322         return (y);
 323 }
 324
 325 /* end program */