File: packet.c

package info (click to toggle)
icom 20040912-1.1
  • links: PTS
  • area: main
  • in suites: squeeze, wheezy
  • size: 744 kB
  • ctags: 501
  • sloc: ansic: 3,086; csh: 65; makefile: 62; awk: 61
file content (361 lines) | stat: -rw-r--r-- 9,333 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
/*
 * Program to control ICOM radios
 *
 * Input/output interface
 */
#include "icom.h"

#ifndef MSDOS
#include <sys/fcntl.h>
#include <sys/termios.h>
#include <sys/unistd.h>
#else /* MSDOS */
#include <string.h>
#endif /* MSDOS */

/*
 * Parameters
 */
#ifdef MSDOS
#define XFRETRY	3000		/* interface timeout counter (MSDOS) */

/*
 * Define port and speed
 */
#define PORT	0x03f8		/* port address (COM1) */
/* #define PORT 0x02f8		/* port address (COM2) */
/* #define PORT 0x03e8		/* port address (COM3) */
/* #define PORT 0x02e8		/* port address (COM4) */
/* #define BAUD 384		/* baud rate 300 */
#define BAUD	96		/* baud rate 1200 */
/* #define BAUD 12		/* baud rate 9600 */

/*
 * Serial port definitions (8250)
 */
#define THR	0		/* transmitter holding register */
#define RBR	0		/* receiver buffer register */
#define DLL	0		/* divisor latch LSB */
#define DLM	1		/* divisor latch MSB */
#define LCR	3		/* line control register */
#define LCR_8BITS 3		/* 8 bit words */
#define   LCR_DLAB 0x80		/* divisor latch access bit */
#define MCR	4		/* modem control register */
#define   MCR_DTR 1		/* data terminal ready */
#define   MCR_RTS 2		/* request to send */
#define LSR	5		/* line status register */
#define   LSR_DR 0x01		/* data ready */
#define   LSR_THRE 0x20		/* trans line holding register empty */
#define   LSR_TSRE 0x40		/* transmitter shift register empty */
#else /* MSDOS */
#define DICOM	"/dev/icom"	/* serial line driver */
#define	BICOM	B1200		/* serial line speed */
#endif /* MSDOS */

/*
 * fsa definitions
 */
#define S_IDLE	0		/* idle */
#define S_HDR	1		/* header */
#define S_TX	2		/* address */
#define S_DATA	3		/* data */
#define S_ERROR	4		/* error */

/*
 * Global variables
 */
int retry;			/* max command retries */

/*
 * Local function prototypes
 */
static u_char sndoctet(u_char);	/* send octet */
static u_char rcvoctet();	/* receive octet */

/*
 * Local variables
 */
static int count;		/* retry counter */
static int fd_icom;		/* radio file descriptor */
static int state;		/* fsa state */
#ifdef MSDOS
static int inp(int);		/* input port byte */
static void outp(int, int);	/* output port byte */
static void outpw(int, int);	/* output port word */
#endif /* MSDOS */

/*
 * Packet routines
 *
 * These routines send a packet and receive the response. Since the CI-V
 * bus is bidirectional, every octet sent by this program is read back
 * for check. If an error occurs on transmit (readback compare check),
 * the packet is resent. If an error occurs on receive (timeout), all
 * input to the terminating fe is discarded and the packet is resent. If
 * the maximum number of retries is not exceeded, the program returns
 * the number of octets in the user buffer; otherwise, it returns zero.
 *
 * ICOM frame format
 *
 * Frames begin with a two-octet preamble (fe-fe) followed by the radio
 * address RA, controller address (e0), command CN, subcommand SN
 * (optional), zero or more data octets DA and terminator fd. If a
 * subcommand is not used, the data field begins with the SN octet.
 *
 * The radio responds to a command frame with a response frame in the
 * same format, but with the radio and controller addresses
 * interchanged. If the response contains no data, the CN octet is fb
 * for success or fa for failure and the following octet fd ends the
 * frame. If the response format includes a data field, a frame with a
 * nonempty data field is a success, but an empty data field is a
 * failure.
 *
 *	+------+------+------+------+------+------+--//--+------+
 *	|  fe  |  fe  |  RA  |  e0  |  CN  |  SN  |  DA  |  fd  |
 *	+------+------+------+------+------+------+--//--+------+
 */
/*
 * initpkt() - initialize serial interface
 *
 * This routine opens the serial interface for raw transmission; that
 * is, character-at-a-time, no stripping, checking or monkeying with the
 * bits. For Unix, an input operation ends either with the receipt of a
 * character or a 0.5-s timeout.
 */
void
initpkt()			/* no return value */
{
#ifdef MSDOS
	outp(PORT+LCR, LCR_DLAB); /* set baud */
	outpw(PORT+DLL, BAUD);
	outp(PORT+LCR, LCR_8BITS); /* set 8 bits, no parity */
	outp(PORT+MCR, MCR_DTR+MCR_RTS); /* wake up modem */
#else /* MSDOS */
	struct termios ttyb, *ttyp;

	ttyp = &ttyb;
	if ((fd_icom = open(DICOM, O_RDWR, 0777)) < 0) {
		printf("\n*** Unable to open serial line %s\n", DICOM);
		exit(1);
	}
	if (tcgetattr(fd_icom, ttyp) < 0) {
		printf("\n*** Unable to get line parameters\n");
		exit(1);
	}
	ttyp->c_iflag = 0;	/* input modes */
	ttyp->c_oflag = 0;	/* output modes */
	ttyp->c_cflag = BICOM|CS8|CREAD|CLOCAL;	/* control modes */
	ttyp->c_lflag = 0;	/* local modes */
	ttyp->c_cc[VMIN] = 0;	/* min chars */
	ttyp->c_cc[VTIME] = 5;	/* receive timeout */
	if (tcsetattr(fd_icom, TCSANOW, ttyp) < 0) {
		printf("\n*** Unable to set line parameters\n");
		exit(1);
	}
#endif /* MSDOS */
	retry = RETRY;
}

