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
icom_freq(int fd,int ident,double freq)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
doublefreq(double freq,u_char * x,int len)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
icom_init(char * device,int speed,int trace)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
sndpkt(int fd,int r,u_char * cmd,u_char * rsp)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
sndoctet(int fd,int x)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
rcvoctet(int fd)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