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 */ 326