---

adxl_util.c

Go to the documentation of this file.

#include <sys/types.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <unistd.h>
#include <stdint.h>
#include <string.h>
#include <signal.h>
#include <time.h>

#include <sys/termios.h>
#include <fcntl.h>

#include "nsds_util.h"
#include "flog.h"
#include "adxl_util.h"

bool control_break;

// ---------------------------------------------------------------------
int adxl_open(const char *COMPORT_FILE)
{
    char            me[] = "adxl_open";
    struct termios  term;
    int             comm_fd = -1;
    const int       baud_rate = B38400;
    char            *portname = NULL;
    const char      com1[] = "/dev/ttyS1";


    // If no port passed, try environment or default
    if(COMPORT_FILE == NULL)
    {
        // If set, use environment variable
        portname = getenv("ADXL_PORT");
        if(portname == NULL)
        {
            // Fallback to hardwired serial port zero
            portname = (char *) com1;
        }
    }
    else // try users' port
        portname = (char *) COMPORT_FILE;
        
    // Open and program the serial port
    flog_usr(FLOG_NOTICE, 0, me, "Opening ADXL202 on port '%s'", portname);

    /* Open the comport, R/W access required */
    comm_fd = open(portname, O_RDWR);
        
    /* Exit if could not open the comport */
    if(comm_fd <= 0)
    {
        flog_usr(FLOG_ERROR, FL_ERR_SYSTEM, me,
                 "Could not open serial port '%s'\n", portname);
        return(comm_fd);
    }

    // Clear the struct
    memset(&term, 0x00, sizeof(term));

    tcgetattr(comm_fd, &term);

    // Set local device, 8 bits, read enabled, 38400 baud
    term.c_cflag = baud_rate | CS8 | CLOCAL | CREAD;
    term.c_iflag = IGNPAR;// No parity
    term.c_oflag = 0;     // Clear these flags
    term.c_lflag = 0;
    term.c_cc[VMIN] = 1;  // Block until 1 char arrives
    term.c_cc[VTIME] = 0; // Inter-character timeout not used

    tcflush(comm_fd, TCIFLUSH);
    tcsetattr(comm_fd, TCSANOW, &term);

    // Delay to allow the board to start up
    sleep(2);

    flog_usr(FLOG_DEBUG, 0, me, "Serial initialization completed OK");    

    return(comm_fd);
}

// ---------------------------------------------------------------------
int adxl_read(const int COMM_FD, adxl_reading_t *result)
{
    char        me[] = "adxl_read";
    int         itmp;
    char        read_buf[2 * ADXL_READ_LEN] = "";
    const char  start_char[] = "G";

    
    if((COMM_FD <= 0) || (result == NULL))
    {
        flog_usr(FLOG_ERROR, FL_ERR_NOCANDO, me,
                 "Incorrect parameter!");
        return(-1);
    }

    // Zero the result buffer
    memset(result, 0x00, sizeof(adxl_reading_t));

    // Reads are triggered by sending the 'G' character, no timed mode
    itmp = write(COMM_FD, start_char, 1);
    if(itmp <= 0)
    {
        flog_usr(FLOG_ERROR, FL_ERR_SYSTEM, me,
                 "Error %d on serial write", itmp);
        return(itmp);
    }

    // Read 4 bytes of data back - 16 bits for each axis
    itmp = read(COMM_FD, read_buf, ADXL_READ_LEN);
    if(itmp < ADXL_READ_LEN)
    {
        flog_usr(FLOG_ERROR, FL_ERR_SYSTEM, me,
                 "Error %d on serial read", itmp);
        return(1);
    }

    // Decode 16-bit signed ints
    result->raw[0] = ((read_buf[0] * 256) + read_buf[1]);
    result->raw[1] = ((read_buf[2] * 256) + read_buf[3]);

    // Calibration is from the data sheet, convert to +- 2.0
    result->G[0] = (result->raw[0] / 100.0);
    result->G[1] = (result->raw[1] / 100.0);
  
    return(0);
}

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


// ---------------------------------------------------------------------
void adxl_sighandler(int signal)
{
    char    me[] = "adxl_sighandler";

    flog_usr(FLOG_NOTICE, 0, me, "Got signal %d, exiting", signal);
    control_break = true;

    return;
}

---