Работа с кольцевым буфером

void  ScopeH::ReadDataI()
{
    std::ofstream fCH1Data;
    fCH1Data.open("CH1Data.txt");
    fCH1Data.close();
    std::ofstream fCH2Data;
    fCH2Data.open("CH2Data.txt");
    fCH2Data.close();
    std::ofstream fCH3Data;
    fCH3Data.open("CH3Data.txt");
    fCH3Data.close();
    std::ofstream fCH4Data;
    fCH4Data.open("CH4Data.txt");
    fCH3Data.close();
    //stop = true;
    
    stop = false;
    //std::thread save_thread(&ScopeH::SaveThreadProc, this);
 
    if (buffers.empty())
    {
        for (size_t i = 0; i < 10; ++i)
            buffers.emplace_back();
    }
        
    
    while (ReadingDataStreamTrigger == 1)
    {
        
        dsoHTStartCollectData(DeviceIndex, 0);//1 режим roll - самописец, 0- авто триггер, 2 - одна запись
        /*if (dsoHTGetState(DeviceIndex) & 0x02)
        {
            std::this_thread::yield();
            continue;
        }*/
        WORD GetState = 0;
        while (GetState & 0x02)
        {
            GetState = dsoHTGetState(DeviceIndex);
 
        }
 
 
        DataBuffer& buf = buffers.front();
        dsoHTGetData(DeviceIndex, buf.ScopeDataForChannels[CH1], buf.ScopeDataForChannels[CH2],
            buf.ScopeDataForChannels[CH3], buf.ScopeDataForChannels[CH4], &myControlData);
 
        std::lock_guard<std::mutex> lock(mx);
        data.splice(data.end(), buffers, buffers.begin());
        
 
        cv.notify_one();
        if (buffers.empty())
            buffers.emplace_back();
        if (!StartWriting)
        {
            StartWriting = true;
            //StartWritingStream();
            WritingThread = std::thread(&ScopeH::SaveThreadProc, this);
 
 
        }
    }
 
    mx.lock();
    stop = true;
    mx.unlock();
 
    cv.notify_all();
    WritingThread.join();
    StartWriting = false;
    
}
 
bool ScopeH::WaitDataReady()
{
    std::unique_lock<std::mutex> lock(mx);
    while (!stop)
    {
        if (!data.empty())
            return true;
 
        cv.wait(lock);
    }
    return false;
}
void ScopeH::SaveThreadProc()
{
    std::ofstream fCH1Data;
    fCH1Data.open("CH1Data.txt", std::ios::app);
    //CH1Data.close();
    std::ofstream fCH2Data;
    fCH2Data.open("CH2Data.txt", std::ios::app);
    //CH2Data.close();
    std::ofstream fCH3Data;
    fCH3Data.open("CH3Data.txt", std::ios::app);
    //CH3Data.close();
    std::ofstream fCH4Data;
    fCH4Data.open("CH4Data.txt", std::ios::app);
    while (WaitDataReady())
    {
        DataBuffer &buf = data.front();
        
        for (int i = 0; i < myControlData.nReadDataLen; i++)
        {
            fCH1Data << buf.ScopeDataForChannels[0][i] <<"\n";
            fCH2Data << buf.ScopeDataForChannels[1][i] <<"\n";
            fCH3Data << buf.ScopeDataForChannels[2][i] <<"\n";
            fCH4Data << buf.ScopeDataForChannels[3][i] <<"\n";
 
        }
 
        std::lock_guard<std::mutex> lock(mx);
        
        buffers.splice(buffers.end(), data, data.begin());
        
    }
    fCH1Data.close();
 
    fCH2Data.close();
 
    fCH3Data.close();
 
    fCH4Data.close();
 
}

bool ScopeH::WaitDataReady()
{
    std::unique_lock<std::mutex> lock(mx);
    while (data.empty())
    {
        if (stop)
            return false;
 
        cv.wait(lock);
    }
    return true;
}

