serial_cmd.c

Go to the documentation of this file.

#include "edtinc.h"

#define SERBUFSIZE 512

/* prototypes */
void    print_ascii_string(char *buf);
long    MainHelp(int argc, char *argv[], char *edt_devname);
long    PdvDispatch(int argc, char *argv[], char *edt_devname);
long
PdvSerialWriteRead(int argc, char *argv[], int unit, int hexin,
                   int do_wait, int inter, int timeout, int verbose,
                   int foiunit, int baud, int readonly, int channel);
    long    isascii_str(u_char *buf, int n);
    long    ack_nak_str(u_char *buf, int n);

    int
            print_inter_help()
{
    puts("");
    puts("EDT serial_cmd, interactive mode help");
    puts("");
    puts("Enter any command that is valid for the camera. For example, to get camera");
    puts("status from a Kodak MEGAPLUS camera, type in STS? then press ENTER.");
    puts("");
    puts("If you don't get responses from query commands, make sure the camera is");
    puts("configured for RS-422 control. Kodak MEGAPLUS cameras may be factory");
    puts("configured for either RS-232 or RS-422 control, and must be switched");
    puts("to RS-422 to work with the EDT interface.");
    puts("");
    puts("See your camera users guide for control options and valid commands.");
    puts("Run \"serial_cmd -h\" for command line options.");
    puts("");
    return 0;
}

int pnum=0;
void
printify(u_char *buf, u_char *dest, int n, int show_nonprint)

{
    int     has_lf = FALSE;
    int     i, j;

    for (i = 0; i < n; i++)
    {
        if (buf[i] == 10)
            has_lf = TRUE;
    }

    for (i = 0, j = 0; i < n; i++)
    {

        if (buf[i] == 13)
        {
            if (!has_lf)
                dest[j++] = '\n';
        }
        else if (buf[i] == 10 || (buf[i] >= ' ' && buf[i] < 127))
            dest[j++] = buf[i];
        else if (show_nonprint)
        {
            switch (buf[i])
            {
            case 0x06:
                strcpy((char *) dest + j, "<ACK>");
                break;
            case 0x15:
                strcpy((char *) dest + j, "<NAK>");
                break;
            case 0x02:
                strcpy((char *) dest + j, "<STX>");
                break;
            case 0x03:
                strcpy((char *) dest + j, "<ETX>");
                break;
            default:
                sprintf((char *) dest + j, "<%02x>", buf[i]);
            }

            j = strlen((char *) dest);

        }

        dest[j] = 0;
    }


}

int     basler_framing = 0;
int     duncan_framing = 0;

#ifdef NO_MAIN
#include "opt_util.h"
char *argument ;
int option ;
int
serial_cmd(char *command_line)
#else
int
main(int argc, char **argv)
#endif
{
    long    status;             /* return status from command */
    int     unit = 0;
    int     hexin = 0;
    int     inter = 0;
    int     verbose = 0;
    int     do_wait = 0;
    int     timeout = 0;
    int     foiunit = -1;
    int     channel = 0;
    int     readonly = 0;
    int     baud = 0;
#ifdef NO_MAIN
    char **argv  = 0 ;
    int argc = 0 ;
    opt_create_argv("serial_cmd",command_line,&argc,&argv);
#endif

    --argc;
    ++argv;
    while ((argc > 0) && ((argv[0][0] == '-') || (argv[0][0] == '/')))
    {
        switch (argv[0][1])
        {
        case 'u':               /* device unit number */
            ++argv;
            --argc;
            if (argc < 1) {
                fprintf(stderr, "Error: option 'u' requires argument\n");
                MainHelp(argc, argv, NULL);
                exit(1);
            }
            if ((argv[0][0] >= '0') && (argv[0][0] <= '9'))
                unit = atoi(argv[0]);
            break;

        case 'x':  
            hexin = 1; /* command input is in hex */
            break;

        case 'w':
            do_wait = 1;  /* asks user before proceeding with read */
            break;

        case 't':
            ++argv;
            --argc;
            if (argc < 1) {
                fprintf(stderr, "Error: option 't' requires argument\n");
                MainHelp(argc, argv, NULL);
                exit(1);
            }
            if ((argv[0][0] >= '0') && (argv[0][0] <= '9'))
                timeout = atoi(argv[0]);
            break;

        case 'b':
            ++argv;
            --argc;
            if (argc < 1) {
                fprintf(stderr, "Error: option 'b' requires argument\n");
                MainHelp(argc, argv, NULL);
                exit(1);
            }
            baud = atoi(argv[0]);
            break;

        case 'v':
            verbose = 1;
            break;

        case '-':
            if (strcmp(argv[0], "--help") == 0) {
                MainHelp(argc, argv, NULL);
                exit(0);
            } else {
                fprintf(stderr, "unknown option: %s\n", argv[0]);
                MainHelp(argc, argv, NULL);
                exit(1);
            }
            break;

        case 'h':
        case '?':
            MainHelp(argc, argv, NULL);
            exit(0);
            break;

        case 'r':
            readonly = 1;
            break;
        case 'f':
            ++argv;
            --argc;
            if (argc < 1)
            {
                fprintf(stderr, "Error - foi unit # expected\n");
                exit(-1);
            }
            foiunit = atoi(argv[0]);
            break;

        case 'c':
            ++argv;
            --argc;
            if (argc < 1)
            {
                fprintf(stderr, "Error - channel # expected\n");
                exit(-1);
            }
            channel = atoi(argv[0]);
            break;

        case 'B':
            basler_framing = 1;
            break;

        case 'D':
            duncan_framing = 1;
            break;

        default:
            fprintf(stderr, "unknown flag -'%c'\n", argv[0][1]);
            MainHelp(argc, argv, NULL);
            exit(1);
            break;
        }
        argc--;
        argv++;
    }

    if ((argc < 1) && !readonly)
        inter = 1;

    if (readonly && (timeout == 0))
        timeout = 60000;

    status = PdvSerialWriteRead(argc, argv, unit, hexin, do_wait, inter,
                        timeout, verbose, foiunit, baud, readonly, channel);
#ifndef NO_MAIN
    exit(status);
#endif
    return (0);
}

