---

di194.c

Go to the documentation of this file.

#include "di194.h"
#include "di194-internal.h"

bool do_exit;


// ---------------------------------------------------------------------
int di_serial_close(const int COMM_FD)
{
    if(COMM_FD > 0)
    {
        return(close(COMM_FD));
    }
    else
        return(-1);
}

    
// ---------------------------------------------------------------------
int di_serial_init(const char *COMPORT_FILE)
{
    char            me[] = "di_serial_init";
    struct termios  term;
    int             comm_fd = -1;
    const int       baud_rate = B4800;
        
    /* Open the comport, R/W access required */
    comm_fd = open(COMPORT_FILE, O_RDWR);
        
    /* Exit if could not open the comport */
    if(comm_fd < 0)
    {
        fprintf(stderr,
                "\n%s: Could not open port %s\n",
                me, COMPORT_FILE);
        perror("open");
        return(comm_fd);
    }

    // Read current serial flags / setup
    tcgetattr(comm_fd ,&term);

    // Control flags
    term.c_cflag &= ~CSIZE;
    term.c_cflag |= CS8;
    term.c_cflag |= HUPCL;
    term.c_cflag |= CREAD;
    term.c_cflag &= ~CRTSCTS;
    term.c_cflag |= IXON;

    // Output flags
    term.c_oflag &= ~OPOST;
        
    // Input flags
    term.c_iflag = IGNBRK|IGNPAR;
        
    // Que esta?
    term.c_lflag = 0;
        
    // Misc flags
    term.c_cc[VMIN] = 0;
    term.c_cc[VTIME] = (serial_timeout * 10);  // spec'd in deciseconds

    // Set input and output to 4800 baud
    cfsetispeed(&term, baud_rate);
    cfsetospeed(&term, baud_rate);

    /* Turn on the control lines */
    tcsetattr(comm_fd, TCSANOW, &term);

    // Wait for DI-194 to wake up?
    usleep(25000);

    /* Turn off the control lines */
    cfsetispeed(&term, B0);
    cfsetospeed(&term, B0);
    tcsetattr(comm_fd, TCSANOW, &term);

    /* Turn on the control lines */
    cfsetospeed(&term, baud_rate);
    tcsetattr(comm_fd, TCSANOW, &term);

    // Wait for DI-194 to wake up?
    usleep(25000);

    // Empty out any junk in the serial buffers
    tcflush(comm_fd, TCIOFLUSH);

    return(comm_fd);
}

// ---------------------------------------------------------------------
int min(const int A, const int B)
{
    return(A < B? A : B);
}

// ---------------------------------------------------------------------
void hex_print_byte(const uint8_t in_byte)
{
    printf("%02X ", (int) in_byte);
    if(isprint(in_byte))
        printf("(%c)", in_byte);
}

int di_stop(const int COMM_FD)
{
    return(di_cmd_send(COMM_FD, stop_cmd, sizeof(stop_cmd)));
}


int di_start(const int COMM_FD)
{
    return(di_cmd_send(COMM_FD, start_cmd, sizeof(start_cmd)));
}

int di_reset(const int COMM_FD)
{
    return(di_cmd_send(COMM_FD, rst_cmd, sizeof(rst_cmd)));
}

int di_serial_num(const int COMM_FD, char *ser_buf)
{
    char    me[] = "di_serial";
    int     rc, idx;
    
    rc = di_cmd_send(COMM_FD, sn_cmd, sizeof(sn_cmd));
    if(rc != 0)
    {
        fprintf(stderr,
                "\nError sending serial number request, rc=%d\n", rc);
        return(1);
    }

    // Receive 10 bytes of serial number, or timeout
    rc = di_serial_read(COMM_FD, ser_buf, SERIAL_NUM_LEN, serial_timeout);
    if(rc != 0)
    {
        // Error, bail
        fprintf(stderr, "\n%s: Error reading serial number", me);

        if(rc >= 1)
        {
            fprintf(stderr, "\n%s: Data received was '", me);
            for(idx = 0; idx < rc; idx++)
                fprintf(stderr, "%02X ",
                        (int) ser_buf[idx]);
            fprintf(stderr, "'\n");
        }
        return(2);
    }
    
    return(0);
}


