source: ETALON/CLIO/savedata/old-savedata.c @ 756

// $URL: http://subversion:8080/svn/gsc/trunk/drivers/LINUX/18AI32SSC1M/savedata/savedata.c $
// $Rev: 35161 $
// $Date: 2016-06-06 16:28:07 -0500 (Mon, 06 Jun 2016) $

#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];



//*****************************************************************************
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);
}



//*****************************************************************************
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);
}



//*****************************************************************************
static int _save_data(int fd, int chan, int errs)
{
        FILE*           file;
        int                     i;
        long            l;
        const char*     name    = "data.txt";
        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);
}



//*****************************************************************************
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_ai(fd, -1, 1440);
        errs    += ai32ssc1m_rx_io_mode(fd, -1, io_mode, NULL);
        errs    += _channels(fd, &chans);
        errs    += ai32ssc1m_ain_buf_clear(fd, -1);
        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);
}