Return to icom.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / libntp

Annotation of embedaddon/ntp/libntp/icom.c, revision 1.1.1.1

1.1       misho       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 <config.h>
                      9: #include "icom.h"
                     10: #include <unistd.h>
                     11: #include <stdio.h>
                     12: #include <fcntl.h>
                     13: #include <errno.h>
                     14: 
                     15: #include "ntp_tty.h"
                     16: #include "l_stdlib.h"
                     17: 
                     18: #ifdef SYS_WINNT
                     19: #undef write   /* ports/winnt/include/config.h: #define write _write */
                     20: extern int async_write(int, const void *, unsigned int);
                     21: #define write(fd, data, octets)        async_write(fd, data, octets)
                     22: #endif
                     23: 
                     24: /*
                     25:  * Packet routines
                     26:  *
                     27:  * These routines send a packet and receive the response. If an error
                     28:  * (collision) occurs on transmit, the packet is resent. If an error
                     29:  * occurs on receive (timeout), all input to the terminating FI is
                     30:  * discarded and the packet is resent. If the maximum number of retries
                     31:  * is not exceeded, the program returns the number of octets in the user
                     32:  * buffer; otherwise, it returns zero.
                     33:  *
                     34:  * ICOM frame format
                     35:  *
                     36:  * Frames begin with a two-octet preamble PR-PR followyd by the
                     37:  * transceiver address RE, controller address TX, control code CN, zero
                     38:  * or more data octets DA (depending on command), and terminator FI.
                     39:  * Since the bus is bidirectional, every octet output is echoed on
                     40:  * input. Every valid frame sent is answered with a frame in the same
                     41:  * format, but with the RE and TX fields interchanged. The CN field is
                     42:  * set to NAK if an error has occurred. Otherwise, the data are returned
                     43:  * in this and following DA octets. If no data are returned, the CN
                     44:  * octet is set to ACK.
                     45:  *
                     46:  *     +------+------+------+------+------+--//--+------+
                     47:  *     |  PR  |  PR  |  RE  |  TX  |  CN  |  DA  |  FI  |
                     48:  *     +------+------+------+------+------+--//--+------+
                     49:  */
                     50: /*
                     51:  * Scraps
                     52:  */
                     53: #define DICOM /dev/icom/       /* ICOM port link */
                     54: 
                     55: /*
                     56:  * Local function prototypes
                     57:  */
                     58: static void doublefreq         (double, u_char *, int);
                     59: 
                     60: 
                     61: /*
                     62:  * icom_freq(fd, ident, freq) - load radio frequency
                     63:  */
                     64: int
                     65: icom_freq(                     /* returns 0 (ok), EIO (error) */
                     66:        int fd,                 /* file descriptor */
                     67:        int ident,              /* ICOM radio identifier */
                     68:        double freq             /* frequency (MHz) */
                     69:        )
                     70: {
                     71:        u_char cmd[] = {PAD, PR, PR, 0, TX, V_SFREQ, 0, 0, 0, 0, FI,
                     72:            FI};
                     73:        int temp;
                     74: 
                     75:        cmd[3] = (char)ident;
                     76:        if (ident == IC735)
                     77:                temp = 4;
                     78:        else
                     79:                temp = 5;
                     80:        doublefreq(freq * 1e6, &cmd[6], temp);
                     81:        temp = write(fd, cmd, temp + 7);
                     82: 
                     83:        return (0);
                     84: }
                     85: 
                     86: 
                     87: /*
                     88:  * doublefreq(freq, y, len) - double to ICOM frequency with padding
                     89:  */
                     90: static void
                     91: doublefreq(                    /* returns void */
                     92:        double freq,            /* frequency */
                     93:        u_char *x,              /* radio frequency */
                     94:        int len                 /* length (octets) */
                     95:        )
                     96: {
                     97:        int i;
                     98:        char s1[16];
                     99:        char *y;
                    100: 
                    101:        snprintf(s1, sizeof(s1), " %10.0f", freq);
                    102:        y = s1 + 10;
                    103:        i = 0;
                    104:        while (*y != ' ') {
                    105:                x[i] = *y-- & 0x0f;
                    106:                x[i] = x[i] | ((*y-- & 0x0f) << 4);
                    107:                i++;
                    108:        }
                    109:        for ( ; i < len; i++)
                    110:                x[i] = 0;
                    111:        x[i] = FI;
                    112: }
                    113: 
                    114: /*
                    115:  * icom_init() - open and initialize serial interface
                    116:  *
                    117:  * This routine opens the serial interface for raw transmission; that
                    118:  * is, character-at-a-time, no stripping, checking or monkeying with the
                    119:  * bits. For Unix, an input operation ends either with the receipt of a
                    120:  * character or a 0.5-s timeout.
                    121:  */
                    122: int
                    123: icom_init(
                    124:        char *device,           /* device name/link */
                    125:        int speed,              /* line speed */
                    126:        int trace               /* trace flags */       )
                    127: {
                    128:        TTY ttyb;
                    129:        int fd;
                    130:        int flags;
                    131:        int rc;
                    132:        int saved_errno;
                    133: 
                    134:        flags = trace;
                    135:        fd = tty_open(device, O_RDWR, 0777);
                    136:        if (fd < 0)
                    137:                return -1;
                    138: 
                    139:        rc = tcgetattr(fd, &ttyb);
                    140:        if (rc < 0) {
                    141:                saved_errno = errno;
                    142:                close(fd);
                    143:                errno = saved_errno;
                    144:                return -1;
                    145:        }
                    146:        ttyb.c_iflag = 0;       /* input modes */
                    147:        ttyb.c_oflag = 0;       /* output modes */
                    148:        ttyb.c_cflag = IBAUD|CS8|CLOCAL; /* control modes  (no read) */
                    149:        ttyb.c_lflag = 0;       /* local modes */
                    150:        ttyb.c_cc[VMIN] = 0;    /* min chars */
                    151:        ttyb.c_cc[VTIME] = 5;   /* receive timeout */
                    152:        cfsetispeed(&ttyb, (u_int)speed);
                    153:        cfsetospeed(&ttyb, (u_int)speed);
                    154:        rc = tcsetattr(fd, TCSANOW, &ttyb);
                    155:        if (rc < 0) {
                    156:                saved_errno = errno;
                    157:                close(fd);
                    158:                errno = saved_errno;
                    159:                return -1;
                    160:        }
                    161:        return (fd);
                    162: }
                    163: 
                    164: /* end program */