// ---------------------------------------------------------------------  
int di_serial_read(const int COMM_FD, const uint8_t *buf,
                   const int READ_LEN, const time_t TIMEOUT)
{
    char       me[] = "di_serial_read";
    time_t     t_start;
    int        rc;
    int        rx_count = 0;

    t_start = time(NULL);

    // Read until timeout or get the data amount requested
    while(((time(NULL) - t_start) < TIMEOUT) &&
          (rx_count < READ_LEN))
    {
        // Try and get all of the remaining data at once
        rc = read(COMM_FD, (uint8_t *) &buf[rx_count],
                  (READ_LEN - rx_count));
        if(rc < 0)
        {
            // Read error
            fprintf(stderr, "\n%s: Error on read, rc=%d", me, rc);
            return(1);
        }
        if(rc == 0)
        {
            // No data yet, wait half a character time
            usleep(100);
        }
        else // rc > 0, got data
            rx_count += rc;
    }

    // Are we done
    if(rx_count >= READ_LEN)
        return(0);
    else
    {
        fprintf(stderr, "\n%s: Short read, got %d of %d expected",
                me, rx_count, READ_LEN);
        fprintf(stderr, ", elapsed was %u seconds",
                (uint32_t) (time(NULL) - t_start));

        if(rx_count != 0)
            return(rx_count);
        else
            return(-1);
    }
}

// ---------------------------------------------------------------------
void di_cmd_print(const uint8_t *cmd, const int CMD_LEN)
{
    char    me[] = "di_cmd_print";
    int     idx;

    if(CMD_LEN > 1)
        fprintf(stderr, "\n%s: %d-byte command '", me, CMD_LEN);
    else if(CMD_LEN == 1)
        fprintf(stderr, "\n%s: 1-byte argument '", me);
    else
    {
        fprintf(stderr, "\n%s: Error, invalid cmd length %d",
                me, CMD_LEN);
        return;
    }
                        
    for(idx = 0; idx < CMD_LEN; idx++)
    {
        fprintf(stderr, " %02X", (int) cmd[idx]);
                
        if(isprint(cmd[idx]))
            fprintf(stderr, " (%c)", cmd[idx]);
    }

    fprintf(stderr, "'");
    return;
}

// ---------------------------------------------------------------------
bool is_reset_cmd(const uint8_t *cmd, const int CMD_LEN)
{
    char    me[] = "is_reset_cmd";
    int     idx;

    // Simple checks
    if((CMD_LEN != 3) || (cmd == NULL))
        return(false);

    for(idx = 0; idx < CMD_LEN; idx++)
        if(cmd[idx] != rst_cmd[idx])
            return(false);
        
    return(true);

    // intentionally unreachable code
    fprintf(stderr, "\n%s: Reset command found", me);
}

// ---------------------------------------------------------------------
int di_daq_sync(const int COMM_FD)
{
    char            me[] = "di_daq_sync";
    uint8_t         sync_buf[5 * sizeof(daq_buf_t)] = "";
    int             idx, rc, clear_count;
    bool            found_match = false;

        
    // Get three samples' worth of serial data, plus slop
    rc = di_serial_read(COMM_FD, sync_buf, (4 * sizeof(daq_buf_t)),
                        serial_timeout);
    if(rc != 0)
    {
        fprintf(stderr, "\n%s: Error reading\n", me);
        return(rc);
    }

    // Scan for pattern match
    for(idx = 0; idx < (3 * sizeof(daq_buf_t)); idx++)
    {
        rc = di_buf_validate(&sync_buf[idx]);
        if(rc != 0)
            fprintf(stderr, "\n%s: No sync at index %d, rc %d", me, idx, rc);
        else
        {
          //        fprintf(stderr, "\n%s: Sync at index %d", me, idx);
            found_match = true;
            break;
        }
    }

    if(found_match == true)
    {
        // Figure how many to read to sync up
        clear_count = idx;

        rc = di_serial_read(COMM_FD, sync_buf,
                            clear_count, serial_timeout);
        if(rc != 0)
        {
            fprintf(stderr, "\n%s: Error on sync read!", me);
            return(rc);
        }
                
        // Check again?
        return(0);
    }
    else
        fprintf(stderr, "\nNo sync\n");
    
    // Failed, do nothing else
    return(-1);
}
                

