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