Форум:

LTR22_Close(module1);
LTR22_Close(module2);
LTR_Close(hcrate);

LTR22Open = Указанный крейт не найден

hcrate = new TLTR();
int rez_crate = LTR_Init(hcrate);
if(rez_crate != 0)
cout << "!!!  ERROR crate LTR_Init = " << LTR22_GetErrorString(rez_crate) << endl;

int resopen = LTR_OpenSvcControl(hcrate, 0x7f000001, 11111);
cout << "LTR_OpenSvcControl = " << resopen << endl;

int rezcrate = LTR_ResetModule(hcrate, LTR_CRATE_IFACE_TCPIP, "", 1, 0);
cout << "LTR_ResetModule 1 = " << rezcrate << endl;
rezcrate = LTR_ResetModule(hcrate, LTR_CRATE_IFACE_TCPIP, "", 2, 0);
cout << "LTR_ResetModule 2 = " << rezcrate << endl;

LTR_OpenSvcControl = 0
LTR_ResetModule 1 = -14
LTR_ResetModule 2 = -14

        hcrate = new TLTR();
        module1 = new TLTR22(); // создаем структуру в памяти
        //memset(module1,0,sizeof(TLTR22));
        LTR22_Init(module1);
        module2 = new TLTR22(); // создаем структуру в памяти
        //memset(module2,0,sizeof(TLTR22));
        LTR22_Init(module2);

        module1->Channel.saddr = 0x7f000001; //127.0.0.1
        module1->Channel.sport = 11111;

        module1->Channel.csn[0] = '6';
        module1->Channel.csn[1] = 'T';
        module1->Channel.csn[2] = '7';
        module1->Channel.csn[3] = '6';
        module1->Channel.csn[4] = '9';
        module1->Channel.csn[5] = '6';
        module1->Channel.csn[6] = '5';
        module1->Channel.csn[7] = '1';
        module1->Channel.cc = 1;


        module2->Channel.saddr = 0x7f000001; //127.0.0.1
        module2->Channel.sport = 11111;

        module2->Channel.csn[0] = '6';
        module2->Channel.csn[1] = 'T';
        module2->Channel.csn[2] = '7';
        module2->Channel.csn[3] = '6';
        module2->Channel.csn[4] = '9';
        module2->Channel.csn[5] = '6';
        module2->Channel.csn[6] = '5';
        module2->Channel.csn[7] = '1';
        module2->Channel.cc = 2;

        DataModul1 = new double[32000*4];
        DataModul2 = new double[32000];

    int rez1=LTR22_Close(module1);
    int rez2=LTR22_Close(module2);
    rez1=LTR22_Open(module1, module1->Channel.saddr, module1->Channel.sport, module1->Channel.csn, module1->Channel.cc);
    rez2=LTR22_Open(module2, module2->Channel.saddr, module2->Channel.sport, module2->Channel.csn, module2->Channel.cc);

 //modul1

    rez1 = LTR22_SwitchMeasureADCZero(module1, false);
    rez1 = LTR22_SwitchACDCState(module1, true);
    rez1 = LTR22_SetADCChannel(module1,0,true);
    rez1 = LTR22_SetADCChannel(module1,1,true);
    rez1 = LTR22_SetADCChannel(module1,2,true);
    rez1 = LTR22_SetADCChannel(module1,3,true);
    rez1 = LTR22_SetFreq(module1,true, 2);
    rez1=LTR22_SetADCRange(module1, 0, 4); //  +-10B
    rez1=LTR22_SetADCRange(module1, 1, 4);
    rez1=LTR22_SetADCRange(module1, 2, 4);
    rez1=LTR22_SetADCRange(module1, 3, 4);
    rez1=LTR22_GetConfig(module1);

 //modul2
    rez2 = LTR22_SwitchMeasureADCZero(module2, false);
    rez2 = LTR22_SwitchACDCState(module2, true);
    rez2 = LTR22_SetADCChannel(module2,0,true);
    rez2 = LTR22_SetADCChannel(module2,1,false);
    rez2 = LTR22_SetADCChannel(module2,2,false);
    rez2 = LTR22_SetADCChannel(module2,3,false);

    rez2 = LTR22_SetFreq(module2,true, 2);
    rez2=LTR22_SetADCRange(module2, 0, 4);
    rez2=LTR22_GetConfig(module2);

//crate
    rez_crate = LTR_Init(hcrate);
    rez_crate = LTR_OpenCrate(hcrate, 0x7f000001, 11111, 2, "");

// старт сбора данных
    rez = LTR22_StartADC(module1, false);
    rez = LTR22_StartADC(module2, false);
    rez_crate = LTR_StartSecondMark(hcrate, LTR_MARK_EXT_DIGIN1_FALL);//по спаду DIGIN1

