---

adxl-simple.c

Go to the documentation of this file.

#include <sys/types.h>

#include <assert.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 <getopt.h>

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

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

// ---------------------------------------------------------------------
// Globals


// ------------------------------------------------------------------------
void adxl_do_work(const char *port)
{
    char          me[] = "adxl_do_work";
//    uint32_t      idx = 0;
    uint32_t      data_idx = 0;
    char          *data_buf = NULL;
    int           bufsize;
    int           rc;
    int           comm_fd = -1;
    adxl_reading_t data;
  
    
    comm_fd = adxl_open(port);
    if(comm_fd <= 0)
    {
        flog_usr(FLOG_ERROR, FL_ERR_UNKNOWN, me,
                 "Unable to open ADXL connection");
        return;
    }
    
    // Figure space required
    bufsize = (sizeof(char) * NUM_ADXL_CHANNELS * (DATUM_LEN + 4));

    // Allocate send buffer
    data_buf = (char *) malloc(bufsize);
    if(data_buf == NULL)
    {
        flog_usr(FLOG_ERROR, FL_ERR_NO_MEMORY, me,
                 "Malloc failure on %d bytes!", bufsize);

        return;
    }

    flog_usr(FLOG_NOTICE, 0, me, "Main loop running");
    
    // Run until port closed, error, control-c or done streaming
    while(!control_break)
    {
        sleep(1);

        // read a value from the daq, blocking read
        rc = adxl_read(comm_fd, &data);
        if(rc != 0)
        {
            flog_usr(FLOG_ERROR, FL_ERR_UNKNOWN, me,
                     "Error %d reading from ADXL", rc);
            break;
        }

        sprintf(data_buf, " X: %6.5f Y: %6.5f", 
                data.G[0], data.G[1]);

        // Track ttl xmitted bytes
        data_idx++;
            
        // DDT, dump to screen
        flog_usr(FLOG_DEBUG, 0, me, data_buf);
    }
    
    flog_usr(FLOG_NOTICE, 0, me,
             "Exiting, %d points or so",  data_idx);

    free(data_buf);
    adxl_close(comm_fd);
    
    return;
}

// ---------------------------------------------------------------------
int main(int argc, char *argv[])
{
    char          me[] = "main";
    int           help_flag = 0;
    int           idx, rc;
    char          *port = NULL;
    
    struct option long_options[] = 
        {
            {"help", no_argument, &help_flag, 'h'},
            {"port", required_argument, 0, 'p'},
            {0, 0, 0, 0}
        };
    
    // Set logging options
    flog_set_report(FLOG_L3BUG, FLOG_QUIET, FLOG_QUIET);
    flog_set_style(0x2019, 0x0038, 0x6008);    

    // Parse command line with getopt_long
    while(1)
    {
        rc = getopt_long(argc, argv, "p:r:h",
                         long_options, &idx);
        if(rc == -1)
            break;

        switch(rc)
        {
        case 0:
            /* If this option set a flag, do nothing else now. */
            break;

        case '?':
            /* getopt_long already printed an error message. */
            break;

        case 'h':
            help_flag = 1;
            break;

        case 'p':
            port = optarg;
            flog_usr(FLOG_NOTICE, 0, me, "Setting port to '%s'", port);
            break;

        default:
            flog_usr(FLOG_ERROR, FL_ERR_SYSTEM, me,
                     "Unreachable case in getopt_long parse");
            exit(1);
        }
    }

    if(help_flag != 0)
    {
        print_args(long_options);
        return(1);
    }
    
    flog_usr(FLOG_NOTICE, 0, me,
             "Compiled for %d data channels", NUM_ADXL_CHANNELS);
    
    // Signal handler
    flog_usr(FLOG_NOTICE, 0, me, "Installing signal handler");
    control_break = false;
    signal(SIGINT, adxl_sighandler);
    signal(SIGPIPE, adxl_sighandler);

    // Call main routine
    adxl_do_work(port);

    // Bail
    flog_usr(FLOG_NOTICE, 0, me, "Done");
    return(0);
}

---