/*
 * sndpkt(r, x, y) - send packet and receive response
 *
 * This routine sends a command frame, which consists of all except the
 * preamble octets fe-fe. It then listens for the response frame and
 * returns the payload to the caller. The routine checks for correct
 * response header format; that is, the length of the response vector
 * returned to the caller must be at least two and the radio and
 * controller address octets must be interchanged; otherwise, the
 * operation is retried up to the number of times specified in a global
 * variable.
 *
 * The trace function, which is enabled by the P_TRACE bit of the global
 * pflags variable, prints all characters received or echoed on the bus
 * preceded by a T (transmit) or R (receive). The P_ERMSG bit of the
 * pflags variable enables printing of bus error messages.
 *
 * Note that the first octet sent is a pad (ff) in order to allow time
 * for the radio to flush its receive buffer after sending the previous
 * response. Even with this precaution, some of the older radios
 * occasionally fail to receive a command and it has to be sent again.
 */
int
sndpkt(				/* returns octet count */
	int r,			/* radio address */
	u_char *x,		/* command vector */
	u_char *y		/* response vector */
	)
{
	int i, j, k;		/* temps */
	u_char temp;

#ifndef MSDOS
	(void)tcflush(fd_icom, TCIOFLUSH);
#endif /* MSDOS */
	for (i = 0; i < retry; i++) {
		state = S_IDLE;

		/*
		 * Transmit packet.
		 */
		if (pflags & P_TRACE)
			printf("T:");
		sndoctet(PAD);		/* send header */
		sndoctet(PR);
		sndoctet(PR);
		sndoctet(r);
		sndoctet(TX);
		for (j = 0; j < BMAX; j++) { /* send body */
			if (sndoctet(x[j]) == FI)
				break;
		}
		while (rcvoctet() != FI); /* purge echos */
		if (x[0] == V_FREQT || x[0] == V_MODET)
			return (0);	/* shortcut for broadcast */

		/*
		 * Receive packet. First, delete all characters
		 * preceeding a PR, then discard all PRs. Check that the
		 * RE and TX fields are correctly interchanged, then
		 * copy the remaining data and FI to the user buffer.
		 */
		if (pflags & P_TRACE)
			printf("\nR:");
		j = 0;
		while ((temp = rcvoctet()) != FI) {
			switch (state) {

				case S_IDLE:
				if (temp != PR)
					continue;
				state = S_HDR;
				break;

				case S_HDR:
				if (temp == PR) {
					continue;
				} else if (temp != TX) {
					if (pflags & P_ERMSG)
						printf(
						    "\n*** TX error\n");
					state = S_ERROR;
				}
				state = S_TX;
				break;

				case S_TX:
				if (temp != r) {
					if (pflags & P_ERMSG)
						printf(
						    "\n*** RE error\n");
					state = S_ERROR;
				}
				state = S_DATA;
				break;

				case S_DATA:
				if (j >= BMAX ) {
					if (pflags & P_ERMSG)
						printf(
					    "\n*** buffer overrun\n");
					state = S_ERROR;
					j = 0;
				}
				y[j++] = temp;
				break;

				case S_ERROR:
				break;
			}
		}
		if (pflags & P_TRACE)
			printf("\n");
		if (j > 0) {
			y[j++] = FI;
			return (j);
		}
	}
	if (pflags & P_ERMSG)
		printf("*** retries exceeded\n");
	return (0);
}

/*
 * Interface routines
 *
 * These routines read and write octets on the bus. In case of receive
 * timeout a FI code is returned. In case of output collision (echo
 * does not match octet sent), the remainder of the collision frame
 * (including the trailing FI) is discarded.
 */

#ifdef MSDOS
/*
 * sndoctet(x) - send octet
 */
static u_char
sndoctet(			/* returns octet */
	u_char x;		/* octet */
	)
{
	u_char temp;

	inp(PORT+RBR);		/* flush spikes */
	outp(PORT+THR, x);	/* write octet */
	if (x == (temp = rcvoctet()))
		return (x);

	if (pflags & P_ERMSG)
		printf("\n*** bus error %02x %02x\n", x, temp);
	while (rcvoctet() != FI); /* discard junk */
	return (FI);
}

/*
 * Receive octet
 */
static u_char
rcvoctet()			/* returns octet, FI if error */
{
	int i;
	u_char temp;

	for (i = 0; i < XFRETRY; i++) /* wait for input */
	if ((inp(PORT + LSR)) & LSR_DR != 0) {
		if (i > count)
			count = i;
		temp = inp(PORT+RBR); /* read octet */
		return (temp);
	}
	return (FI);
}
#else /* MSDOS */

/*
 * sndoctet(x) - send octet
 */
static u_char
sndoctet(			/* returns octet */
	u_char x		/* octet */
	)
{
	write(fd_icom, &x, 1);
	return (x);
}

/*
 * rcvoctet () - receive octet
 */
static u_char
rcvoctet()			/* returns octet */
{
	u_char y;

	if (read(fd_icom, &y, 1) < 1)
		y = FI;		/* come here if timeout */
	if (pflags & P_TRACE && y != PAD)
		printf(" %02x", y);
	return (y);
}
#endif /* MSDOS */

/* end program */