int main()
{
    RELAYCONTROL myRelayControl;
    //PRELAYCONTROL pRelayControl;
    CONTROLDATA  myControlData;
    //std::cout << "Hello World!\n";
    short DevInfo[32];
    WORD nConnectedDevNum = 0;
    WORD DeviceIndex = 0;
    //WORD DevInd = 1;
    WORD nTimeDiv = /*TIMEDIV_1GSA*/0;
    USHORT LPos[MAX_CH_NUM];
    LPos[CH1] = 80;
    LPos[CH2] = 112;
    LPos[CH3] = 144;
    LPos[CH4] = 176;
    nConnectedDevNum = dsoHTSearchDevice(DevInfo);
    WORD pAmpLevel[AMPCALI_Len];
    //std::cout << "Connected Devices:" << std::endl;
    /*for (int i = 0; i < 32; i++)
    {
 
        std::cout << "DevInfo = " << DevInfo[i] << std::endl;
        if (DevInfo[i] == 1)
        {
            DeviceIndex = i;
        }
    }*/
    //std::cout << "DevInfo = " << DevInfo << std::endl;
    //DevInd = dsoGetUSBModulVersion(2);
    //std::cout << "USB #1 ver.: " << DevInd << std::endl;
    std::cout << "ConnectedDeviceNumber = "<< nConnectedDevNum << std::endl;
    //std::cout << "DeviceIndex = " << DeviceIndex << std::endl;
    //std::cout << "Trying to set USBBus...";
    
    //bool B = dsoSetUSBBus(2);
    //bool B = true;
    //std::cout << "DeviceIsConnected? = " << B << std::endl;
    //dsoInitHard()
    /*for (int i = 0; i < 32; i++)
    {
        WORD Index = dsoHTDeviceConnect(i);
        if (Index == 1)
        {
            DeviceIndex = i;
        }
        //std::cout << "Index = " << Index << std::endl;
 
    }*/
 
    //dsoHTDeviceConnect()
   //BOOL SetUSBBus = dsoSetUSBBus(DeviceIndex);
    dsoSetUSBBus(DeviceIndex);
    //std::cout << "SetUSBBus = "<< std::boolalpha <<SetUSBBus << std::endl;
    /*if ()
    {
        std::cout << "Success!" << std::endl;
    }
    else
    {
        std::cout << "Failed :(" << std::endl;
        //std::cout << "Success!" << std::endl;
        //return 1;
    }*/
    WORD InitADC = dsoInitADCOnce(DeviceIndex);
    if (InitADC != 0)
    {
        std::cout << "InitADCOnce Success!" << std::endl;
        //successArray[counter] = 1;
        
    }
    else
    {
        std::cout << "InitADCOnce Failed!" << std::endl;
    }
    //counter++;
    WORD CHMODGain = dsoHTADCCHModGain(DeviceIndex, 4);
    if (CHMODGain != 0)
    {
        std::cout << "HTADCCHModGain Success!" << std::endl;
        //successArray[counter] = 1;
        
    }
    else
    {
        std::cout << "HTADCCHModGain Failed!" << std::endl;
    }
    //counter++;
    WORD CHLevel[CAL_LEVEL_LEN];
    
    /*if (CHLevel[CAL_LEVEL_LEN - 1] != ZERO_FLAG) {
        //if(1){
        int xxxxxxx = 0;
        for (int i = 0; i < ZEROCALI_LEN; i++) {
            int nVolt = (i % ZEROCALI_PER_CH_LEN) / ZEROCALI_PER_VOLT_LEN;
            if (nVolt == 5 || nVolt == 8 || nVolt == 11) 
            {
                switch ((i % ZEROCALI_PER_CH_LEN) % ZEROCALI_PER_VOLT_LEN) 
                {
                case 0:
                    CHLevel[i] = 16602;
                    break;
                case 1:
                    CHLevel[i] = 60111;
                    break;
                case 2:
                    CHLevel[i] = 17528;
                    break;
                case 3:
                    CHLevel[i] = 59201;
                    break;
                case 4:
                    CHLevel[i] = 17710;
                    break;
                case 5:
                    CHLevel[i] = 58900;
                    break;
                default:
                    CHLevel[i] = 0;
                    break;
                }
            }
        }
    }*/
 
 
    WORD ReadCalibrationData = dsoHTReadCalibrationData(DeviceIndex,CHLevel, CAL_LEVEL_LEN);
    if (ReadCalibrationData != 0)
    {
        std::cout << "HTReadCalibrationData Success!" << std::endl;
        //successArray[counter] = 1;
        
    }
    else
    {
        std::cout << "HTReadCalibrationData Failed!" << std::endl;
    }
    //counter++;
 
    //инициализация структуры relaycontrol
    myRelayControl.bCHEnable[0] = 1;
    myRelayControl.bCHEnable[1] = 1;
    myRelayControl.bCHEnable[2] = 1;
    myRelayControl.bCHEnable[3] = 1;
 
    myRelayControl.nCHVoltDIV[0] = 7;
    myRelayControl.nCHVoltDIV[1] = 7;
    myRelayControl.nCHVoltDIV[2] = 7;
    myRelayControl.nCHVoltDIV[3] = 7;
 
    myRelayControl.nCHCoupling[0] = 0;
    myRelayControl.nCHCoupling[1] = 0;
    myRelayControl.nCHCoupling[2] = 0;
    myRelayControl.nCHCoupling[3] = 0;
    
    myRelayControl.bCHBWLimit[0] = 0;
    myRelayControl.bCHBWLimit[1] = 0;
    myRelayControl.bCHBWLimit[2] = 0;
    myRelayControl.bCHBWLimit[3] = 0;
 
    myRelayControl.nTrigSource = 0;
    
    myRelayControl.bTrigFilt = 0;
 
    myRelayControl.nALT = 0;
    
 
    //инициализация структуры controldata
    myControlData.nCHSet = 0x0F;//заводская установка
    myControlData.nTimeDIV = nTimeDiv;
    myControlData.nTriggerSource = 0;//заводская установка
    myControlData.nHTriggerPos = 50;//заводская установка
    myControlData.nVTriggerPos = 64;//заводская установка
    myControlData.nTriggerSlope = RISE;//заводская установка
    myControlData.nBufferLen = BUF_4K_LEN;//BUF_4K_LEN;//моя установка
    myControlData.nReadDataLen = BUF_4K_LEN;//BUF_4K_LEN;//моя установка
    myControlData.nAlreadyReadLen = BUF_4K_LEN; //BUF_4K_LEN;//моя установка
    myControlData.nALT = 0;//заводская установка
    myControlData.nFPGAVersion = 0xa000;//заводская установка
 
    /*    WORD nTimeDIV; //the index of time base
    WORD nTriggerSource; //the index of the trigger source
    WORD nHTriggerPos; //the horizontal trigger pos (Value:0~100)
    WORD nVTriggerPos; //the vertical trigger pos
    WORD nTriggerSlope; //the edge trigger slope(0 is rise slope, 1 is fall slope)
    ULONG nBufferLen; //the buffer length
    ULONG nReadDataLen; //the data length of data to be Read
    ULONG nAlreadyReadLen; //the data length of data having been read
    WORD nALT; //is alternate trigger of not
    WORD nETSOpen; //ETS enable/display（no use）*/
 
    
    WORD SetSampleRate = dsoHTSetSampleRate(DeviceIndex, pAmpLevel, 0, &myRelayControl, &myControlData);
    if (SetSampleRate != 0)
    {
        std::cout << "HTSetSampleRate Success!" << std::endl;
        //successArray[counter] = 1;
        
    }
    else
    {
        std::cout << "HTSetSampleRate Failed!" << std::endl;
    }
    //for
    //counter++;
 
    WORD SetCHAndTrigger = dsoHTSetCHAndTrigger(DeviceIndex, &myRelayControl, nTimeDiv);
    if (SetCHAndTrigger != 0)
    {
        std::cout << "HTSetCHAndTrigger Success!" << std::endl;
        //successArray[counter] = 1;
        
    }
    else
    {
        std::cout << "HTSetCHAndTrigger Failed!" << std::endl;
    }
    //counter++;
 
    WORD SetRamAndTrigerControl = dsoHTSetRamAndTrigerControl(DeviceIndex, nTimeDiv, myControlData.nCHSet, myControlData.nTriggerSource, 0);
    if (SetRamAndTrigerControl != 0)
    {
        std::cout << "HTSetRamAndTrigerControl Success!" << std::endl;
        //successArray[counter] = 1;
        
    }
    else
    {
        std::cout << "HTSetRamAndTrigerControl Failed!" << std::endl;
    }
    //counter++;
    WORD nCH = 128;//уровень нуля при замерах на ацп осциллографа
    WORD SetCHPos;
    for (int i = 0; i < MAX_CH_NUM; i++)
    {
        SetCHPos =dsoHTSetCHPos(DeviceIndex, CHLevel, myRelayControl.nCHVoltDIV[i], nCH, i, 4);
        if (SetCHPos != 0)
        {
            std::cout << "For channel "<<i<<" HTSetCHPos Success!" << std::endl;
            //successArray[counter] = 1;
 
        }
        else
        {
            std::cout << "For channel " << i << " HTSetCHPos Failed!" << std::endl;
        }
    }
    //= dsoHTSetCHPos(DeviceIndex, CHLevel, myRelayControl.nCHVoltDIV[0], 255, 0, 4);
   
    //counter++;
 
    WORD SetVTrigger = dsoHTSetVTriggerLevel(DeviceIndex, CHLevel, MAX_DATA-LPos[CH1], 4);
    if (SetVTrigger != 0)
    {
        std::cout << "HTSetVTriggerLevel Success!" << std::endl;
        //successArray[counter] = 1;
        
    }
    else
    {
        std::cout << "HTSetVTriggerLevel Failed!" << std::endl;
    }
    //counter++;
 
    WORD SetTriggerMode = dsoHTSetTrigerMode(DeviceIndex, EDGE, myControlData.nTriggerSlope, DC);
    if (SetTriggerMode != 0)
    {
        std::cout << "HTSetTrigerMode Success!" << std::endl;
        //successArray[counter] = 1;
        
    }
    else
    {
        std::cout << "HTSetTrigerMode Failed!" << std::endl;
    }
 
    /*WORD pCHPos[MAX_CH_NUM];
    for (int i = 0; i < MAX_CH_NUM; i++)
    {
        pCHPos[i] = 128;
    }
    WORD SetAmpCalibrate = dsoHTSetAmpCalibrate(DeviceIndex, myControlData.nCHSet, nTimeDiv, CHLevel, myRelayControl.nCHVoltDIV, pCHPos);
    if (SetAmpCalibrate != 0)
    {
        std::cout << "HTSetAmpCalibrate Success!" << std::endl;
        //successArray[counter] = 1;
 
    }
    else
    {
        std::cout << "HTSetAmpCalibrate Failed!" << std::endl;
    }*/
    //counter++;
 
    char cExit = 'y';
    /*while (true)
    {*/
        WORD StartCollectData = dsoHTStartCollectData(DeviceIndex, 2);
        if (StartCollectData != 0)
        {
            std::cout << "HTStartCollectData Success!" << std::endl;
            //successArray[counter] = 1;
        }
        else
        {
            std::cout << "HTStartCollectData Failed!" << std::endl;
        }
        std::cout << "GettingStatusOfDevice..." << std::endl;
        WORD GetState =0;
        /*std::cout.unsetf(std::ios::dec);
        std::cout.setf(std::ios::hex);*/
        while (GetState&0x02)
        {
            GetState = dsoHTGetState(DeviceIndex);
            std::cout << "GetState = "<< GetState << std::endl;
        }
        std::cout << "Status is ok, starting to read data" << std::endl;
        USHORT* pReadData[MAX_CH_NUM];
        for (int i = 0; i < MAX_CH_NUM; i++)
        {
            pReadData[i] = new USHORT[myControlData.nReadDataLen];
            memset(pReadData[i], 0, myControlData.nReadDataLen * sizeof(USHORT));
        }
        WORD GetData = dsoHTGetData(DeviceIndex, pReadData[CH1], pReadData[CH2], pReadData[CH3], pReadData[CH4], &myControlData);
 
        // = dsoHTGetData(DeviceIndex, &CH1Data, &CH2Data, &CH3Data, &CH4Data, &myControlData);
        if (GetData != 0)
        {
            std::cout << "HTGetData Success!" << std::endl;
            //std::cout << "GetData = " << GetData << std::endl;
        }
        else
        {
            std::cout << "HTGetData Failed!" << std::endl;
        }
        //(raw * inputRanges[ch]) / unit->maxValue;
        //double Channel1result = ((long)pReadData[CH1] * myRelayControl.nCHVoltDIV[CH1]) / 35;
        //int Channel1result = (*pReadData[CH1] + myControlData.nReadDataLen) - (MAX_DATA - 1);
        //float CH1Res = (((float)Channel1result - (3970)) / 100);
        //V = ADCval * VALmax / ADCmax.
        float ReadedData=0.0;
        float ReadedData2 = 0.0;
        ReadedData += *pReadData[CH1];
 
        ReadedData2 += *pReadData[CH2];
        /*float MLimit = 0.f;*/
        int VDiv = 0;
        VDiv += myRelayControl.nCHVoltDIV[CH1];
        /*MLimit += VDiv * 2;*/
        //double NumberOfDivs = 255.0 / VDiv;
        //double X = 255.0 / NumberOfDivs;
        //double nNumberOfDivs = 255 / 0.5;
        //int nVoltsMax = nNumberOfDivs * VDiv;
        //double Y = X / VDiv;
        
        double Volts2 = (ReadedData2 - 128) * (4.0 / 255.0);
        
        //int ADCval = (int)pReadData[CH1];
        //float CH1Res = (ReadedData-128)*(MLimit/128);
        std::cout << "Collected data from channels 1,2,3,4:" << std::endl;
        for (int i = 0; i < 4096; i++)
        {
            double Volts = (pReadData[CH1][i] - 128) * (4.0 / 255.0);
            cout << "ADCCH1 = " << pReadData[CH1][1] << " ADCCH2 = " << pReadData[CH2][i] << " ADCCH3 = " << pReadData[CH3][i] << " ADCCH4 = " << pReadData[CH4][i] << endl;
        }
        //std::cout << std::setprecision(10) <<"ADC = "<<ReadedData<<" Volts =  "<<Volts << " "<< Volts2 << " " <<pReadData[CH3][127] << " " <<pReadData[CH4] << " " << std::endl;
        //printf("%d", pReadData[CH1]);// вывод десятичного
       // std::cout << std::endl;
        for (int i = 0; i < MAX_CH_NUM; i++)
        {
            delete pReadData[i];
        }
       /* std::cout << "Would you like to read data again?(y/n):" << std::endl;
        std::cin >> cExit;*/
   /* }*/
    
 
    
    return 0;
 
}