long
MainHelp(int argc, char *argv[], char *edt_devname)
{
    printf("Usage:   serial_cmd [-h | -?] [-u unit] [-x] [\"cmd\"]\n");
    printf(
           "    -?, /?, -h      - Help message\n"
           "    --help          - Help message\n"
           "    -u N            - Unit number (default 0)\n"
           "    -f N            - FOI (fiber optic remote) unit #\n"
           "    -c N            - channel #\n"
           "    -b baud         - Set baud rate\n"
           "    -v              - Verbose\n"
           "    -w              - Wait before read\n"
           "    -r              - Read only\n"
           "    -t              - Serial timeout override value\n"
           "    -B              - Basler framing mode -- cmd should be hex cmd (bytes separated by\n"
           "    -D              - Duncan framing mode -- cmd should be hex cmd (bytes separated by\n"
           "                      spaces, with NO framing info (serial_cmd will add STX and Checksum)\n"
           "    -x              - Hex mode -- cmd should be hex bytes separared by spaces\n"
       "   \"cmd\"            - ASCII (default) or hex command(s) to send\n"
        );
    return 0;
}


long
PdvSerialWriteRead(int argc, char *argv[], int unit, int hexin,
              int do_wait, int inter, int timeout, int verbose, int foiunit,
                   int baud, int readonly, int channel)
{
    int     i;
    int     ret;
    int     nbytes;
    int     length;
    u_char  hbuf[SERBUFSIZE];
    char    tmpbuf[SERBUFSIZE];
    char    getbuf[SERBUFSIZE];
    char    *ibuf_p;
    u_char  lastbyte, waitc;
    char    buf[SERBUFSIZE];
    char    bs[32][3];
    EdtDev *ed;

    /* open a handle to the device     */
    ed = pdv_open_channel(EDT_INTERFACE, unit, channel);
    if (ed == NULL)
    {
        pdv_perror(EDT_INTERFACE);
        return -1;
    }

    if (timeout < 1)
        timeout = ed->dd_p->serial_timeout;

    if (verbose)
        printf("serial timeout %d\n", timeout);

    if (foiunit >= 0)
    {
        /* edt_foi_autoconfig(ed) ; */
        edt_set_foiunit(ed, foiunit);
        edt_set_rci_dma(ed, foiunit, 0);
    }

    if (inter)
    {
        ibuf_p = getbuf;
        printf("\nEnter command (Ctrl-C to quit)\n\n");
    }
    else
        ibuf_p = argv[0];

    if (baud)
    {
        pdv_set_baud(ed, baud);
    }


    /* flush any junk */
    (void) pdv_serial_read(ed, buf, SERBUFSIZE);

    do
    {
        if (inter)
        {
            printf("> ");
            fgets(ibuf_p,SERBUFSIZE-1,stdin);
        }

        if (!readonly)
        {
            if (hexin)
            {
                nbytes = sscanf(ibuf_p, "%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",
                     bs[0], bs[1], bs[2], bs[3], bs[4], bs[5], bs[6], bs[7],
                                bs[8], bs[9], bs[10], bs[11], bs[12], bs[13], bs[14], bs[15]);

                /*
                 * change 5/28/99 one serial_binary_command for the whole
                 * thing -- before it did one write per byte which was dumb
                 * and didn't work on FOI anyway
                 */
                for (i = 0; i < nbytes; i++)
                {
                    if (strlen(bs[i]) > 2)
                    {
                        printf("hex string format error\n");
                        break;
                    }
                    hbuf[i] = (u_char) (strtoul(bs[i], NULL, 16) & 0xff);

                }

                /*
                 * using pdv_serial_binary_command instead of
                 * pdv_serial_write because it prepends a 'c' if FOI
                 */
                pdv_serial_binary_command(ed, (char *) hbuf, nbytes);
                /* edt_msleep(10000); */
            }
            else if (duncan_framing)
            {
                nbytes = sscanf(ibuf_p, "%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",
                     bs[0], bs[1], bs[2], bs[3], bs[4], bs[5], bs[6], bs[7],
                                bs[8], bs[9], bs[10], bs[11], bs[12], bs[13], bs[14], bs[15]);

                for (i = 0; i < nbytes; i++)
                {
                    if (strlen(bs[i]) > 2)
                    {
                        printf("duncan command format error\n");
                        break;
                    }
                    hbuf[i] = (u_char) (strtoul(bs[i], NULL, 16) & 0xff);
                }

                pdv_send_duncan_frame(ed, hbuf, nbytes);
                /* edt_msleep(10000); */
            }
            else if (basler_framing)
            {
                nbytes = sscanf(ibuf_p, "%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",
                     bs[0], bs[1], bs[2], bs[3], bs[4], bs[5], bs[6], bs[7],
                                bs[8], bs[9], bs[10], bs[11], bs[12], bs[13], bs[14], bs[15]);

                for (i = 0; i < nbytes; i++)
                {
                    if (strlen(bs[i]) > 2)
                    {
                        printf("basler command format error\n");
                        break;
                    }
                    hbuf[i] = (u_char) (strtoul(bs[i], NULL, 16) & 0xff);
                }

                pdv_send_basler_frame(ed, hbuf, nbytes);
                /* edt_msleep(10000); */
            }
            else
            {
                sprintf(tmpbuf, "%s\r", ibuf_p);
                if (verbose)
                    printf("writing <%s>\n", ibuf_p);
                pdv_serial_command(ed, tmpbuf);
            }
        }

        /*
         * serial_timeout comes from the config file (or -t override flag in
         * this app), or if not present defaults to 500 unless readonly
         * defaults to 60000
         */
        if (duncan_framing)
        {
            ret = pdv_read_duncan_frame(ed, (u_char *)buf);
            printf("resp <");
            for (i = 0; i < ret; i++)
                printf("%02x%s", (u_char)buf[i], (i == ret-1)? ">\n" : " ");
        }
        else
        {

            pdv_serial_wait(ed, timeout, 64);

            if (do_wait)
            {
                printf("return to read response: ");
                getchar();
            }

            /*
             * read and print the response. Could be large or small so loop
             * no more characters (OR waitchar seen, if any). Format output
             * for 1) ASCII, 2) HEX, or 3) Pulnix STX/ETX format, as
             * appropriate
             */
            do
            {
                ret = pdv_serial_read(ed, buf, SERBUFSIZE);
                if (verbose)
                    printf("read returned %d\n", ret);

                if (*buf)
                    lastbyte = (u_char)buf[strlen(buf)-1];

                if (ret != 0)
                {
                    buf[ret + 1] = 0;
                    if (hexin || basler_framing || duncan_framing)
                    {
                        int     i;

                        if (ret)
                        {
                            printf("resp <");
                            for (i = 0; i < ret; i++)
                                printf("%s%02x", i ? " " : "", (u_char) buf[i]);
                            printf(">\n");
                        }
                    }
                    else                /* simple ASCII */
                        print_ascii_string(buf);
                    length += ret;
                }

                if (ed->devid == PDVFOI_ID)
                    ret = pdv_serial_wait(ed, 500, 0);
                else if (pdv_get_waitchar(ed, &waitc) && (lastbyte == waitc))
                    ret = 0; /* jump out if waitchar is enabled/received */
                else ret = pdv_serial_wait(ed, 500, 64);
            } while (ret > 0);
        }

        printf("\n");

    } while (inter);

    pdv_close(ed);

    return (1);
}