// ---------------------------------------------------------------------
int di_cmd_send(const int COMM_FD, const uint8_t *cmd, const int CMD_LEN)
{
    char     me[] = "di_cmd_send";
    int      idx, rc;
    uint8_t  btmp;
    int      read_len = CMD_LEN;

    if(cmd == NULL)
        return(-1);

    // DDT print to screen what command is
    // di_cmd_print(cmd, CMD_LEN);
        
    // Reset is annoyingly different
    //    if(is_reset_cmd(cmd, CMD_LEN))
    //  read_len++;

    for(idx = 0; idx < CMD_LEN; idx++)
    {
        // Send one byte (cmd or argument)
        rc = write(COMM_FD, &cmd[idx], sizeof(uint8_t));
        if(rc != sizeof(uint8_t))
        {
            fprintf(stderr, "\n%s: Error sending command", me);
            return(1);
        }
                
        // Zeros (NULLS) precede each cmd and are never echoed back
        if(cmd[idx] == 0x00)
            continue;
    
        // Look for the echo back, just one character
        rc = di_serial_read(COMM_FD, &btmp,
                            sizeof(btmp), serial_timeout);
        if(rc != 0)
        {
            fprintf(stderr, "\n%s: Error on command echo read",
                    me);
            return(2);
        }
        // DDT check echo
        if(btmp != cmd[idx])
        {
            fprintf(stderr, "\n%s: Cmd was %02X, echo was %02X",
                    me, (int) cmd[idx], (int) btmp);
        }
        /*
                        else
                        fprintf(stderr, "\n%s: Cmd was %02X, echo was same",
                        me, (int) cmd[idx]);
        */
    }

    // Any left to read?
    for(idx = 0; idx < (read_len - CMD_LEN); idx++)
    {
        rc = di_serial_read(COMM_FD, &btmp,
                            sizeof(btmp), serial_timeout);
        if(rc != 0)
        {
            fprintf(stderr, "\n%s: Error reading trailer bytes\n",
                    me);
        }
    }

    return(0);
}
                
// ---------------------------------------------------------------------
int di_initialize(const int COMM_FD, int *num_bits)
{
    char          me[] = "di_initialize";
    int           idx, rc;
    uint8_t       ser_buf[SERIAL_NUM_LEN * 2] = "";
    const uint8_t rs_signature[SERIAL_NUM_LEN + 1] = "0000000000";

    
    // DDT, one extra byte (0xFF) from 194RS
    read(COMM_FD, ser_buf, 1);

    // Unknown init cmd, ignore return code for now
    di_cmd_send(COMM_FD, odd_cmd, sizeof(odd_cmd));

    // Stop acquiring data
    rc = di_stop(COMM_FD);
        
    // Try requesting the serial number to check presence
    rc = di_serial_num(COMM_FD, ser_buf);
    if(rc != 0)
        return(rc);

    // New units (RS) return a serial of all ASCII zeros
    if(strncmp(ser_buf, rs_signature, SERIAL_NUM_LEN) == 0)
    {
        printf("\nNew (RS) unit found, skipping enable code download");
        *num_bits = 10;
    }
    else
    {
      *num_bits = 8;
      printf("\nDI-194 found, Serial number: '");

        for(idx = 0; idx < SERIAL_NUM_LEN; idx++)
            printf("%c", ser_buf[idx]);
        printf("'\nSending enable key to device");

        // Send the key (enabler) out
        // Each key byte is prefixed with 0x00 0x45
        for(idx = 0; idx < sizeof(di_enable_key); idx++)
        {
            rc = di_cmd_send(COMM_FD, key_cmd, sizeof(key_cmd));
            if(rc != 0)
            {
                fprintf(stderr, "\n%s: Error sending key command", me);
                return(2);
            }

            // That was key prefix, now the key byte itself
            rc = di_cmd_send(COMM_FD, &di_enable_key[idx], sizeof(uint8_t));
            if(rc != 0)
            {
                fprintf(stderr, "\n%s: Error sending key byte", me);
                return(2);
            }
        }
    }
    
    return(0);
}


