Subversion Repositories modular_oscilloscope

#include <QtGui/QDialog>

#include <QThread>

#include <QString>

#include <QTimer>

#include <cmath>

//#include <QBasicTimer>

#include "rvicommthread.h"

RVICommThread::RVICommThread(QObject *parent): QThread(parent = 0)

{

    portAddress = 0;

    continuous = 0;

    triggerOn = 0;

    triggerSlope = 0;

    triggerChannel = 0;

    timeScaleEnabled = 0;

    timeScaleValue = 0;

    channelAEnabled = 0;

    channelBEnabled = 0;

    bufferSize = 0;

    triggerLevel = 0;

    triggerOffset = 0;

    aDCSampleRate = BASE_SAMPLE_RATE;

}

RVICommThread::~RVICommThread()

{

    port.closeEPP();

}

void RVICommThread::run()

{

    ////////////////////////////////////////////////////////////////////////////////////////////////

    // Init

    acqStopped = false;

    bufferFull = false;

    unsigned short int confArray[5];

    if (bufferSize < triggerOffset || -bufferSize > triggerOffset )

    {

        if (triggerOffset < 0)

            triggerOffset = -bufferSize;

        else

            triggerOffset = bufferSize;

        emit statusMessage(tr("Too big trigger offset, truncating to: %1").arg(triggerOffset));

    }

    if ( (channelAEnabled == false) && (channelBEnabled == false) )

    {

        emit statusMessage(tr("All channels disabled."));

        return;

    }

    timer = new QTimer;

    timer->setSingleShot(true);

    connect(timer, SIGNAL(timeout()), SLOT(endWaiting()));

    ////////////////////////////////////////////////////////////////////////////////////////////////

    //  Writing config

    confArray[0] = 1;                                     // Run

    confArray[0] = continuous        << 1 | confArray[0]; // Cont

    confArray[0] = triggerOn         << 2 | confArray[0]; // TrOn

    confArray[0] = triggerSlope      << 3 | confArray[0]; // TrEdg

    confArray[0] = triggerChannel    << 4 | confArray[0]; // TrCh

    confArray[0] = timeScaleEnabled  << 5 | confArray[0]; // TScalEn

    confArray[0] = timeScaleValue    << 6 | confArray[0]; // TScal00..04

    confArray[1] = channelAEnabled;                       // RCh00

    confArray[1] = channelBEnabled   << 1 | confArray[1]; // RCh01

    confArray[2] = bufferSize;                            // BuffS00..13

    confArray[3] = triggerLevel;                          // TrLvl00..09

    confArray[4] = triggerOffset;                         // TrOff00..14

    /*

      ADR  NAME        MODE    [     15|     14|     13|     12|     11|     10|      9|      8|

                                      7|      6|      5|      4|      3|      2|      1|      0]    bits

       00   RunConf_R   RW     [       |       |       |       |       |TScal04|TScal03|TScal02|

    --                          TScal01|TScal00|TScalEn|   TrCh|  TrEdg|   TrOn|   Cont|  Start]

    --

    -- 01   Channels_R  RW     [       |       |       |       |       |       |       |       |

    --                                 |       |       |       |       |       |  RCh01|  RCh00]

    --

    -- 02   BuffSize_R  RW     [       |       |BuffS13|BuffS12|BuffS11|BuffS10|BuffS09|BuffS08|

    --                          BuffS07|BuffS06|BuffS05|BuffS04|BuffS03|BuffS02|BuffS01|BuffS00]

    --

    -- 03   TrigLvl_R   RW     [       |       |       |       |       |       |TrLvl09|TrLvl08|

    --                          TrLvl07|TrLvl06|TrLvl05|TrLvl04|TrLvl03|TrLvl02|TrLvl01|TrLvl00]

    --

    -- 04   TrigOff_R   RW     [       |TrOff14|TrOff13|TrOff12|TrOff11|TrOff10|TrOff09|TrOff08|

    --                          TrOff07|TrOff06|TrOff00|TrOff00|TrOff00|TrOff00|TrOff00|TrOff00]

    --

    -- 05   ADCConf     RW     [       |       |       |       |   ADCS|ADSleep| ADPSEn| ADPS08|

    --                           ADPS07| ADPS06| ADPS05| ADPS04| ADPS03| ADPS02| ADPS01| ADPS00]

    --

    -- 08   Data_O      R      [ErrFlag|RunFlag|       |       |       |  DCh00|  Dat09|  Dat08|

    --                            Dat07|  Dat06|  Dat05|  Dat04|  Dat03|  Dat02|  Dat01|  Dat00]

    --

    -- 09   Error_O     R      [       |       |       |       |       |       |       |       |

    --                                 |       |       |       |       | ErrN02| ErrN01| ErrN00]

    */

    EppParallelUseWin::PPStatusType status;

    status = port.negotiateEPP(portAddress);

    emit statusMessage(translateStatus(status));

    if (status != EppParallelUseWin::PP_CONECTED)

        return;

    status = port.testDataTransfer();

    for (int i = 4; i >= 0; i--)

    {

        port.writeWord(confArray[i], i);

        status = port.testDataTransfer();

        if (status != EppParallelUseWin::PP_CONECTED)

        {

            for (int j = 0; (j <= 5) && (status != EppParallelUseWin::PP_CONECTED); j++)

            {

                port.writeWord(confArray[i], i);

                status = port.testDataTransfer();

            }

            if (status != EppParallelUseWin::PP_CONECTED)

            {

                emit statusMessage(translateStatus(status));

                return;

            }

        }

    }

    ////////////////////////////////////////////////////////////////////////////////////////////////

    //  Write and check stream address

    char address = 8;  // input data address

    port.testDataTransfer();

    port.writeAddress(address);

    port.readAddress(address);

    if (address != 8)

    {

        emit statusMessage(tr("Can't write an address"));

        return;

    }

    ////////////////////////////////////////////////////////////////////////////////////////////////

    // Getting data

    int count = 0;

    bool oddBuffer = false;

    unsigned int data = 0x80; // stopped with errors

    dataUsed = false;

    port.testDataTransfer(); // clear time out flags

    channelData[0].clear();

    channelData[1].clear();

    if (triggerOn)

        emit statusMessage(tr("Waiting for trigger..."));

    else

        emit statusMessage(tr("Running"));

    do {

        port.readWord(data);

        status =  port.testDataTransfer();

        if ((status == EppParallelUseWin::PP_CONECTED) && (data != 0xFFFF))

        {

            // check running flag

            if ((data & 0x4000) == 0x0000 )

            {

                port.readWord(data ,0);

                port.readWord(data,8);

                if ((data & 0x4000) == 0x0000 )

                {

                    if (continuous)

                    {

                        emit statusMessage(tr("Error in data"));

                    }

                    else

                    {

                        checkDataSize();

                    }

                    bufferFull = true;

                    while (dataUsed == false && acqStopped == false) ;

                 //   emit endOfBuffer();

                    return;

                }

            }

            // if buffer is full

            else if ( ((data & 0x8000) == 0x0000) != oddBuffer)

            {

             //   emit endOfBuffer();

                dataUsed = false;

                bufferFull = true;

                checkDataSize();

                while (dataUsed == false && acqStopped == false) ;

                channelData[0].clear();

                channelData[1].clear();

            }

            // channel A

            else if ( (data & 0x0400) == 0x0400 )

            {

             //   emit chBNewData(0x3FF & data);

                channelData[0] << (0x3FF & data);

             //   oddBuffer = (data & 0x8000) == 0x0000 ;

            }

            // channel B

            else

            {

            //    emit chANewData(0x3FF & data);

                channelData[1] << (0x3FF & data);

            }

            oddBuffer = (data & 0x8000) == 0x0000 ;

            count = 0;

        }

        else

        {

            count++;

            if (count >= 500000)

            {

                if (triggerOn)

                {

                    statusMessage(tr("Still waiting for trigger..."));

                    count = 0;

                }

                else

                {

               //     emit endOfBuffer();

                    emit statusMessage(tr("Too much time out. Check the cable."));

                    return;

                }

            }

        }

    } while (acqStopped == false);

}

