icom.c revision 56746 
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 */
40static void doublefreq		P((double, u_char *, int));
41static int sndpkt		P((int, int, u_char *, u_char *));
42static int sndoctet		P((int, int));
43static int rcvoctet		P((int));
44
45/*
46 * Local variables
47 */
48static int flags;		/* trace flags */
49static int state;		/* fsa state */
50
51
52/*
53 * icom_freq(fd, ident, freq) - load radio frequency
54 */
55int
56icom_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 */
80static void
81doublefreq(			/* 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 */
139int
140icom_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 */
187static int
188sndpkt(				/* 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 */
298static int
299sndoctet(			/* 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 */
315static int
316rcvoctet(			/* 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