mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-13 10:02:38 +00:00
324 lines
7.6 KiB
C
324 lines
7.6 KiB
C
/*
|
|
* Program to control ICOM radios
|
|
*
|
|
* This is a ripoff of the utility routines in the ICOM software
|
|
* distribution. The only function provided is to load the radio
|
|
* frequency. All other parameters must be manually set before use.
|
|
*/
|
|
#include "icom.h"
|
|
#include <unistd.h>
|
|
#include <stdio.h>
|
|
#include <fcntl.h>
|
|
#include <errno.h>
|
|
|
|
#include "ntp_tty.h"
|
|
|
|
/*
|
|
* Scraps
|
|
*/
|
|
#define BMAX 50 /* max command length */
|
|
#define DICOM /dev/icom/ /* ICOM port link */
|
|
|
|
/*
|
|
* 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 */
|
|
|
|
/*
|
|
* Local function prototypes
|
|
*/
|
|
static void doublefreq P((double, u_char *, int));
|
|
static int sndpkt P((int, int, u_char *, u_char *));
|
|
static int sndoctet P((int, int));
|
|
static int rcvoctet P((int));
|
|
|
|
/*
|
|
* Local variables
|
|
*/
|
|
static int flags; /* trace flags */
|
|
static int state; /* fsa state */
|
|
|
|
|
|
/*
|
|
* icom_freq(fd, ident, freq) - load radio frequency
|
|
*/
|
|
int
|
|
icom_freq( /* returns 0 (ok), EIO (error) */
|
|
int fd, /* file descriptor */
|
|
int ident, /* ICOM radio identifier */
|
|
double freq /* frequency (MHz) */
|
|
)
|
|
{
|
|
u_char cmd[BMAX], rsp[BMAX];
|
|
int temp;
|
|
cmd[0] = V_SFREQ;
|
|
if (ident == IC735)
|
|
temp = 4;
|
|
else
|
|
temp = 5;
|
|
doublefreq(freq * 1e6, &cmd[1], temp);
|
|
temp = sndpkt(fd, ident, cmd, rsp);
|
|
if (temp < 1 || rsp[0] != ACK)
|
|
return (EIO);
|
|
return (0);
|
|
}
|
|
|
|
|
|
/*
|
|
* doublefreq(freq, y, len) - double to ICOM frequency with padding
|
|
*/
|
|
static void
|
|
doublefreq( /* returns void */
|
|
double freq, /* frequency */
|
|
u_char *x, /* radio frequency */
|
|
int len /* length (octets) */
|
|
)
|
|
{
|
|
int i;
|
|
char s1[11];
|
|
char *y;
|
|
|
|
sprintf(s1, " %10.0f", freq);
|
|
y = s1 + 10;
|
|
i = 0;
|
|
while (*y != ' ') {
|
|
x[i] = *y-- & 0x0f;
|
|
x[i] = x[i] | ((*y-- & 0x0f) << 4);
|
|
i++;
|
|
}
|
|
for (; i < len; i++)
|
|
x[i] = 0;
|
|
x[i] = FI;
|
|
}
|
|
|
|
|
|
/*
|
|
* Packet routines
|
|
*
|
|
* These routines send a packet and receive the response. If an error
|
|
* (collision) occurs on transmit, the packet is resent. If an error
|
|
* occurs on receive (timeout), all input to the terminating FI 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 PR-PR followyd by the
|
|
* transceiver address RE, controller address TX, control code CN, zero
|
|
* or more data octets DA (depending on command), and terminator FI.
|
|
* Since the bus is bidirectional, every octet output is echoed on
|
|
* input. Every valid frame sent is answered with a frame in the same
|
|
* format, but with the RE and TX fields interchanged. The CN field is
|
|
* set to NAK if an error has occurred. Otherwise, the data are returned
|
|
* in this and following DA octets. If no data are returned, the CN
|
|
* octet is set to ACK.
|
|
*
|
|
* +------+------+------+------+------+--//--+------+
|
|
* | PR | PR | RE | TX | CN | DA | FI |
|
|
* +------+------+------+------+------+--//--+------+
|
|
*/
|
|
/*
|
|
* icom_open() - open and 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.
|
|
*/
|
|
int
|
|
icom_init(
|
|
char *device, /* device name/link */
|
|
int speed, /* line speed */
|
|
int trace /* trace flags */ )
|
|
{
|
|
TTY ttyb;
|
|
int fd;
|
|
|
|
flags = trace;
|
|
fd = open(device, O_RDWR, 0777);
|
|
if (fd < 0)
|
|
return (fd);
|
|
tcgetattr(fd, &ttyb);
|
|
ttyb.c_iflag = 0; /* input modes */
|
|
ttyb.c_oflag = 0; /* output modes */
|
|
ttyb.c_cflag = IBAUD|CS8|CREAD|CLOCAL; /* control modes */
|
|
ttyb.c_lflag = 0; /* local modes */
|
|
ttyb.c_cc[VMIN] = 0; /* min chars */
|
|
ttyb.c_cc[VTIME] = 5; /* receive timeout */
|
|
cfsetispeed(&ttyb, (u_int)speed);
|
|
cfsetospeed(&ttyb, (u_int)speed);
|
|
tcsetattr(fd, TCSANOW, &ttyb);
|
|
return (fd);
|
|
}
|
|
|
|
|
|
/*
|
|
* sndpkt(r, x, y) - send packet and receive response
|
|
*
|
|
* This routine sends a command frame, which consists of all except the
|
|
* preamble octets PR-PR. 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 2 and the RE and TX 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
|
|
* flags variable, prints all characters received or echoed on the bus
|
|
* preceded by a T (transmit) or R (receive). The P_ERMSG bit of the
|
|
* flags variable enables printing of bus error messages.
|
|
*
|
|
* Note that the first octet sent is a PAD 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.
|
|
*/
|
|
static int
|
|
sndpkt( /* returns octet count */
|
|
int fd, /* file descriptor */
|
|
int r, /* radio address */
|
|
u_char *cmd, /* command vector */
|
|
u_char *rsp /* response vector */
|
|
)
|
|
{
|
|
int i, j, temp;
|
|
|
|
(void)tcflush(fd, TCIOFLUSH);
|
|
for (i = 0; i < RETRY; i++) {
|
|
state = S_IDLE;
|
|
|
|
/*
|
|
* Transmit packet.
|
|
*/
|
|
if (flags & P_TRACE)
|
|
printf("icom T:");
|
|
sndoctet(fd, PAD); /* send header */
|
|
sndoctet(fd, PR);
|
|
sndoctet(fd, PR);
|
|
sndoctet(fd, r);
|
|
sndoctet(fd, TX);
|
|
for (j = 0; j < BMAX; j++) { /* send body */
|
|
if (sndoctet(fd, cmd[j]) == FI)
|
|
break;
|
|
}
|
|
while (rcvoctet(fd) != FI); /* purge echos */
|
|
if (cmd[0] == V_FREQT || cmd[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 (flags & P_TRACE)
|
|
printf("\nicom R:");
|
|
j = 0;
|
|
while ((temp = rcvoctet(fd)) != 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 (flags & P_ERMSG)
|
|
printf(
|
|
"icom: TX error\n");
|
|
state = S_ERROR;
|
|
}
|
|
state = S_TX;
|
|
break;
|
|
|
|
case S_TX:
|
|
if (temp != r) {
|
|
if (flags & P_ERMSG)
|
|
printf(
|
|
"icom: RE error\n");
|
|
state = S_ERROR;
|
|
}
|
|
state = S_DATA;
|
|
break;
|
|
|
|
case S_DATA:
|
|
if (j >= BMAX ) {
|
|
if (flags & P_ERMSG)
|
|
printf(
|
|
"icom: buffer overrun\n");
|
|
state = S_ERROR;
|
|
j = 0;
|
|
}
|
|
rsp[j++] = (u_char)temp;
|
|
break;
|
|
|
|
case S_ERROR:
|
|
break;
|
|
}
|
|
}
|
|
if (flags & P_TRACE)
|
|
printf("\n");
|
|
if (j > 0) {
|
|
rsp[j++] = FI;
|
|
return (j);
|
|
}
|
|
}
|
|
if (flags & P_ERMSG)
|
|
printf("icom: 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.
|
|
*/
|
|
/*
|
|
* sndoctet(fd, x) - send octet
|
|
*/
|
|
static int
|
|
sndoctet( /* returns octet */
|
|
int fd, /* file descriptor */
|
|
int x /* octet */
|
|
)
|
|
{
|
|
u_char y;
|
|
|
|
y = (u_char)x;
|
|
write(fd, &y, 1);
|
|
return (x);
|
|
}
|
|
|
|
|
|
/*
|
|
* rcvoctet(fd) - receive octet
|
|
*/
|
|
static int
|
|
rcvoctet( /* returns octet */
|
|
int fd /* file descriptor */
|
|
)
|
|
{
|
|
u_char y;
|
|
|
|
if (read(fd, &y, 1) < 1)
|
|
y = FI; /* come here if timeout */
|
|
if (flags & P_TRACE && y != PAD)
|
|
printf(" %02x", y);
|
|
return (y);
|
|
}
|
|
|
|
/* end program */
|