QList<int> RVICommThread::getChannelData(int channel)

{

    if (channel > 1 || channel < 0)

        channel = 0;

    dataUsed = true;

    bufferFull = false;

    return channelData[channel];

}

bool RVICommThread::isBufferFull()

{

    return bufferFull;

}

void RVICommThread::checkDataSize()

{

    if (channelAEnabled && channelBEnabled)

    {

        if ( (bufferSize != (channelData[0].size()-1)*2) && \

             (bufferSize != (channelData[1].size()-1)*2) )

            emit statusMessage(tr("Data size and buffer size not match"));

        else

            emit statusMessage(tr(""));

    }

    else if (channelAEnabled)

    {

        if (bufferSize != channelData[0].size())

            emit statusMessage(tr("Data size and buffer size not match"));

        else

            emit statusMessage(tr(""));

    }

    else

    {

        if (bufferSize != channelData[1].size())

            emit statusMessage(tr("Data size and buffer size not match"));

        else

            emit statusMessage(tr(""));

    }

}

QString RVICommThread::translateStatus(const EppParallelUseWin::PPStatusType &port_status)

{

  switch(port_status)

  {

    case EppParallelUseWin::PP_CONECTED:

        return QString( tr("Conected"));

        break;

    case EppParallelUseWin::PP_TIME_OUT:

        return QString( tr("Time Out"));

        break;

    case EppParallelUseWin::PP_COMUNICATION_FAIL:

        return QString( tr("Comunication fail at 0x%1").arg(portAddress, 0, 16));

        break;

    case EppParallelUseWin::PP_NEGOTIATION_FAIL:

        return QString( tr("Negotiation fail at 0x%1").arg(portAddress, 0, 16));

        break;

    case EppParallelUseWin::PP_LOAD_LIBRARY_FAIL:

       return QString( tr("Canīt load the library"));

        break;

    case EppParallelUseWin::PP_WRONG_BASE_ADDRESS:

        return QString( tr("Wrong port base address: 0x%1").arg(portAddress, 0, 16));

        break;

    default:

        return QString( tr("OK"));

        break;

  }

}