//в отдельном потоке для каждого модуля   
    
    // старт сбора данных
    bool flag_out = true;
    int module_en_ch_cnt = 4; /* кол-во разрешенных каналов в модуле */
    int module_num = 0;/* номер модуля, 0 или 1 */
    DWORD rbuf[4*BLOCK_RX_CH_WORDS_CNT];
    DWORD tstmp[4*BLOCK_RX_CH_WORDS_CNT];
    double *proc_buf = new double[4*BLOCK_RX_CH_WORDS_CNT];
    DWORD last_tstmp[2]; /* сохранение tstmp для отслеживания изменения по каждому модулю. Нужно сохранять, т.к. может изменится на границе блоков! */
    bool last_tstmp_valid[2] = {false, false}; /* признак, что инициализировали значение last_tstmp */
    double pt;
    //byte OverflowFlags[4];
    byte *OverflowFlags = new byte[4];
    
    while (flag_out)
    {
        //возвращает количество полученных данных
        int recvd = LTR22_Recv(dev_ConnectLcard->module1, rbuf, tstmp, module_en_ch_cnt * BLOCK_RX_CH_WORDS_CNT, 2000);
       cout << "количество полученных данных MODUL 1 = " << recvd << endl;
        if (recvd > 0)
        {
            /* если еще значение метки не инициализировано, то иницизируем первым принятым значением */
            if (!last_tstmp_valid[module_num])
            {
                cout << " init metka " << endl;
                last_tstmp[module_num] = tstmp[0] & 0xFFFF; /* используем только младшие 16 бит - метку СЕКУНДА без учета метки СТАРТ */
                last_tstmp_valid[module_num] = true;
            }

            /* обработка данных */
            rez = LTR22_ProcessData(dev_ConnectLcard->module1, rbuf, proc_buf, recvd, true, true, OverflowFlags);
            if(rez != 0) cout << "!!!  ERROR MODUL 1 LTR22_ProcessData = " << LTR22_GetErrorString(rez) << endl;

            /* быстрая проверка, изменилась ли метка, сравнивая метку на конец блока с последней действительной. */
             if (last_tstmp[module_num]  != (tstmp[recvd-1] & 0xFFFF))
            {
                /* ищем момент изменения метки - для простоты примера просто проходим по всем элементам без каких-то ускоренных поисков */
                for (int i = 0; i < recvd; ++i)
                {
                    if (last_tstmp[module_num]  != (tstmp[i] & 0xFFFF))
                    {
                         flag_out = false;
                      
                        cout << "количество полученных данных MODUL 1 = " << recvd << endl;

                        last_tstmp[module_num] = tstmp[i] & 0xFFFF;
                        /* обновляем последнее значение метки */
                        /* метка изменилась на i-ом элементе */
                        /* полчаем позицию в массиве на канал после обработки */
                        int proc_ch_pos = (i / module_en_ch_cnt);
                        cout << "!!!!!!!   proc_ch_pos = " << proc_ch_pos << endl;
                        for (int ch_num = 0; ch_num < module_en_ch_cnt; ++ch_num)
                        {
                            /* для каждого канала получаем точку за изменением метки времени.
                                если нужно более одной точки то можем пройтись по позиции с  proc_ch_pos до proc_ch_pos + N,
                                но должны учитывать, что следующие точки могут выйти за границу блока,
                                принятого в этот раз. Тогда нужно ставить флаг для модуля, что обработать еще сколько-то
                                точек из следующего блока */
                            for(int point = 0; point<32000-proc_ch_pos; point++)
                            {
                                pt = proc_buf[recvd/module_en_ch_cnt * ch_num + proc_ch_pos + point];
                                /* сохраняем полученную точку или обрабатываем другим требуемым образом */
                                dev_ConnectLcard->DataModul1[32000*ch_num + point] = pt;
                                
                            }
                        }
                    }
                    i = recvd;
                }
            }
        }
    }
    
//в основном потоке
    rez = LTR_StopSecondMark(hcrate); /* останов меток (может быть и после останова модулей) */
    rez = LTR22_StopADC(module1);         /* останов сбора*/
    rez = LTR22_ClearBuffer(module1,true); /* очистка буфера */
    rez = LTR22_StopADC(module2);         // останов сбора
    rez = LTR22_ClearBuffer(module2,true); // очистка буфера
        
    rez1=LTR22_Close(module1);
    rez2=LTR22_Close(module2);
    rez_crate = LTR_Close(hcrate);

<ltrsrv_config>
<log>
<level> 3 </level>
</log>
<crate_ip_entries>
<ip autocon="1"> 192.168.1.2 </ip>
</crate_ip_entries>
<intf_eth_params>
<intf_check_time> 1000 </intf_check_time>
<crate_poll_time> 15000 </crate_poll_time>
<crate_conection_timeout> 5000 </crate_conection_timeout>
<crate_ctlcmd_timeout> 5000 </crate_ctlcmd_timeout>
</intf_eth_params>
</ltrsrv_config>

        TLTR22* module = new TLTR22(); 
        memset(module,0,sizeof(TLTR22));
        int res=0;

        module->Channel.saddr = 0x7f000001; //127.0.0.1  сетевой адрес сервера
        module->Channel.sport = 11111;
        module->Channel.csn[0] = '6';
        module->Channel.csn[1] = 'T';
        module->Channel.csn[2] = '7';
        module->Channel.csn[3] = '6';
        module->Channel.csn[4] = '9';
        module->Channel.csn[5] = '6';
        module->Channel.csn[6] = '5';
        module->Channel.csn[7] = '1';
        module->Channel.cc = 1;

        res=LTR22_Open(module, module->Channel.saddr, module->Channel.sport, module->Channel.csn, module->Channel.cc);