---

di_test.c

Go to the documentation of this file.

#include "di194.h"

// Global boolean used for control-break
bool do_exit;

typedef enum commands_e 
{
    DI_HELP,
    DI_START,
    DI_STOP,
    DI_READ,
    DI_READ_SINGLE,
    DI_RESET,
    DI_PROGRAM,
    DI_QUIT,
    DI_SERIAL,
    DI_FLUSH,
    DI_EMPTY_CMD,
    DI_INVALID_CMD
} commands_t;

typedef struct command_entry_s 
{
    char       *command;
    char       *info;
    char       *usage;
    commands_t cmd;
} command_entry_t;

command_entry_t    commands[] = 
{
    {
        "help",        "help",       "help command ENTER", DI_HELP
    },
    {
        "start",       "start DAQ",  "start ENTER", DI_START
    },
    {
        "stop",        "stop DAQ",   "stop ENTER", DI_STOP
    },
    {
        "read",        "read once",  "read ENTER", DI_READ
    },
    {
        "single",      "read a single value", "single ENTER", DI_READ_SINGLE
    },
    {
        "reset",       "reset unit", "reset ENTER", DI_RESET
    },
    {
        "prog",        "program unit", "prog ENTER", DI_PROGRAM
    },
    {
        "serial",      "read serial number", "serial ENTER", DI_SERIAL
    },
    {
        "flush",       "flush port buffers", "flush ENTER", DI_FLUSH
    },
    {
        "quit",        "quit program",  "quit ENTER", DI_QUIT
    }
    
};


#define CMD_TABLE_SIZE (sizeof(commands) / sizeof(command_entry_t))

