source: ETALON/DAQ/savedata.c

// $URL: http://subversion:8080/svn/gsc/trunk/drivers/LINUX/18AI32SSC1M/savedata/savedata.c $
// $Rev: 1895 $
// $Date: 2009-04-27 14:00:34 -0500 (Mon, 27 Apr 2009) $

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include "main.h"



// #defines     *******************************************************************

#define _1M             (1024L * 1024L)



// variables    ***************************************************************

static  __u32   _buffer[_1M];



/******************************************************************************
*
*       Function:       _channels
*
*       Purpose:
*
*               Check to see how many channels the board has.
*
*       Arguments:
*
*               fd              The handle for the board to access.
*
*               chan    Report the number of channels here.
*
*       Returned:
*
*               >= 0    The number of errors encounterred.
*
******************************************************************************/

static int _channels(int fd, __s32* chans)
{
        __s32   active  = -1;
        char    buf[64];
        int             errs    = 0;
        __s32   first   = -1;
        __s32   last    = -1;
        __s32   single  = -1;

        gsc_label("Input Channels");

        active  = -1;
        errs    += ai32ssc1m_dsl_ioctl(fd, AI32SSC1M_IOCTL_CHAN_ACTIVE, &active );
        errs    += ai32ssc1m_dsl_ioctl(fd, AI32SSC1M_IOCTL_CHAN_FIRST,  &first  );
        errs    += ai32ssc1m_dsl_ioctl(fd, AI32SSC1M_IOCTL_CHAN_LAST,   &last   );
        errs    += ai32ssc1m_dsl_ioctl(fd, AI32SSC1M_IOCTL_CHAN_SINGLE, &single );

        if (errs == 0)
        {
                switch (active)
                {
                        default:

                                errs++;
                                printf("FAIL <---  (invalid ACTIVE selection: %ld)\n", (long) active);
                                break;

                        case AI32SSC1M_CHAN_ACTIVE_SINGLE:

                                chans[0]        = 1;
                                sprintf(buf, "# %ld", (long) single);
                                break;

                        case AI32SSC1M_CHAN_ACTIVE_0_1:

                                chans[0]        = 2;
                                strcpy(buf, "#s 0-1");
                                break;

                        case AI32SSC1M_CHAN_ACTIVE_0_3:

                                chans[0]        = 4;
                                strcpy(buf, "#s 0-3");
                                break;

                        case AI32SSC1M_CHAN_ACTIVE_0_7:

                                chans[0]        = 8;
                                strcpy(buf, "#s 0-7");
                                break;

                        case AI32SSC1M_CHAN_ACTIVE_0_15:

                                chans[0]        = 16;
                                strcpy(buf, "#s 0-15");
                                break;

                        case AI32SSC1M_CHAN_ACTIVE_0_31:

                                chans[0]        = 32;
                                strcpy(buf, "#s 0-31");
                                break;

                        case AI32SSC1M_CHAN_ACTIVE_RANGE:

                                chans[0]        = last - first + 1;

                                if (first == last)
                                        sprintf(buf, "# %ld", (long) first);
                                else
                                        sprintf(buf, "#s %ld-%ld", (long) first, (long) last);

                                break;
                }

                if (errs == 0)
                {
                        printf( "%ld Channel%s  (%s)\n",
                                        (long) chans[0],
                                        (chans[0] == 1) ? "" : "s",
                                        buf);
                }
        }

        return(errs);
}



/******************************************************************************
*
*       Function:       _read_data
*
*       Purpose:
*
*               Read data into the buffer.
*
*       Arguments:
*
*               fd              The handle for the board to access.
*
*       Returned:
*
*               >= 0    The number of errors encounterred.
*
******************************************************************************/

static int _read_data(int fd)
{
        int             errs;
        long    get             = sizeof(_buffer) / 4;
        int             got;

        gsc_label("Reading");
        got     = ai32ssc1m_dsl_read(fd, _buffer, get);

        if (got < 0)
        {
                errs    = 1;
        }
        else if (got != get)
        {
                errs    = 1;
                printf( "FAIL <---  (got %ld samples, requested %ld)\n",
                                (long) got,
                                (long) get);
        }
        else
        {
                errs    = 0;
                printf( "PASS  (%ld samples)\n",
                                (long) get);
        }

        return(errs);
}



