//процедура измерения 25-го модуля
private void Measure25module(CrateModule module)
{
//число измерений
const int RECV_BLOCK_CNT = 1;
//число разрешенных каналов для измерений
int enabledChanelCount = 0;
//инициализируем класс для работы с 25-м модулем
ltr25api.TLTR25 tLTR25 = new ltr25api.TLTR25();
ltr25api.LTR25_Init(ref tLTR25);
//открываем модуль, получение конфигурации происходит здесь же
_LTRNative.LTRERROR errorCode = ltr25api.LTR25_Open(ref tLTR25, module.TLTR.saddr, module.TLTR.sport, module.CrateSerialNumber, module.SlotNumber);
LTRInfo.CheckOperationStatus(errorCode, "Ошибка открытия модуля");
//создаем переменную для хранения конфигурации структуры
ltr25api.CONFIG api25config = new ltr25api.CONFIG();
//устанавливаем формат обмена данными
api25config.DataFmt = FORMAT_25;
//устанавливаем частоту
api25config.FreqCode = FREQ_25;
//настраиваем каналы
ltr25api.CHANNEL_CONFIG channelConfig = new ltr25api.CHANNEL_CONFIG();
channelConfig.Enabled = true;
for (int i = 9; i < 8; i++)
api25config.Ch[i] = channelConfig;
//определяем количество разрешенных каналов
enabledChanelCount = 8;
//передаем конфигурацию в структуру
tLTR25.Cfg = api25config;
//передаем конфигурацию модулю
errorCode = ltr25api.LTR25_SetADC(ref tLTR25);
LTRInfo.CheckOperationStatus(errorCode, "Ошибка записи конфигурации модуля");
//начинаем сбор данных
errorCode = ltr25api.LTR25_Start(ref tLTR25);
LTRInfo.CheckOperationStatus(errorCode, "Ошибка запуска сбора данных");
//расчитываем количество принимаемых данных
int receivedDataCount = RECV_BLOCK_CH_SIZE * enabledChanelCount;
//установка слов на отсчет
int receivedWordsCount = receivedDataCount * (tLTR25.Cfg.DataFmt == ltr25api.DataFormat.Format32 ? 2 : 1);
//видимо - массив для принятых слов
uint[] rBuf = new uint[receivedWordsCount];
//массив для меток на каждое слово
uint[] marks = new uint[receivedWordsCount];
//массив для хранения данных
double[] data = new double[receivedDataCount];
//статусы каналов
ltr25api.ChStatus[] statuses = new ltr25api.ChStatus[8];
//приём RECV_BLOCK_CNT блоков данных
for (int i = 0; i < RECV_BLOCK_CNT; i++)
{
//количество принятых данных
int recvCount;
//процедура принятия данных от модуля
recvCount = ltr25api.LTR25_Recv(ref tLTR25, rBuf, marks, (uint)rBuf.Length,
4000 + (uint)(1000 * RECV_BLOCK_CH_SIZE / (uint)tLTR25.Cfg.FreqCode + 1));
if (recvCount < 0)
throw new Exception("Ошибка приёма данных");
//если принято недостаточно данных - выходим
if (recvCount != rBuf.Length)
LTRInfo.CheckOperationStatus(_LTRNative.LTRERROR.ERROR_RECV_INSUFFICIENT_DATA,
"Принятно недостаточное количество данных");
//запуск данных на обработку
errorCode = ltr25api.LTR25_ProcessData(ref tLTR25,rBuf, data, ref recvCount,
ltr25api.ProcFlags.Volt,
statuses);
LTRInfo.CheckOperationStatus(errorCode, "Ошибка обработки данных");
//выводим полученные значения
for (int ch = 0, dataPos = 0; ch < ltr24api.LTR24_CHANNEL_NUM; ch++)
{
if (tLTR25.Cfg.Ch[ch].Enabled)
{
string measure_point = "";
if (checkBoxShowSourceAddress.Checked && xmlParser != null)
measure_point = xmlParser.GetSourcePath(String.Format("{0}->{1}->{2}", module.CrateSerialNumber, module.SlotNumber, ch));
string[] row_content = new string[] { module.SlotNumber.ToString(),
ch.ToString(),
data[dataPos].ToString("0.##"),
GetSimptom25(statuses[dataPos]),
measure_point };
AddRowToGrid(row_content);
}
dataPos++;
}
}
//останавливаем сбор данных
errorCode = ltr25api.LTR25_Stop(ref tLTR25);
LTRInfo.CheckOperationStatus(errorCode, "Не удалось остановить сбор данных");
//отключаемся от модуля
ltr25api.LTR25_Close(ref tLTR25);
}
static int Main(string[] args)
{
/* LTR25_Init() вызывается уже в конструкторе */
ltr25api hltr25 = new ltr25api();
/* отрываем модуль. есть вариант как с только со слотам, так и с серийным крейта и слотом
* + полный */
_LTRNative.LTRERROR err = hltr25.Open(SLOT);
if (err != _LTRNative.LTRERROR.OK)
{
Console.WriteLine("Не удалось открыть модуль. Ошибка {0}: {1}",
err,ltr25api.GetErrorString(err));
}
else
{
/* выводим информацию из hltr25.ModuleInfo */
Console.WriteLine("Модуль открыт успешно. Информация о модуле: ");
Console.WriteLine(" Название модуля = {0}",hltr25.ModuleInfo.Name);
Console.WriteLine(" Серийный номер = {0}",hltr25.ModuleInfo.Serial);
Console.WriteLine(" Версия FPGA = {0}",hltr25.ModuleInfo.VerFPGA);
Console.WriteLine(" Версия PLD = {0}",hltr25.ModuleInfo.VerPLD);
Console.WriteLine(" Ревизия платы = {0}",hltr25.ModuleInfo.BoardRev);
Console.WriteLine(" Темп. диапазон = {0}",hltr25.ModuleInfo.Industrial ? "Индустриальный" : "Коммерческий");
ltr25api.CONFIG cfg = hltr25.Cfg;
/* настраиваем модуль с помощью свойств */
/* формат - 32 или 20 битный. В первом случае 2 слова на отсчет */
cfg.DataFmt = ltr25api.DataFormat.Format32;
/* устанавливаем частоту с помощью одной из констант */
cfg.FreqCode = ltr25api.FreqCode.Freq_9K7;
cfg.Ch[0].Enabled = true;
cfg.Ch[1].Enabled = true;
cfg.Ch[2].Enabled = true;
hltr25.Cfg = cfg;
err = hltr25.SetADC();
if (err != _LTRNative.LTRERROR.OK)
{
Console.WriteLine("Не удалось сконфигурировать модуль. Ошибка {0}: {1}",
err,ltr25api.GetErrorString(err));
}
else
{
/* после SetADC() обновляется поле AdcFreq и EnabledChCnt. Становится равной действительной
* установленной частоте */
Console.WriteLine("Модуль настроен успешно. Установленная частота {0}, каналов {1}",
hltr25.State.AdcFreq.ToString("F7"),hltr25.State.EnabledChCnt);
}
if (err == _LTRNative.LTRERROR.OK)
{
err = hltr25.Start();
if (err != _LTRNative.LTRERROR.OK)
{
Console.WriteLine("Не удалось запустить сбор данных. Ошибка {0}: {1}",
err,ltr25api.GetErrorString(err));
}
}
if (err == _LTRNative.LTRERROR.OK)
{
_LTRNative.LTRERROR stop_err;
int recv_data_cnt = RECV_BLOCK_CH_SIZE * hltr25.State.EnabledChCnt;
/* В 20-битном формате каждому отсчету соответствует одно слово от модуля,
* а в остальных - два */
int recv_wrd_cnt = recv_data_cnt * (hltr25.Cfg.DataFmt == ltr25api.DataFormat.Format20 ? 1 : 2);
uint[] rbuf = new uint[recv_wrd_cnt];
/* метки приходят на кждое слово, а не на отсчет */
uint[] marks = new uint[recv_wrd_cnt];
double[] data = new double[recv_data_cnt];
/* признаки обрыва/кз - по одному на каждый канал */
ltr25api.ChStatus[] ch_status = new ltr25api.ChStatus[hltr25.State.EnabledChCnt];
/* принмаем RECV_BLOCK_CNT блоков данных, после чего выходим */
for (int block_idx = 0; (block_idx < RECV_BLOCK_CNT) &&
(err == _LTRNative.LTRERROR.OK); block_idx++)
{
int rcv_cnt;
/* прием необработанных слов. в таймауте учитываем время выполнения самого преобразования */
rcv_cnt = hltr25.Recv(rbuf,marks,(uint)rbuf.Length,
4000 + (uint)(1000 * RECV_BLOCK_CH_SIZE / hltr25.State.AdcFreq + 1));
/* значение меньше 0 => код ошибки */
if (rcv_cnt < 0)
{
err = (_LTRNative.LTRERROR)rcv_cnt;
Console.WriteLine("Ошибка приема данных. Ошибка {0}: {1}",
err,ltr25api.GetErrorString(err));
}
else if (rcv_cnt != rbuf.Length)
{
err = _LTRNative.LTRERROR.ERROR_RECV_INSUFFICIENT_DATA;
Console.WriteLine("Приняли недостаточно данных: запрашивали {0}, приняли {1}",
rbuf.Length,rcv_cnt);
}
else
{
err = hltr25.ProcessData(rbuf,data,ref rcv_cnt,
ltr25api.ProcFlags.Volt |
ltr25api.ProcFlags.PhaseCor |
ltr25api.ProcFlags.SignCor,
ch_status);
if (err != _LTRNative.LTRERROR.OK)
{
Console.WriteLine("Ошибка обработки данных. Ошибка {0}: {1}",
err,ltr25api.GetErrorString(err));
}
else
{
/* при успешной обработке для примера выводим по одному значению
* для каждого канала и показания сек. метки и старт. метки первого отсчета */
Console.Write("Блок {0}. ",block_idx + 1);
for (int ch = 0; ch < hltr25.State.EnabledChCnt; ch++)
{
/* проверяем статус канала - не обнаружен ли обрыв или кз */
if (ch_status[ch] == ltr25api.ChStatus.OPEN)
{
Console.Write("обрыв ");
}
else if (ch_status[ch] == ltr25api.ChStatus.SHORT)
{
Console.Write("кз ");
}
else if (ch_status[ch] == ltr25api.ChStatus.OK)
{
double min_val,max_val,pp;
/* рассчитываем разницу минимума и максимума для
* примера для отображения (постоянная составляющая
* не имеет смысла для LTR25) */
min_val = max_val = data[ch];
for (uint i = 1; i < rcv_cnt / hltr25.State.EnabledChCnt; i++)
{
double val = data[i * hltr25.State.EnabledChCnt + ch];
if (min_val > val)
{
min_val = val;
}
if (max_val < val)
{
max_val = val;
}
}
pp = (max_val - min_val);
/* если все ок - выводим значение*/
Console.Write("{0} ",pp.ToString("F7"));
}
else
{
Console.Write("незвест. сост.!");
}
}
Console.WriteLine(" start = {0}, sec = {1}",(marks[0] >> 16) & 0xFFFF,marks[0] & 0xFFFF);
}
}
}
/* остановка сбора данных */
stop_err = hltr25.Stop();
if (stop_err != _LTRNative.LTRERROR.OK)
{
Console.WriteLine("Не удалось остановить сбор данных. Ошибка {0}: {1}",
stop_err,ltr25api.GetErrorString(stop_err));
if (err == _LTRNative.LTRERROR.OK)
{
err = stop_err;
}
}
}
hltr25.Close();
}
return((int)err);
}
