возможно ли получая данные с двух каналов АЦП е14-440 сразу перемножать их между собой и записывать в текстовый файл уже результаты умножения???

Все возможно. Как программу напишите так и будет. Только сразу да в текстовый возможно будет медленно...те скорость работы АЦП невысокая будет чтобы непрерывный поток писать...

То что возможно уже очень здорово))хотелось бы узнать что должна быть за запись,что то вроде Y[i]=X[i]*X[i+1],только никак не могу это объявить чтобы было понятно X[i] первый канал X[i+1] второй не могли бы вы подсказать,вот часть программки
void main(void)
{
    WORD i;
//    WORD DacSample;

    // сбросим флажок завершения потока ввода данных
    IsReadThreadComplete = false;
    // пока ничего не выделено под буфер данных
    ReadBuffer = NULL;
    // пока не создан поток ввода данных
    hReadThread = NULL;
    // пока откытого файла нет
    hFile = INVALID_HANDLE_VALUE;
    // сбросим флаг ошибок потока ввода данных
    ReadThreadErrorNumber = 0x0;

    // зачистим экран монитора
    clrscr();

    printf(" *******************************//n");
    printf(" Module E14-440                 //n");
    printf(" Console example for ADC Stream //n");
    printf(" *******************************//n//n");

    // проверим версию используемой библиотеки Lusbapi.dll
    if((DllVersion = GetDllVersion()) != CURRENT_VERSION_LUSBAPI)
    {
        char String[128];
        sprintf(String, " Lusbapi.dll Version Error!!!//n   Current: %1u.%1u. Required: %1u.%1u",
                                            DllVersion >> 0x10, DllVersion & 0xFFFF,
                                            CURRENT_VERSION_LUSBAPI >> 0x10, CURRENT_VERSION_LUSBAPI & 0xFFFF);

        AbortProgram(String);
    }
    else printf(" Lusbapi.dll Version --> OK//n");

    // попробуем получить указатель на интерфейс
    pModule = static_cast<ILE440 *>(CreateLInstance("e440"));
    if(!pModule) AbortProgram(" Module Interface --> Bad//n");
    else printf(" Module Interface --> OK//n");

    // попробуем обнаружить модуль E14-440 в первых MAX_VIRTUAL_SLOTS_QUANTITY_LUSBAPI виртуальных слотах
    for(i = 0x0; i < MAX_VIRTUAL_SLOTS_QUANTITY_LUSBAPI; i++) if(pModule->OpenLDevice(i)) break;
    // что-нибудь обнаружили?
    if(i == MAX_VIRTUAL_SLOTS_QUANTITY_LUSBAPI) AbortProgram(" Can//'t find any module E14-440 in first 127 virtual slots!//n");
    else printf(" OpenLDevice(%u) --> OK//n", i);

    // попробуем прочитать дескриптор устройства
    ModuleHandle = pModule->GetModuleHandle();
    if(ModuleHandle == INVALID_HANDLE_VALUE) AbortProgram(" GetModuleHandle() --> Bad//n");
    else printf(" GetModuleHandle() --> OK//n");

    // прочитаем название модуля в обнаруженном виртуальном слоте
    if(!pModule->GetModuleName(ModuleName)) AbortProgram(" GetModuleName() --> Bad//n");
    else printf(" GetModuleName() --> OK//n");
    // проверим, что это //'E14-440//'
    if(strcmp(ModuleName, "E440")) AbortProgram(" The module is not //'E14-440//'//n");
    else printf(" The module is //'E14-440//'//n");

    // попробуем получить скорость работы шины USB
    if(!pModule->GetUsbSpeed(&UsbSpeed)) AbortProgram(" GetUsbSpeed() --> Bad//n");
    else printf(" GetUsbSpeed() --> OK//n");
    // теперь отобразим скорость работы шины USB
    printf("   USB is in %s//n", UsbSpeed ? "High-Speed Mode (480 Mbit/s)" : "Full-Speed Mode (12 Mbit/s)");

    // код LBIOS//'а возьмём из соответствующего ресурса штатной DLL библиотеки
    if(!pModule->LOAD_MODULE()) AbortProgram(" LOAD_MODULE() --> Bad//n");
    else printf(" LOAD_MODULE() --> OK//n");

    // проверим загрузку модуля
    if(!pModule->TEST_MODULE()) AbortProgram(" TEST_MODULE() --> Bad//n");
    else printf(" TEST_MODULE() --> OK//n");

    // получим информацию из ППЗУ модуля
    if(!pModule->GET_MODULE_DESCRIPTION(&ModuleDescription)) AbortProgram(" GET_MODULE_DESCRIPTION() --> Bad//n");
    else printf(" GET_MODULE_DESCRIPTION() --> OK//n");

    // получим текущие параметры работы АЦП
    if(!pModule->GET_ADC_PARS(&ap)) AbortProgram(" GET_ADC_PARS() --> Bad//n");
    else printf(" GET_ADC_PARS() --> OK//n");

    // установим желаемые параметры работы АЦП
    ap.IsCorrectionEnabled = TRUE;            // разрешим корректировку данных на уровне драйвера DSP
    ap.InputMode = NO_SYNC_E440;                // обычный сбор данных безо всякой синхронизации ввода
    ap.ChannelsQuantity = 0x2;                    // четыре активных канала
    // формируем управляющую таблицу
           for(i = 0x0; i < ap.ChannelsQuantity; i++)
              ap.ControlTable[i] = (WORD)(i | (ADC_INPUT_RANGE_2500mV_E440 << 0x6 | i<<0x5));

    ap.AdcRate = 400.0;                            // частота работы АЦП в кГц
    ap.InterKadrDelay = 0.0;                    // межкадровая задержка в мс
    ap.AdcFifoBaseAddress = 0x0;                  // базовый адрес FIFO буфера АЦП в DSP модуля
    ap.AdcFifoLength = MAX_ADC_FIFO_SIZE_E440; // длина FIFO буфера АЦП в DSP модуля
    // будем использовать фирменные калибровочные коэффициенты, которые храняться в ППЗУ модуля
    for(i = 0x0; i < ADC_CALIBR_COEFS_QUANTITY_E440; i++)
    {
        ap.AdcOffsetCoefs[i] =  ModuleDescription.Adc.OffsetCalibration[i];
        ap.AdcScaleCoefs[i] =  ModuleDescription.Adc.ScaleCalibration[i];
    }

    // передадим требуемые параметры работы АЦП в модуль
    if(!pModule->SET_ADC_PARS(&ap)) AbortProgram(" SET_ADC_PARS() --> Bad//n");
    else printf(" SET_ADC_PARS() --> OK//n");

    // выделим память под буфер
    ReadBuffer = new SHORT[2*DataStep];
    if(!ReadBuffer) AbortProgram(" Can not allocate memory//n");

    // откроем файл для записи получаемых с модуля данных
    hFile = CreateFile("Test.dat", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN | FILE_FLAG_WRITE_THROUGH, NULL);
    if(hFile == INVALID_HANDLE_VALUE) AbortProgram("//n Can//'t create file //'Test.dat//'!//n");

    // Создаём и запускаем поток сбора данных
    printf(" //n");
    hReadThread = CreateThread(0, 0x2000, ServiceReadThread, 0, 0, &ReadTid);
    if(!hReadThread) AbortProgram(" ServiceReadThread() --> Bad//n");
    else printf(" ServiceReadThread() --> OK//n");

    // отобразим параметры сбора данных модуля на экране монитора
    printf(" //n");
    printf(" Module E14-440 (S/N %s) is ready ... //n", ModuleDescription.Module.SerialNumber);
    printf("   Module Info://n");
    printf("     Module  Revision   is //'%c//'//n", ModuleDescription.Module.Revision);
    printf("     MCU Driver Version is %s (%s)//n", ModuleDescription.Mcu.Version.Version, ModuleDescription.Mcu.Version.Date);
    printf("     LBIOS   Version    is %s (%s)//n", ModuleDescription.Dsp.Version.Version, ModuleDescription.Dsp.Version.Date);
    printf("   Adc parameters://n");
    printf("     Data Correction is %s//n", ap.IsCorrectionEnabled ? "enabled" : "disabled");
    printf("     ChannelsQuantity = %2d//n", ap.ChannelsQuantity);
    printf("     AdcRate = %8.3f kHz//n", ap.AdcRate);
    printf("     InterKadrDelay = %2.4f ms//n", ap.InterKadrDelay);
    printf("     KadrRate = %8.3f kHz//n", ap.KadrRate);

    // цикл записи получаемых данных и ожидания окончания работы приложения
//    DacSample = 0x1000;
    printf("//n Press any key if you want to terminate this program...//n//n");
    while(!IsReadThreadComplete)
    {
        if(OldCounter != Counter) { printf(" Counter %3u from %3u//r", Counter, NDataBlock); OldCounter = Counter; }
        else Sleep(20);
//        if(!pModule->ENABLE_TTL_OUT(TRUE)) AbortProgram(" Ошибка разрешения выходных цифровых линий");
//        if(!pModule->TTL_OUT(0xFFFF)) AbortProgram(" Ошибка установки выходных цифровых линий");
//        if(!pModule->TTL_OUT(0x0000)) AbortProgram(" Ошибка установки выходных цифровых линий");
//        if(!pModule->DAC_SAMPLE((SHORT *)&DacSample, 0x0)) AbortProgram(" Ошибка установки канала ЦАП");
    }

    // ждём окончания работы потока ввода данных
    WaitForSingleObject(hReadThread, INFINITE);

    // проверим была ли ошибка выполнения потока сбора данных
    printf("//n//n");
    if(ReadThreadErrorNumber) { AbortProgram(NULL, false); ShowThreadErrorMessage(); }
    else AbortProgram(" The program was completed successfully!!!//n", false);
}