/******************************************************************************
*
*       Function:       _save_data
*
*       Purpose:
*
*               Save the read data to a text file.
*
*       Arguments:
*
*               fd              The handle for the board to access.
*
*               chan    The number of channels.
*
*               errs    have there been any errors so far?
*
*       Returned:
*
*               >= 0    The number of errors encounterred.
*
******************************************************************************/

static int _save_data_hex(int fd, int chan, int errs,char* name)
{
        FILE*           file;
        int                     i;
        long            l;
        long            samples = sizeof(_buffer) / 4;

        gsc_label("Saving");

        for (;;)
        {
                if (errs)
                {
                        printf("SKIPPED  (errors)\n");
                        errs    = 0;
                        break;
                }

                file    = fopen(name, "w+b");

                if (file == NULL)
                {
                        printf("FAIL <---  (unable to create %s)\n", name);
                        errs    = 1;
                        break;
                }

                for (l = 0; l < samples; l++)
                {
                        if ((l) && (_buffer[l] & 0x80000000))
                        {
                                i       = fprintf(file, "\r\n");

                                if (i != 2)
                                {
                                        printf("FAIL <---  (fprintf() failure to %s)\n", name);;
                                        errs    = 1;
                                        break;
                                }
                        }

                        i       = fprintf(file, "  %08lX", (long) _buffer[l]);

                        if (i != 10)
                        {
                                printf("FAIL <---  (fprintf() failure to %s)\n", name);
                                errs    = 1;
                                break;
                        }
                }

                fclose(file);

                if (errs == 0)
                        printf("PASS  (%s)\n", name);

                break;
        }

        return(errs);
} // _save_data_hex

/******************************************************************************
*
*       Function:       _save_data
*
*       Purpose:
*
*               Save the read data to a text file.
*
*       Arguments:
*
*               fd              The handle for the board to access.
*
*               chan    The number of channels.
*
*               errs    have there been any errors so far?
*
*       Returned:
*
*               >= 0    The number of errors encounterred.
*
******************************************************************************/

static int _save_data_dec(int fd, int chan, int errs,char* name)
{
        FILE*           file;
        int                     i;
        long            l;
        long            samples = sizeof(_buffer) / 4;

        gsc_label("Saving");

        for (;;)
        {
                if (errs)
                {
                        printf("SKIPPED  (errors)\n");
                        errs    = 0;
                        break;
                }

                file    = fopen(name, "w+b");

                if (file == NULL)
                {
                        printf("FAIL <---  (unable to create %s)\n", name);
                        errs    = 1;
                        break;
                }

                for (l = 0; l < samples; l++)
                {
                        if ((l) && (_buffer[l] & 0x80000000))
                        {
                                i       = fprintf(file, "\r\n");

                                if (i != 2)
                                {
                                        printf("FAIL <---  (fprintf() failure to %s)\n", name);;
                                        errs    = 1;
                                        break;
                                }
                        }

                        if ((_buffer[l] & 0x80000000))
                        {  
                          i     = fprintf(file, " %12ld", (long) ( _buffer[l] - 0x80000000) );
                        } else {
                          i     = fprintf(file, " %12ld", (long) _buffer[l]);
                        }
                        if (i < 5)
                        {
                                printf("FAIL <---  (fprintf() failure to %s)\n", name);
                                errs    = 1;
                                break;
                        }
                }

                fclose(file);

                if (errs == 0)
                        printf("PASS  (%s)\n", name);

                break;
        }

        return(errs);
} // _save_data_dec


/******************************************************************************
*
*       Function:       _save_data
*
*       Purpose:
*
*               Save the read data to a text file.
*
*       Arguments:
*
*               fd              The handle for the board to access.
*
*               chan    The number of channels.
*
*               errs    have there been any errors so far?
*
*       Returned:
*
*               >= 0    The number of errors encounterred.
*
******************************************************************************/