// ---------------------------------------------------------------------
int di_configure(const int COMM_FD)
{
    char      me[] = "di_configure";
    int       rc;
        
    if(COMM_FD <= 0)
    {
        fprintf(stderr, "\n%s: Invalid file descriptor %d",
                me, COMM_FD);
        return(1);
    }

    // Select all (analog) channels
    rc = di_cmd_send(COMM_FD, all_chan, sizeof(all_chan));
    if(rc != 0)
    {
        fprintf(stderr, "\n%s: Error sending all-channels command",
                me);
        return(2);
    }

    // Turn on digital inputs, too
    rc = di_cmd_send(COMM_FD, dig_chan, sizeof(dig_chan));
    if(rc != 0)
    {
        fprintf(stderr,
                "\n%s: Error sending digital channels command", me);
        return(2);
    }

    // Made it!
    return(0);
}

// ---------------------------------------------------------------------
char *di_byte_print(const uint8_t in_byte)
{
    int         idx;
    static char out_buf[sizeof(uint8_t) * sizeof(char) + 1];
    uint8_t     btmp;


    for(idx = 0; idx < 8; idx++)
    {
        // Slice off MSB
        btmp = ((in_byte >> (7 - idx)) & 0x01);
        // Convert to ASCII
        out_buf[idx] = (btmp + '0');
    }

    return(out_buf);
}

// ---------------------------------------------------------------------
int di_buf_validate(const daq_buf_t buf)
{
  int idx;

  // Initial byte has trailing zero
  if((buf[0] & 0x01) != 0x00)
    return(1);

  // rest are constant 1
  for(idx = 1; idx < 8; idx++)
    if((buf[idx] & 0x01) != 0x01)
      return(idx + 1);

    return(0);
}

// ---------------------------------------------------------------------
int di_buf_decode(const daq_buf_t buf, 
                  daq_reading_t *result, const int NUM_BITS)
{
    uint16_t   atmp[4];
    int        idx;
    double     slope = 20.0 / ((double) (1 << NUM_BITS));

    if((buf == NULL) || (result == NULL))
        return(-1);

    // Check for signature
    if(di_buf_validate(buf) == 0)
    {
        result->is_valid = true;
    }
    else
    {
        result->is_valid = false;
            
        printf("\nSignature not found; invalid buffer: '");
        for(idx = 0; idx < sizeof(daq_buf_t); idx++)
          hex_print_byte(buf[idx]);
        printf("'\n");
        return(1);
    }

    /*
      This bit-mangling won't make sense until you stare at the
      vendor-supplied decode table. Obfuscated data, basically.

      The digital-to-voltage conversion is simple: 0x00 == -10VDC,
      and 0xFF means +10VDC. This is just an mx+b conversion.
    */
    if(NUM_BITS == 10) // DI-194RS
    {
      atmp[0] = (((buf[1] & 0xFE) << 8) | ((buf[0] & 0xF0) >> 5)) >> 6;
      atmp[1] = (((buf[3] & 0xFE) << 8) | ((buf[2] & 0xF0) >> 5)) >> 6;
      atmp[2] = (((buf[5] & 0xFE) << 8) | ((buf[4] & 0xF0) >> 5)) >> 6;
      atmp[3] = (((buf[7] & 0xFE) << 8) | ((buf[6] & 0xF0) >> 5)) >> 6;
      
      for(idx = 0; idx < 4; idx++)
      {
        result->analog[idx] = -10.0 + (slope * (atmp[idx]));
        result->raw[idx] = atmp[idx];
      }
      
      
      // In 240 Hz mode, we get 4 different reads on the digital!
      result->digital[0] = (buf[2] & 0x08) ? 1 : 0;
      result->digital[1] = (buf[2] & 0x04) ? 1 : 0;
      result->digital[2] = (buf[2] & 0x02) ? 1 : 0;
      
    }
    else if(NUM_BITS == 8)
    {
      atmp[0] = (((buf[1] & 0xFE) << 8) | ((buf[0] & 0xF0) >> 7)) >> 8;
      atmp[1] = (((buf[3] & 0xFE) << 8) | ((buf[2] & 0xF0) >> 7)) >> 8;
      atmp[2] = (((buf[5] & 0xFE) << 8) | ((buf[4] & 0xF0) >> 7)) >> 8;
      atmp[3] = (((buf[7] & 0xFE) << 8) | ((buf[6] & 0xF0) >> 7)) >> 8;
      
      for(idx = 0; idx < 4; idx++)
      {
        result->analog[idx] = -10.0 + (slope * (atmp[idx]));
        result->raw[idx] = atmp[idx];
      }
      

      // In 240 Hz mode, we get 4 different reads on the digital!
      result->digital[0] = (buf[0] & 0x08) ? 1 : 0;
      result->digital[1] = (buf[0] & 0x04) ? 1 : 0;
      result->digital[2] = (buf[0] & 0x02) ? 1 : 0;
    }

    return(0);
}