//-- ----------------------------------------------------------------------
// Поток, в котором осуществляется сбор данных
//-- ----------------------------------------------------------------------
DWORD WINAPI ServiceReadThread(PVOID /*Context*/)
{
    WORD i;
    WORD RequestNumber;
    DWORD FileBytesWritten;
    // массив OVERLAPPED структур из двух элементов
    OVERLAPPED ReadOv[2];
    // массив структур с параметрами запроса на ввод/вывод данных
    IO_REQUEST_LUSBAPI IoReq[2];

        //Создаем указатель на текстовый файл
        fl=fopen("Text.txt","wt");

    // остановим работу АЦП и одновременно сбросим USB-канал чтения данных
    if(!pModule->STOP_ADC()) { ReadThreadErrorNumber = 0x1; IsReadThreadComplete = true; return 0x0; }

    // формируем необходимые для сбора данных структуры
    for(i = 0x0; i < 0x2; i++)
    {
        // инициализация структуры типа OVERLAPPED
        ZeroMemory(&ReadOv[i], sizeof(OVERLAPPED));
        // создаём событие для асинхронного запроса
        ReadOv[i].hEvent = CreateEvent(NULL, FALSE , FALSE, NULL);
        // формируем структуру IoReq
        IoReq[i].Buffer = ReadBuffer + i*DataStep;
        IoReq[i].NumberOfWordsToPass = DataStep;
        IoReq[i].NumberOfWordsPassed = 0x0;
        IoReq[i].Overlapped = &ReadOv[i];
        IoReq[i].TimeOut = DataStep/ap.AdcRate + 1000;
    }

    // делаем предварительный запрос на ввод данных
    RequestNumber = 0x0;
    if(!pModule->ReadData(&IoReq[RequestNumber])) { CloseHandle(ReadOv[0].hEvent); CloseHandle(ReadOv[1].hEvent); ReadThreadErrorNumber = 0x2; IsReadThreadComplete = true; return 0x0; }

    // запустим АЦП
    if(pModule->START_ADC())
    {
        // цикл сбора данных
        for(i = 0x1; i < NDataBlock; i++)
        {
            // сделаем запрос на очередную порцию данных
            RequestNumber ^= 0x1;
            if(!pModule->ReadData(&IoReq[RequestNumber])) { ReadThreadErrorNumber = 0x2; break; }
            if(ReadThreadErrorNumber) break;

            // ждём завершения операции сбора предыдущей порции данных
            if(WaitForSingleObject(ReadOv[RequestNumber^0x1].hEvent, IoReq[RequestNumber^0x1].TimeOut) == WAIT_TIMEOUT) { ReadThreadErrorNumber = 0x3; break; }
            if(ReadThreadErrorNumber) break;

            // запишем полученную порцию данных в файл
            if(!WriteFile(    hFile,                                                    // handle to file to write to
                                IoReq[RequestNumber^0x1].Buffer,                    // pointer to data to write to file
                                2*DataStep,                                                 // number of bytes to write
                                &FileBytesWritten,                                    // pointer to number of bytes written
                               NULL                                                          // pointer to structure needed for overlapped I/O
                               )) { ReadThreadErrorNumber = 0x4; break; }

                        //fprintf(fl,"%d//t",RequestNumber);
                        for(int ii=0;ii<1024;ii++)
                        Y[i]=X[i]+Y[i+1];
                                fprintf(fl,"%d//t",IoReq[RequestNumber^0x1].Buffer[ii]);
                        fprintf(fl,"//n");

            if(ReadThreadErrorNumber) break;
            else if(kbhit()) { ReadThreadErrorNumber = 0x5; break; }
            else Sleep(20);
            Counter++;
        }

        // последняя порция данных
        if(!ReadThreadErrorNumber)
        {
            RequestNumber ^= 0x1;
            // ждём окончания операции сбора последней порции данных
            if(WaitForSingleObject(ReadOv[RequestNumber^0x1].hEvent, IoReq[RequestNumber^0x1].TimeOut) == WAIT_TIMEOUT) ReadThreadErrorNumber = 0x3;
            // запишем последнюю порцию данных в файл
            if(!WriteFile(    hFile,                                                    // handle to file to write to
                                IoReq[RequestNumber^0x1].Buffer,                    // pointer to data to write to file
                                2*DataStep,                                                 // number of bytes to write
                                &FileBytesWritten,                                    // pointer to number of bytes written
                               NULL                                                          // pointer to structure needed for overlapped I/O
                               )) ReadThreadErrorNumber = 0x4;

                        for(int ii=0;ii<1024;ii++)
                                fprintf(fl,"%d//t",IoReq[RequestNumber^0x1].Buffer[ii]);
                        fprintf(fl,"//n");
                       
            Counter++;
        }
    }
    else { ReadThreadErrorNumber = 0x6; }

    // остановим работу АЦП
    if(!pModule->STOP_ADC()) ReadThreadErrorNumber = 0x1;
    // прервём возможно незавершённый асинхронный запрос на приём данных
    if(!CancelIo(ModuleHandle)) { ReadThreadErrorNumber = 0x7; }
    // освободим все идентификаторы событий
    for(i = 0x0; i < 0x2; i++) CloseHandle(ReadOv[i].hEvent);
    // небольшая задержка
    Sleep(100);
        //Закроем поток
        fclose(fl);
    // установим флажок завершения работы потока сбора данных
    IsReadThreadComplete = true;
    // теперь можно спокойно выходить из потока
    return 0x0;
}

x[i] * x [i+1], i=i+2

можно чуть подробнее,забыл совсем С++ ,ничего не получается.X сначала ведь нужно присвоить значения которые где то хранятся потом еще они должны уже сразу умноженными записываться

Ну x это данные в Buffer я так понимаю. а так цикл for(i=0;i+=2;i<DataStep) по прочитанным буферам...

Все значения с АЦП сначала записываются в READBUFFER ,buffer это указатель на буфер данных.Т.е мне нужно в какой то части программы сделать цикл в котором переписать ReadBuffer,Но поймет ли программа чему равны X,мне же надо и им присваивать значения из READBUFFER