static int _save_data(int fd, int chan, int errs)
{
  char  name_hex[50];
  char  name_dec[50];

        time_t t = time(NULL);
        struct tm tm = *localtime(&t);

        sprintf(name_hex,"data/data_SPESO_%d-%02d-%02d_%02d-%02d-%02d_hex.txt", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
        sprintf(name_dec,"data/data_SPESO_%d-%02d-%02d_%02d-%02d-%02d_dec.txt", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);

        errs +=_save_data_hex(fd, chan, errs, name_hex);
        errs +=_save_data_dec(fd, chan, errs, name_dec);

        return(errs);
} // _save_data


/******************************************************************************
*
*       Function:       save_data
*
*       Purpose:
*
*               Configure the board, then capture data to a file.
*
*       Arguments:
*
*               fd              The handle for the board to access.
*
*               io_mode Use the I/O mode for data transfer.
*
*       Returned:
*
*               >= 0    The number of errors encounterred.
*
******************************************************************************/

/*
int save_data(int fd, __s32 io_mode)
{
        __s32   chans   = 32;
        int             errs    = 0;

        gsc_label("Capture & Save");
        printf("\n");
        gsc_label_level_inc();

        errs    += ai32ssc1m_config_basic(fd, -1, 1440);        // 1440 ~= 25000 S/S/C
        errs    += ai32ssc1m_rx_io_mode(fd, -1, io_mode, NULL);
        errs    += _channels(fd, &chans);
        errs    += _read_data(fd);
        errs    += ai32ssc1m_ain_buf_overflow(fd, -1, -1, NULL);
        errs    += ai32ssc1m_ain_buf_underflow(fd, -1, -1, NULL);
        errs    += _save_data(fd, chans, errs);

        gsc_label_level_dec();
        return(errs);
} // save_data
*/


/******************************************************************************
*
*       Function:       save_data_continuous
*
*       Purpose:
*
*               Configure the board, then capture data to a file.
*
*       Arguments:
*
*               fd              The handle for the board to access.
*
*               io_mode Use the I/O mode for data transfer.
*
*       Returned:
*
*               >= 0    The number of errors encounterred.
*
******************************************************************************/

 //int save_data_continuous(int fd, __s32 io_mode)
int save_data(int fd, __s32 io_mode)
{
        __s32   chans   = 32;
        int             errs    = 0;

        //ND
        int index=-1;
        int max_rate=36000000;//Hz
        int my_rate=20000;//Hz
                int nrate=max_rate/my_rate;
        __s32 range = AI32SSC1M_AIN_RANGE_5V;
        //__s32 range = AI32SSC1M_AIN_RANGE_10V;

        gsc_label("Capture & Save");
        gsc_label_level_inc();

        gsc_label("At 1");
        errs    += ai32ssc1m_config_basic(fd, -1, 1440);        // 1440 ~= 25000 S/S/C
        gsc_label("At 2");
        printf("rate= %d Hz (factor= %d) \n",my_rate,nrate);
        errs    += ai32ssc1m_rx_io_mode(fd, -1, io_mode, NULL);

        gsc_label("At 3");
        //ND
        errs    += ai32ssc1m_ain_range                  (fd, index, range, NULL);
        errs    += ai32ssc1m_rag_nrate                  (fd, index, nrate, NULL);
                                        errs    += ai32ssc1m_burst_sync                 (fd, index, AI32SSC1M_BURST_SYNC_EXT, NULL);
                                                                
                                        //                                      errs    += ai32ssc1m_burst_sync                 (fd, index, AI32SSC1M_BURST_SYNC_DISABLE, NULL);
        errs    += ai32ssc1m_burst_size                 (fd, index, 1024, NULL);
        //      errs    += ai32ssc1m_io_inv                             (fd, index, AI32SSC1M_IO_INV_HIGH,NULL);
        errs    += ai32ssc1m_io_inv                             (fd, index, AI32SSC1M_IO_INV_LOW,NULL);

        gsc_label("At 4");

        errs    += ai32ssc1m_chan_active                (fd, index, AI32SSC1M_CHAN_ACTIVE_RANGE,  NULL);
        errs    += ai32ssc1m_chan_first                 (fd, index, 26, NULL);
        errs    += ai32ssc1m_chan_last                  (fd, index, 31, NULL);
        errs    += ai32ssc1m_chan_active                (fd, index, AI32SSC1M_CHAN_ACTIVE_RANGE,  NULL);
        errs    += ai32ssc1m_ain_buf_clear              (fd, index);
        //      errs    += ai32ssc1m_input_sync                 (fd, index);
        //      errs    += ai32ssc1m_input_sync                 (fd, index);

        errs    += _channels(fd, &chans);


        errs    += _read_data(fd);
        errs    += ai32ssc1m_ain_buf_overflow(fd, -1, -1, NULL);
        errs    += ai32ssc1m_ain_buf_underflow(fd, -1, -1, NULL);
        errs    += _save_data(fd, 31-26, errs);

        gsc_label_level_dec();
        return(errs);
} // save_data_continuous