#include "QAdcObject.h"
QAdcObject::QAdcObject(QObject *parent) : QObject(parent)
{
    m_bRun = false;
    m_dev  = 0;
}

QAdcObject::~QAdcObject()
{
    if(m_dev != 0)
    {
        m_bRun = false;
        X502_Close(m_dev);
        X502_Free(m_dev);
    }
}
#define channel_count 10
//#define CHECK_ADC_SCALE
void QAdcObject::init()
{
    char serial[2][X502_SERIAL_SIZE];
    qint32 err, devs;

    if(m_dev != 0)
    {
        m_bRun = false;
        X502_Close(m_dev);
        X502_Free(m_dev);
    }

    err = E502_UsbGetSerialList(serial, 2, X502_GETDEVS_FLAGS_ONLY_NOT_OPENED, (uint32_t*)&devs);
    if(devs == 0)
    {
        QDebug() << "e502 device not found";
        return;
    }
    m_dev = X502_Create();
    err = E502_OpenUsb(m_dev, serial[0]);
    if(err != 0)
    {
        QDebug() << "open e502 failed";
        X502_Free(m_dev);
        return;
    }
	err = X502_SetMode(m_dev, X502_MODE_FPGA);
    if(err < 0)
    {
        QDebug() << QString("set mode failed (%1)").arg(err);
    }
    err = X502_SetLChannelCount(m_dev, channel_count);
    if(err < 0)
    {
        QDebug() << QString("set channel count failed (%1)").arg(err);
    }
    for(int i = 0; i < channel_count; i++)
    {
        err = X502_SetLChannel(m_dev, i, i, X502_LCH_MODE_COMM, X502_ADC_RANGE_5, 1);
        if(err < 0)
        {
            QDebug() << QString("set logical channel failed (%1)").arg(err);
        }
    }
    err = X502_SetSyncMode(m_dev, X502_SYNC_INTERNAL);
    if(err < 0)
    {
        qDebug() << QString("set sync mode failed (%1)").arg(err);
    }
    err = X502_SetSyncStartMode(m_dev, X502_SYNC_INTERNAL);
    if(err < 0)
    {
        qDebug() << QString("set sync start mode failed (%1)").arg(err);
    }

	double fAdcFrame = 4000.0;
    double fAcq = 2000000.0;
    err = X502_SetAdcFreq(m_dev, &fAcq, &fAdcFrame);
    if(err < 0)
    {
        qDebug() << QString("set adc frequency failed (%1)").arg(err);
    }
    err = X502_Configure(m_dev, 0);
    if(err < 0)
    {
        qDebug() << QString("set configure failed (%1)").arg(err);
    }
}

//#define ADC_REORDER_DATA
void QAdcObject::startAdc(bool)
{
    qint32 buffer[32];
    qint32 rcv_size, adc_size, err;
	
	err = X502_SetStreamBufSize(m_dev, X502_STREAM_CH_IN, channel_count);
    if(err < 0)
    {
        QDebug() << QString("set stream buffer size failed (%1)").arg(err);
    }
    err = X502_SetStreamStep(m_dev, X502_STREAM_CH_IN, channel_count);
    if(err < 0)
    {
        QDebug() << QString("set stream step failed (%1)").arg(err);
    }

    err = X502_StreamsEnable(m_dev, X502_STREAM_ADC);
    if(err < 0)
    {
        QDebug() << QString("set stream enable failed (%1)").arg(err);
    }
    err = X502_StreamsStart(m_dev);
    if(err < 0)
    {
        QDebug() << QString("set stream start failed (%1)").arg(err);
    }
    m_bRun = true;
    while(m_bRun)
    {
        rcv_size = channel_count;
        rcv_size = X502_Recv(m_dev, (uint32_t*)buffer, rcv_size, 2000);
        if(rcv_size <= 0)
        {
            QDebug() << QString("error received adc data");
            continue;
        }
        adc_size = rcv_size;

#ifdef ADC_REORDER_DATA
        int first_lch;
        double adc_data[channel_count];
        X502_GetNextExpectedLchNum(m_dev, (uint32_t*)&first_lch);
        err = X502_ProcessAdcData(m_dev, (uint32_t*)buffer, adc_data, (uint32_t*)&adc_size,
                                         X502_PROC_FLAGS_VOLT);
#else
        err = X502_ProcessAdcData(m_dev, (uint32_t*)buffer, ret, (uint32_t*)&adc_size,
                                         X502_PROC_FLAGS_VOLT);
#endif
        if(err < 0)
        {
            QDebug() << QString("error processing data [%1]").arg(err);
			//helper for restart stream after error. It's working but not ever time...
            X502_StreamsStop(m_dev);
            X502_StreamsStart(m_dev);
            continue;
        }
#ifdef ADC_REORDER_DATA
        for(int lch = 0; lch < adc_size; ++lch)
        {
            int pos = (lch >= first_lch)? lch - first_lch : adc_size - first_lch + lch;
            if(pos < adc_size)
            {
                ret[lch] = adc_data[pos];
            }
        }
#endif
		// there is should be my processing data
    }
    X502_StreamsStop(m_dev);
    X502_StreamsDisable(m_dev, X502_STREAM_ADC);
}

   X502_StreamsStart(m_dev);
    while(m_bRun)
    {
        X502_Recv(m_dev, (uint32_t*)buffer, 10, 2000);
        X502_ProcessAdcData(m_dev, (uint32_t*)buffer, adc_data, (uint32_t*)&adc_size, X502_PROC_FLAGS_VOLT);
        app->adc_queue.enqueue(QByteArray((char*)adc_data, sizeof(double) * adc_size));

        for(int i = 0; i < 4; i++)
        {
            app->m_out = i;
            X502_AsyncOutDig(m_dev, app->m_out, 0);
            X502_AsyncInDig(m_dev, (uint32_t*)&inp_data);
            app->inp_data[i] = inp_data;
        }
    }
    X502_StreamsStop(m_dev);