// ---------------------------------------------------------------------
int user_loop(const int COMM_FD)
{
    int           rc, idx;
    char          cmd_buf[BUFSIZ] = "";
    const char    prompt[] = "di-194> ";
    char          *input = NULL;
    bool          done = false;
    commands_t    cmd = DI_INVALID_CMD;
    daq_reading_t data;
    char          ser_buf[SERIAL_NUM_LEN + 1] = "";
    int           num_bits = 8;

    // Valid file descriptor?
    if(COMM_FD <= 0)
        return(-1);

    while((!done) && (!do_exit))
    {
        printf(prompt);
        
        input = fgets(cmd_buf, (BUFSIZ - 1), stdin);
        if(input == NULL)
            continue;

        input = strtok(cmd_buf, " \t\n");
        if(input != NULL)
        {
            // search command table
            for(idx = 0; idx < CMD_TABLE_SIZE && 
                    strcmp(input, commands[idx].command) != 0; idx++);
            
            if(idx >= CMD_TABLE_SIZE)
            {
                cmd = DI_INVALID_CMD;
            }
            else
            {
                cmd = commands[idx].cmd;
            }
        }
        else // Null command
            cmd = DI_EMPTY_CMD;
    
        // Dispatch it
        switch(cmd)
        {
          case DI_QUIT:
            done = true;
            break;
        
          case DI_EMPTY_CMD:
            break;
        
          case DI_INVALID_CMD:
          default:
            printf("Invalid command. Type 'help' for valid commands.\n");
            break;
        
          case DI_HELP:
            input = strtok(NULL, " \t\n");
            if(input != NULL)
            {
                for(idx = 0; idx < CMD_TABLE_SIZE && 
                        strcmp(input, commands[idx].command) != 0; idx++);

                if(idx >= CMD_TABLE_SIZE)
                    printf("No such command\n");
                else
                {
                    printf("%s\t\t%s\n\tUsage: %s\n", 
                           commands[idx].command,
                           commands[idx].info, 
                           commands[idx].usage);
                }
            
            }
            else  // Just plain help; dump table
            {
                for(idx = 0; idx < CMD_TABLE_SIZE; idx++)
                {
                    printf("%s:\t\t%s\n", 
                           commands[idx].command, commands[idx].info);
                }
                printf("\nFor help on a specific command,");
                printf(" type 'help <command>'\n");
            }
            break;
        
          case DI_START:
            rc = di_start(COMM_FD);
            if(rc != 0)
                printf("Error %d on start command\n", rc);
            else
                printf("Started OK.\n");
        
            break;
        
          case DI_STOP:
            rc = di_stop(COMM_FD);
            if(rc != 0)
                printf("Error %d on stop command\n", rc);
            else
                printf("Stopped OK.\n");

            break;

          case DI_READ:
            // DDT
            di_daq_sync(COMM_FD);
            
            rc = di_read(COMM_FD, &data, num_bits);
            if(rc != 0)
            {
                printf("Error %d on read\n", rc);
                break;
            }
        
            // got data!
            printf("A0: %5.2f %5.2f %5.2f %5.2f",
                   data.analog[0],
                   data.analog[1],
                   data.analog[2],
                   data.analog[3]);
            printf("\nD0: %1d %1d %1d\n",
                   data.digital[0],
                   data.digital[1],
                   data.digital[2]);

            break;
          case DI_READ_SINGLE:
            rc = di_read_single(COMM_FD, &data, num_bits);
            if(rc != 0)
            {
                printf("Error %d on read\n", rc);
                break;
            }
        
            // got data!
            printf("A0: %5.2f %5.2f %5.2f %5.2f",
                   data.analog[0],
                   data.analog[1],
                   data.analog[2],
                   data.analog[3]);
            printf("\nD0: %1d %1d %1d\n",
                   data.digital[0],
                   data.digital[1],
                   data.digital[2]);
            break;
            
          case DI_SERIAL:
            rc = di_serial_num(COMM_FD, ser_buf);
            if(rc != 0)
            {
                printf("Error %d reading serial number\n", rc);
                break;
            }
            
            printf("DI-194 serial number: '");
            
            for(idx = 0; idx < SERIAL_NUM_LEN; idx++)
                printf("%c", ser_buf[idx]);
            printf("'\n");
            break;

          case DI_FLUSH:
            tcflush(COMM_FD, TCIOFLUSH);
            printf("Done.\n");
            break;
            
          case DI_RESET:
            rc = di_reset(COMM_FD);
            if(rc != 0)
            {
                printf("Error %d on reset\n", rc);
                break;
            }
            else
                printf("Reset OK.\n");
            break;
        
          case DI_PROGRAM:
            rc = di_configure(COMM_FD);
            if(rc != 0)
            {
                printf("Error %d on reprogram\n", rc);
                break;
            }
            else
                printf("Reprogrammed OK\n");
            break;
        }
    }
    
    printf("Closing down DI-194\n");
    
    di_stop(COMM_FD);
    di_close(COMM_FD);
    
    printf("Done, exiting\n");
    return(0);
}
    
// ---------------------------------------------------------------------
void sighandler(int signal)
{
    char    me[] = "sighandler";

    fprintf(stderr, "\n%s: Got signal %d, exiting\n", me, signal);
    fflush(stderr);
    
    do_exit = true;

    return;
}

//***********************************************************************
int main(int argc, char *argv[])
{
    char          me[] = "main";
    FILE          *fHandle = NULL;
    int           comm_fd = -1;
    int           num_bits = 0;


    // Try new routines!
    comm_fd = di_open(getenv("DI194_PORT"), &num_bits);
    if(comm_fd <= 0)
    {
        fprintf(stderr, "\n%s: Error %d opening device",
                me, comm_fd);
        return(1);
    }

    // If supplied one arg, use as data file name
    if(argc == 2)
    {
        fHandle = fopen(argv[1], "w");

        if(fHandle == NULL)
            fprintf(stderr, "\n%s: unable to open %s for output",
         me, argv[1]);
    }
        
    printf("Installing signal handler.\n");
    do_exit = false;
    signal(SIGINT, sighandler);

    // Call main routine
    return(user_loop(comm_fd));
}

---