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