void RVICommThread::endWaiting()

{

    waiting = false;

}

////////////////////////////////////////////////////////////////////////////////////////////////////

// Parameters

void RVICommThread::setAddress(const short int &address)

{

    portAddress = address;

}

void RVICommThread::setContinuous(const bool &on)

{

    continuous = on;

}

void RVICommThread::setTrigger(const bool &on, const bool &slope, const bool &channel, const int &level, const int &offset)

{

    triggerOn = on;

    triggerSlope = slope;

    triggerChannel = channel;

    triggerLevel = level;

    triggerOffset = offset;

}

void RVICommThread::setChannels(const bool &chAOn, const bool &chBOn)

{

    channelAEnabled = chAOn;

    channelBEnabled = chBOn;

}

void RVICommThread::setBuffer(const int &size)

{

    bufferSize = size;

}

void RVICommThread::setTimeScaler(const bool &on, const int &value)

{

    timeScaleEnabled = on;

    timeScaleValue = value;

}

void RVICommThread::setADCPreScale(const int &preScale)

{

    adcPreScaler = preScale;

}

void RVICommThread::stopAcquistion()

{

    acqStopped = true;

}

void RVICommThread::configADC()

{

    if (adcPreScaler > pow(2.0, 8) )

    {

        emit statusMessage("Too big pre scaler, setting to default value (1).");

        adcPreScaler = 1;

    }

    else

    {

        emit statusMessage(tr("ADC Config Writed."));

    }

    unsigned short int config;

    config = adcPreScaler;                     // clk_pre_scaler

    config = 1                 << 9  | config; // clk_pre_scaler_ena

    config = 0                 << 10 | config; // adc sleep

    config = 0                 << 11 | config; // adc_chip_sel

    // if clk_pre_scaler_ena = 1,

    // freq_adc = freq_wbn / ((clk_pre_scaler+1)*2)

    EppParallelUseWin::PPStatusType status;

    status = port.negotiateEPP(portAddress);

    if (status != EppParallelUseWin::PP_CONECTED)

    {

        emit statusMessage(translateStatus(status));

        return;

    }

    status = port.testDataTransfer();

    port.writeWord(config, 5);

    status = port.testDataTransfer();

    if (status != EppParallelUseWin::PP_CONECTED)

    {

        for (int j = 0; (j <= 5) && (status != EppParallelUseWin::PP_CONECTED); j++)

        {

            port.writeWord(config, 5);

            status = port.testDataTransfer();

        }

        if (status != EppParallelUseWin::PP_CONECTED)

        {

            emit statusMessage(translateStatus(status));

            return;

        }

    }

    aDCSampleRate = BASE_SAMPLE_RATE/adcPreScaler;

}

double RVICommThread::getADCSampleRate()

{

    return aDCSampleRate;

}