Форум: Техническая поддержка

Добрый день!
В перечне возможных ОС для работы с Lcard указана Astra Linux. Но переходя по ссылке с дистрибутивами http://download.opensuse.org/repositories/home:/l-card/ раздел с данной ОС не нахожу. Прошу помощи
Если важно:    LTR-EU-2-5         LTR22

Здравствуйте.

Да, отдельно дистрибутива Astra Linux там нет, но Astra основана на Debian и для нее подходят пакеты от Debian. Просто можете выбрать ближайшую к используемой у Вас версию Debian (например, по версии ядра - https://ru.wikipedia.org/wiki/Debian#%D … %80%D0%B0) и ставьте пакеты оттуда.

Спасибо.
Установлены все пакеты из http://download.opensuse.org/repositori … _10/amd64/
Написан мини код.

#include <ltr22api.h>
TLTR22 * module = new TLTR22();
int rez = LTR22_Init(module);

При компиляции возникает ошибка:
undefined reference to `LTR22_Init'

В Makefail указанна ссылка на каталог с файлом ltr22api.h
INC_DIR_USER= -I . \
                -I /usr/local/include/modbus \
                -I /usr/include/ltr/include

В чем может быть проблема?

Если в коде оставить только строку:
TLTR22 * module = new TLTR22();
то компилиться.

Помимо указания пути к заголовочным файлам, необходимым для компиляции, Вам еще нужно указать линковщику библиотеку, где ему искать реализацию функций. Это делается с помощью флага -l<имя библиотеки> (тут маленькая L, а не I), в данном случае -lltr22api (если используете функции базой библиотеки LTR_xxx, то также и -lltrapi).

Я не знаю структуру Вашего Makefile, обычно так же как и с INC_DIR_USER делается отдельная переменная (например с именем LIB, LIBS, LIBRARIES или что-то типа того) со списком библиотек, которая дальше аналогично INC_DIR_USER используется при вызове gcc. По идее, если Вы используете библиотеку modbus и она не случайно попала в INC_DIR_USER, то для нее уже это должно быть сделано и она уже должна присутствовать и в переменной со списком библиотек, тогда туда и библиотеки LTR нужно добавить.

Спасибо, библиотеки прописала - код скомпилился.
Но результат функции LTR22_Open = -14 (LTR_ERROR_INVALID_CRATE - Указанный крейт не найден)

В Windows LTR Manager видит подключение модуля с IP-192.168.1.2 с двумя крейтами.
[img]file:///home/Lcard/1.jpg[/img]

На AstraLinux я адрес 192.168.1.2  прописываю в файле /etc/ltrd/congig.xml:

<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);

       
Результат -14
При этом узел 192.168.1.2 пингуется

config.xml конечно же

Картинка не вставилась...

Не до конца понял, скриншот LTR Manager - это из Windows или Linux? Windows и Linux - это один ПК или это с разных машин?
На Astra Вы можете установить LTR Manager или там нет графического интерфейса, а только консоль? Если только консоль, то можно для действий, аналогичных LTR Manager, использовать консольную утилиту ltrctl (см. https://www.lcard.ru/download/ltr_cross_sdk.pdf), которая позволяет посмотреть подключенные крейты, добавить запись с IP адресом и установить соединение. В первую очередь нужно убедиться, что с крейтом установлено соединение из службы в Astra и крейт в списке активных крейтов.
На всякий случай, если Windows и Linux - разные машины, то одновременно с крейтом может установить соединение только одна служба, т.е. нужно тогда отключить соединение с керйтом в LTR Manager в Windows, затем уже установить соединение через LTR Manager/ltrctl/функции ltrapi из под Linux (можно и через xml файл, но для этого нужно также перезапустить службу и с синтаксисом все корректно написать, лучше все же делать через ПО).

Скриншот был из Windows. Компьютер один.
Отключилась в Windows, запустила в Linux LTR Manager, настроила, отключила/включила питание модуля и все заработало - спасибо

Подскажите, пожалуйста, как часто нужно выполнять команду LTR22_SyncPhaze ?
Перед каждым синхроимпульсом старта или достаточно после выключения/включения питания?

Здравствуйте. Процедуру синхронизации согласно  https://www.lcard.ru/download/ltr22api.pdf , гл.3, требуется выполнять однократно в начале очередного цикла сбора данных. После этой процедуры модули LTR22, находящиеся в одном крейте, синхронизируются, и далее, в течение текущего цикла сбора данных их синхронизация сохраняется. Описание возможностей синхронизации см. в https://www.lcard.ru/download/ltr.pdf пп. 13.3.1.5, 13.3.1.6.

Отредактировано Инженер (15.03.2022 07:37:49)

Добрый вечер!
Собран следующий макет:
    - к четырем каналам модуля 1 подключен генератор с импульсами амплитудой 4В и длительностью основания 3 секунды
    - каналу 1 модуля 2 подключено постоянное напряжение 4В
    - в качестве синхросигнала подается импульс от генератора ипульса с длительностью 10 мс с периодом раз в 3 секунды
    - на крейте установлен режим генерации метки "Старт" по спаду сигнала  DIGIN1 (LTR_MakeStartMark(hcrate, 2)).

В LTR Manager видно, что увеличивается количество метки "Старт" так же с периодом раз в 3 секунды.

При попытке провести фазировку модулей с периодом ожидания 10 секунд (LTR22_SyncPhaze(module, 10000)) выдается ошибка "Нет ответа на переданную команду".

Так же при попытке считать данные. Выполняю TR22_StartADC(module,true), жду 10 секунд, пытаюсь считать данные LTR22_Recv(module, rbuf1, NULL, 1000, 500),  ответ равен 0, т.е. данные не получены.

Оба модуля работают в режиме Slave.
Код прилагаю. Для чистоты кода убрала все проверки, все команды отрабатывают без ошибок. В чем может быть причина? Что упускаю?

        
        TLTR * hcrate;
        TLTR22 * module1;
        TLTR22 * module2;

        hcrate = new TLTR();

        module1 = new TLTR22();
        memset(module1,0,sizeof(TLTR22));

        module2 = new TLTR22();
        memset(module2,0,sizeof(TLTR22));

        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;
//блок 1 начало
        LTR_Init(hcrate);
        LTR_OpenCrate(hcrate, 0x7f000001, 11111, 2, "");
        LTR_MakeStartMark(hcrate, 2);// LTR_MARK_EXIT_DIGIN1_FALL);


        LTR22_Open(module1, module1->Channel.saddr, module1->Channel.sport, module1->Channel.csn, module1->Channel.cc);
        LTR22_Open(module2, module2->Channel.saddr, module2->Channel.sport, module2->Channel.csn, module2->Channel.cc);

        LTR22_SwitchACDCState(module1, true);
        LTR22_SetADCChannel(module1,0,true);
        LTR22_SetADCChannel(module1,1,true);
        LTR22_SetADCChannel(module1,2,true);
        LTR22_SetADCChannel(module1,3,true);
        LTR22_SetFreq(module1,false, 1); // тестировали в этими значениями, но потом посчитали что должны быть "true, 2"
        LTR22_SetADCRange(module1, 0, 4);
        LTR22_SetADCRange(module1, 1, 4);
        LTR22_SetADCRange(module1, 2, 4);
        LTR22_SetADCRange(module1, 3, 4);
        LTR22_GetConfig(module1);

        LTR22_SwitchACDCState(module2, true);
        LTR22_SetADCChannel(module2,0,true);
        LTR22_SetADCChannel(module2,1,false);
        LTR22_SetADCChannel(module2,2,false);
        LTR22_SetADCChannel(module2,3,false);
        LTR22_SetFreq(module2,false, 1);  // тестировали в этими значениями, но потом посчитали что должны быть "true, 2"
        LTR22_SetADCRange(module2, 0, 4);
        LTR22_GetConfig(module2);
//блок 1 конец


        //по команде оператора одновременно создаются 2 потока для фазировки модулей
        //поток 1
        LTR22_SetSyncPriority(dev_ConnectLcard->module1, false); //- режим slave
        rez = LTR22_SyncPhaze(dev_ConnectLcard->module1, 10000);
        cout << "!!!  ERROR 1 LTR22_SyncPhaze = " << LTR22_GetErrorString(rez) << endl;
        //ответ через 10 секунд "Нет ответа на переданную команду"
        //поток 2
        LTR22_SetSyncPriority(dev_ConnectLcard->module2, false); //- режим slave
        rez = LTR22_SyncPhaze(dev_ConnectLcard->module2, 10000);
        cout << "!!!  ERROR 2 LTR22_SyncPhaze = " << LTR22_GetErrorString(rez) << endl;
        //ответ через 10 секунд "Нет ответа на переданную команду"

        //после завершения потоков 1 и 2:
        LTR22_Close(module1);
        LTR22_Close(module2);
        LTR_Close(hcrate);


        //по команде оператора запускается сбор данных
        //повторяется блок 1
        LTR22_SetSyncPriority(dev_ConnectLcard->module1, false); //- режим slave
        LTR22_SetSyncPriority(dev_ConnectLcard->module2, false); //- режим slave
        LTR22_StartADC(dev_ConnectLcard->module1,true);
        LTR22_StartADC(dev_ConnectLcard->module2,true);
        usleep(10000000);

        DWORD rbuf1[1000];
        double *rbuf1_ = new double[4000];
        DWORD rbuf2[1000];
        double *rbuf2_ = new double[1000];
        number_values_1 = LTR22_Recv(dev_ConnectLcard->module1, rbuf1, NULL, 1000, 500);
        cout << "rez 1 LTR22_Recv   Количество полученных значений = " << number_values_1 << endl;
        //ответ  Количество полученных значений = 0
        number_values_2 = LTR22_Recv(dev_ConnectLcard->module2, rbuf2, NULL, 1000, 500);
        cout << "rez 2 LTR22_Recv   Количество полученных значений = " << number_values_2 << endl;
        //ответ  Количество полученных значений = 0

        LTR22_StopADC(dev_ConnectLcard->module1);
        LTR22_StopADC(dev_ConnectLcard->module2);
        LTR22_ClearBuffer(dev_ConnectLcard->module1,true); //true/false - ожиданте отклика
        LTR22_ClearBuffer(dev_ConnectLcard->module2,true); //true/false - ожиданте отклика

        if(number_values_1 == 1000 && number_values_2 == 1000)
        {
            LTR22_ProcessData(dev_ConnectLcard->module1, rbuf1, rbuf1_, 1000, false, false, NULL);
            LTR22_ProcessData(dev_ConnectLcard->module2, rbuf2, rbuf2_, 1000, false, false, NULL);
        }
        delete[] rbuf1_;
        delete[] rbuf2_;
        
        LTR22_Close(module1);
        LTR22_Close(module2);
        LTR_Close(hcrate);


        delete module1;
        delete module2;
        delete hcrate;

Существует два механизма межмодульной синхронизации, которые друг с другом не связаны.
1. Механизм синхронизации данных по меткам. Это универсальный механизм для всех модулей, который позволяет привязать данные с точностью до одного периода дискретизации (при этом на саму частоту и запуск сбора не влияет). Для этого механизма как раз может использоваться разъем SYNC самого крейта и к нему относится функция LTR_MakeStartMark(). В нем сбор данных запускается независимо для каждого модуля обычным способом и после уже определяется момент метки в данных по изменению счетчика меток в Recv (этот способ описан в разделе 4.6 https://www.lcard.ru/download/ltrapi.pdf).

2. Специфичный для модуля LTR22 механизм фазировки и синхронного запуска. Он позволяет уже саму частоту сбора запустить у обоих модулей одновременно. Для него импульсы сигнала запуска должны подаваться на входы SYN_IN самих модулей. И в нем уже используются режиы master/slave, LTR22_SetSyncPriority, LTR22_SyncPhaze и т.д.

Какой из двух способов Вы хотите реализаовать, т.к. у Вас функции из обоих? Заведен ли Ваш синхросигнал на входы SYN_IN самих модулей LTR22 или только на разъем синхронизации крейта (в последнем случае это все объясняет, т.к. модуль ждет импульса именно на своем входе SYN_IN)? Правда во втором способе при периодическом сигнале синхронизации, который нельзя запретить, есть проблема, что может получится что после запуска первого модуля и до запуска второго придет этот импульс и модули запустятся от разных импульсов...

Добрый вечер!
Задача такая:
При наступлении события "Спад сигнала на разъёме SYNC" фиксировать на 4х каналах модуля 1 и 1ом канале модуля 2 значения напряжений.
Т.е. мне подходит "Механизм синхронизации данных по меткам".

Правильно ли я поняла механизм действий?
после всех инициализаций выполняю

LTR_StartSecondMark(hcrate, LTR_MARK_EXT_DIGIN1_FALL);//по спаду DIGIN1
LTR22_Recv(module1, rbuf1, tstamp, 1000, 5000); //получаю данные
LTR22_Recv(module2, rbuf2, tstamp, 1000, 5000); //разделить на два потока???
LTR_StopSecondMark(hcrate);

Событие "Спад сигнала на разъёме SYNC" должен быть на этапе выполнения функций LTR22_Recv?

Да, только данные нужно принимать/обрабатывать все время (т.к. один блок принятый Recv у Вас соответствует времени намного меньше 3 с и Вы можете не попасть на ваш синхроимпульс). Ну и tstamp должны быть разные массивы для разных модулей, чтобы второй Recv на затер первый, либо использовать общий массив на оба модуля, но обрабатывать между Recv первого и второго (как ниже в примере).

Т.е. логика должна быть такая (условная смесь С и псевдокода, т.е. описание словами кода, который должен быть по смыслу. обработка ошибок опущена. module_x - указатель на описатель модуля, для которого выполняются функции):

/* количество слов от одного канала, принимаемых за раз */
#define BLOCK_RX_CH_WORDS_CNT 1000



/* создание буферов для слов, меток времени и обработанных данных. Если вся обработка идет по очереди, то можно выделять в одном экземпляре на оба модуля, но под максимум разрешенных каналов */
 DWORD rbuf[4*BLOCK_RX_CH_WORDS_CNT];
 DWORD tstmp[4*BLOCK_RX_CH_WORDS_CNT];
 double proc_buf[4*BLOCK_RX_CH_WORDS_CNT];
 DWORD last_tstmp[2]; /* сохранение tstmp для отслеживания изменения по каждому модулю. Нужно сохранять, т.к. может изменится на границе блоков! */
 BOOLEAN last_tstmp_valid[2] = {FALSE, FALSE}; /* признак, что инициализировали значение last_tstmp */

 /* запуск сбора для каждого модуля. выполняется до запуска меток, чтобы не получилось, что метка придет 
     в момент, когда один модуль уже запущен, а второй еще нет */
 (для каждого модуля) {
    LTR22_StartADC(module_x, false); 
 }

LTR_StartSecondMark(hcrate, LTR_MARK_EXT_DIGIN1_FALL);//по спаду DIGIN1

/* никакого sleep тут требоваться не должно, не очень понял, зчем он тут */

while (условие останова сбора) {
    (для каждого модуля) {
        INT module_en_ch_cnt = /* кол-во разрешенных каналов в модуле */
        INT module_num = /* номер модуля, 0 или 1 */
        INT recvd = LTR22_Recv(module_x, rbuf, tstamp, module_en_ch_cnt * BLOCK_RX_CH_WORDS_CNT, 5000); 
        if (recvd > 0) {
            /* если еще значение метки не инициализировано, то иницизируем первым принятым значением */
            if (!last_tstmp_valid[module_num]) {
                last_tstmp[module_num] = tstamp[0] & 0xFFFF; /* используем только младшие 16 бит - метку СЕКУНДА без учета метки СТАРТ */
                last_tstmp_valid[module_num] = TRUE;
            }
             
            /* обработка данных */
            LTR22_ProcessData(module_x, rbuf, proc_buf, recvd, FALSE, FALSE, NULL); /* false, false - это значит в некалиброванных кодах АЦП - точно так нужно? */
            /* быстрая проверка, изменилась ли метка, сравнивая метку на конец блока с последней действительной. */
            if ((last_tstmp[module_num]  != (tstamp[recvd-1] & 0xFFFF)) {
                /* ищем момент изменения метки - для простоты примера просто проходим по всем элементам без каких-то ускоренных поисков */
                for (INT i = 0; i < recvd; ++i) {
                    if (last_tstmp[module_num]  != (tstamp[i] & 0xFFFF) ) {
                        last_tstmp[module_num] = tstamp[i] & 0xFFFF; /* обновляем последнее значение метки */
                        /* метка изменилась на i-ом элементе */
                        INT proc_ch_pos = (i / module_en_ch_cnt); /* полчаем позицию в массиве на канал после обработки */
                        for (INT ch_num = 0; ch_num < module_en_ch_cnt; ++ch_num) {
                            /* для каждого канала получаем точку за изменением метки времени.
                                если нужно более одной точки то можем пройтись по позиции с  proc_ch_pos до proc_ch_pos + N, 
                                но должны учитывать, что следующие точки могут выйти за границу блока, 
                                принятого в этот раз. Тогда нужно ставить флаг для модуля, что обработать еще сколько-то
                                точек из следующего блока */
                            double pt = proc_buf[recvd/module_en_ch_cnt * ch_num + proc_ch_pos];
                            /* сохраняем полученную точку или обрабатываем другим требуемым образом */              
                                          
                        }
                    }
                }
            }                  
        }
    }
}

LTR_StopSecondMark(hcrate); /* останов меток (может быть и после останова модулей) */

(для каждого модуля) {
   LTR22_StopADC(module_x);         /* останов сбора*/
   LTR22_ClearBuffer(module_x,true); /* очистка буфера */
}

По поводу потоков, то тут могут быть разные подходы. В общем случая обычно удобнее создавать поток на модуль, но если модули одинаковые и настроены на одну частоту и в одном крейте, то можно сделать и из одного потока, вызывая функции приема-обработки по очереди, но нужно смотреть, чтобы размер Recv был на количество точек, соответствующее одинаковому времени для разных модулей, т.к. в Вашем случае - пропорционален числу используемых каналов.

Отредактировано Алексей L Card (30.03.2022 18:11:15)

Спасибо за скорый и столь подробный ответ!
Буду тестировать.

Добрый вечер!
Правильно ли я поняла:

если мы ожидаем значения +-10В, то
LTR22_SetADCRange(module1, 1, 4);
...
Обрабатываем данные
LTR22_ProcessData(dev_ConnectLcard->module1, rbuf, proc_buf, recvd, true, false, NULL);
...
определяем нужную точку и получаем значение в Вольтах, как pt*10/32767

Да все верно. Но можно и в ProcessData передавать true, true и сразу получать Вольты без перевода вручную.

Что-то у меня не сходится...
Во-первых, если я в ProcessData передаю true, true, то на выходе всегда нулевые значения.
Во-вторых, пробую подставлять разные значения в функцию LTR22_SetADCRange, и выходит не соответствие:

LTR22_SetADCRange(module1, 1, 4) // +-10В
результат: -1167.16                   -1167.16*10/32767 = -0.3562

LTR22_SetADCRange(module1, 1, 0) // +-1В
результат: -1154.02                  -1154.02*1/32767 = -0.035219

LTR22_SetADCRange(module1, 1, 5) // +-3В
результат: -1322.89                   -1167.16*3/32767 = -0.1211

По идее значения должны быть одинаковыми...

А от какого канала это данные в качестве результата?  Номер канала в LTR22_SetADCRange идет от 0, т.е. LTR22_SetADCRange(module1, 1, 4) устанавливает диапазон для 2-го канала.

По ProcessData, Вы нигде к целому числу значение не приводите, что оно становится явно 0 вместо -0,35? Ну и на всякий случай, не изменяете значения в ADCCalibration[][].UserCalibScale ?

Да, все верно, для второго канала

На самом деле значение равно 0.0 , т.е. не целое.
ADCCalibration[][].UserCalibScale не использую

Возможно из-за этой части, если она оставлена, т.к. обнуляются все переменные, включая коэффициенты перевода.
memset(module1,0,sizeof(TLTR22));
Инициализация делается с помощью LTR22_Init(). У Вас изначально она была, а в предыдущем коде ее не вижу.

А на вход этого канала какое напряжение подано?

Убрала memset, добавила LTR22_Init. Теперь при  ProcessData (... true, true...) выводятся не нулевые значения, а уже обработанные 

Но все равно сохраняется ситуация:
LTR22_SetADCRange(module1, 1, 4) // +-10В
результат:  -0.3562

LTR22_SetADCRange(module1, 1, 0) // +-1В
результат:  -0.035219

LTR22_SetADCRange(module1, 1, 5) // +-3В
результат:  -0.1211

Пока нет возможности работать с оборудованием, сигналы не подключены.  Возможно у вас при отсутствии реальных сигналов имитируются разные сигналы в зависимости от параметров в LTR22_SetADCRange?

Если ко входу ничего не подключено, то измеряемое значение точно не определено и может быть впринципе разным на разных диапазонах. Поэтому нельзя сказать тогда, что явно результаты некорректны. Чтобы проверить работу установки диапазонов нужно подать хотя бы какое-то постоянное значение извне на входы.