/*
 * print ascii string. Replace \r or Ctrl-M with \n for consistency and
 * pretty printing
 */
void
print_ascii_string(char *buf)
{
#if 0
    int     i = 0;
    char   *p = buf;
#endif
    char    tmpbuf[SERBUFSIZE];

    printify((u_char *) buf, (u_char *) tmpbuf, strlen(buf), 1);

#if 0

    while (*p)
    {
        if ((*p == '\r' || *p == '\n')
            && (p != buf) && (*(p - 1) != '\n') && (*(p + 1) != '\n'))
            tmpbuf[i++] = '\n';
        else
            tmpbuf[i++] = *p;
        ++p;
    }
    if (tmpbuf[i - 1] != '\n')
        tmpbuf[i++] = '\n';
    tmpbuf[i] = '\0';

#endif
    fputs(tmpbuf, stdout);
    fflush(stdout);
}

long
isascii_str(u_char * buf, int n)
{
    int     i;

    for (i = 0; i < n; i++)
        if ((buf[i] < ' ' || buf[i] > '~')
            && (buf[i] != '\t')
            && (buf[i] != '\n')
            && (buf[i] != '\r'))
            return 0;
    return 1;
}

long
ack_nak_str(u_char *buf, int n)
{
    int     i;

    /* check for all ASCII between the 1st and last chars, or ACK or NAK */
    for (i = 0; i < n; i++)
        if ((buf[i] < ' ' || buf[i] > '~')
            && (buf[i] != 0x15) /* NAK */
            && (buf[i] != 0x6)  /* ACK */
            && (buf[i] != '\n') /* LF */
            && (buf[i] != '\r'))/* CR */
            return 0;
    return 1;
}

---