//***********************************************************************
int di_open(const char *COMPORT_FILE, int *num_bits)
{
    char          me[] = "di_open";
    int           rc;
    char          *portname = NULL;
    const char    com1[] = "/dev/ttyS0"; // Default serial port
    int           comm_fd = -1;

    // If no port passed, try environment or default
    if(COMPORT_FILE == NULL)
    {
        // If set, use environment variable
        portname = getenv("DI194_PORT");
        if(portname == NULL)
        {
            // Fallback to hardwired serial port zero
            portname = (char *) com1;
        }
    }
    else // try users' port
        portname = (char *) COMPORT_FILE;
        
    /* Try to open connection to desired comport */
    //    printf("\nOpening serial port '%s'", portname);
    //    fflush(stdout);

    comm_fd = di_serial_init(portname);
    if(comm_fd < 0)
    {
        fprintf(stderr, "\n%s: Error opening port '%s'",
                me, portname);
        return(-1);
    }

    //   printf("\nPort opened OK, initializing and reading serial number...");
    //   fflush(stdout);
        
    // pfh use my init and read serial code, precision
    rc = di_initialize(comm_fd, num_bits);
    if(rc != 0)
    {
        fprintf(stderr, "\n%s: Error initializing device\n", me);
        return(-2);
    }

    //    printf("\nUnit opened OK, programming...");
    //    fflush(stdout);

    // Set the DAQ up (programming constant DAQ)
    rc = di_configure(comm_fd);
    if(rc != 0)
    {
        fprintf(stderr, "\n%s: Error programming device\n", me);
        return(-3);
    }

    // Hmm. 
    return(comm_fd);
}

//***********************************************************************
int di_close(const int COMM_FD)
{
    char       me[] = "di_close";
    int        rc;
    
    rc = di_serial_close(COMM_FD);

    if(rc != 0)
        fprintf(stderr, "\n%s: Error %d closing DI-194 port\n",
                me, rc);
    
    return(rc);
}


//***********************************************************************
int di_read(const int COMM_FD, daq_reading_t *data, const int NUM_BITS)
{
    char          me[] = "di_read";
    int           rc;
    daq_buf_t     raw_buf;
    

    // Single DAQ
    rc = di_serial_read(COMM_FD, raw_buf,
                        sizeof(raw_buf), serial_timeout);
    if(rc != 0)
    {
        fprintf(stderr, "\n%s: Error %d on serial read",
                me, rc);
        return(rc);
    }
    
    // decode buffer
    rc = di_buf_decode(raw_buf, data, NUM_BITS);
    if(rc != 0)
    {
        fprintf(stderr, "\n%s: Error %d on buffer decode; overflow?",
                me, rc);
        
        return(rc);
    }

    // DDT
    /*
    printf("\n");
    for(idx = 0; idx < 8; idx++)
      hex_print_byte(raw_buf[idx]);
    printf("\n");
    */
    // Made it!
    return(0);
}

//***********************************************************************
int di_read_single(const int COMM_FD, daq_reading_t *data, const int NUM_BITS)
{
    int      rc;


    // Start DAQ
    rc = di_start(COMM_FD);
    if(rc != 0)
        return(rc);
    
    rc = di_read(COMM_FD, data, NUM_BITS);
    if(rc != 0)
    {
        di_stop(COMM_FD);
        return(rc);
    }
    
    rc = di_stop(COMM_FD);

    return(rc);
}

---