/// <summary>
        /// Создает экземпляр класса CrateModule для управления крейтом
        /// </summary>
        /// <param name="csn">Строка - серийный номер крейта, в который установлен модуль</param>
        /// <param name="slot">Число - номер слота, в который установлен модуль</param>
        public CrateModule(string csn, ushort slot, ushort type, UInt32 servIP)
        {
            //переменная для обработки кодов ошибок при работе с крейтом
            _LTRNative.LTRERROR errorCode;

            //устанавливаем серийный номер крейта
            this.crateSerialNumber = csn;

            //устанавливаем номер слота модуля
            this.slotNumber = slot;

            //устанавливаем тип слота модуля
            this.moduleType = (_LTRNative.MODULETYPE)type;

            //инициализируем структуру класса TLTR
            tLTR = new _LTRNative.TLTR();
            errorCode = _LTRNative.LTR_Init(ref tLTR);
            LTRInfo.CheckOperationStatus(errorCode, "Ошибка инициализации модуля");

            //передаем серийный номер крейта в управляющую структуру
            tLTR.csn = LTRInfo.GetByteSN(csn);

            //передаем номер модуля в управляющую структуру
            tLTR.cc = slot;

            //передаем упакованный IP-адрес сервера
            tLTR.saddr = servIP;
        }
示例#2
0
        /// <summary>
        /// Конструктор, автоматически опрашивает LTR-сервер (или ltrd) и получает список серийных номеров крейтов
        /// </summary>
        /// <param name="servIP">Строка - IP-адрес ltr-сервера (по-умолчанию: 127.0.0.1)</param>
        public LTRInfo(string servIP = "")
        {
            //массив для хранения серийников крейтов
            byte[,] crateSNInfo = new byte[_LTRNative.CRATE_MAX, _LTRNative.SERIAL_NUMBER_SIZE];
            //код ошибки при выполнении операций
            _LTRNative.LTRERROR errorCode;

            //инициализируем струкруту TLTR
            _LTRNative.TLTR tLTR = new _LTRNative.TLTR();
            errorCode = _LTRNative.LTR_Init(ref tLTR);
            CheckOperationStatus(errorCode, "Ошибка инициализации управляющей структуры");

            //выбираем управляющий канал
            tLTR.cc = CC_CONTROL;

            //устанавливаем IP-адрес ltr-сервера
            if (servIP != "")
                tLTR.saddr = GetServerIP(servIP);

            char[] defaultCSN = "#SERVER_CONTROL".ToCharArray();
            for (int i = 0; i < defaultCSN.Length; i++)
                tLTR.csn[i] = (byte)defaultCSN[i];

            //открываем модуль
            errorCode = _LTRNative.LTR_OpenEx(ref tLTR, 5000);
            CheckOperationStatus(errorCode, "Ошибка открытия модуля, возможно сервер недоступен!");

            //пытаемся получить список крейтов
            errorCode = _LTRNative.LTR_GetCrates(ref tLTR, crateSNInfo);
            CheckOperationStatus(errorCode, "Ошибка получения списка крейтов");

            //заполняем список серийных номеров крейтов
            for (int i = 0; i < _LTRNative.CRATE_MAX; i++)
            {
                string strBuf = "";
                for (int j = 0; j < _LTRNative.SERIAL_NUMBER_SIZE; j++)
                {
                    //проверка на нулевые строки, если они найдены - выходим из цикла,
                    //добавив непустую строку - буфер с серийным номером крейта в список cratesSerialNumbers
                    if (crateSNInfo[i, j] == 0)
                    {
                        if (strBuf != "")
                            cratesSerialNumbers.Add(strBuf);
                        break;
                    }

                    //заполнение строки - буфера
                    strBuf += Convert.ToChar(crateSNInfo[i, j]);

                    //если все элементы в строке массива - не нулевые, то после записи последнего
                    //элемента в буфер записываем этот буфер в список cratesSerialNumbers
                    if (j == _LTRNative.SERIAL_NUMBER_SIZE - 1)
                        cratesSerialNumbers.Add(strBuf);
                }
            }

            //получаем список состояний серийных номеров крейтов
            GetCratesStatus(tLTR);
        }
示例#3
0
        /// <summary>
        /// Создает экземпляр класса Crate для управления крейтом
        /// </summary>
        /// <param name="csn">Строка - серийный номер крейта</param>
        /// <param name="servIP">IP-адрес LTR-сервера</param>
        /// <param name="ipStatus">Состояние подключения крейта</param>
        /// <param name="crateIP">IP-адрес крейта</param>
        public Crate(string csn, string servIP = "", LTRInfo.CrateIPStatus ipStatus = LTRInfo.CrateIPStatus.OFFLINE, string crateIP = "")
        {
            //переменная для обработки кодов ошибок при работе с крейтом
            _LTRNative.LTRERROR errorCode;

            //сохраняем переданный серийный номер крейта
            this.serialNumber = csn;

            //инициализируем структуру класса TLTR
            tLTR = new _LTRNative.TLTR();
            errorCode = _LTRNative.LTR_Init(ref tLTR);
            LTRInfo.CheckOperationStatus(errorCode, "Ошибка инициализации крейта");

            //передаем серийный номер крейта в управляющую структуру
            tLTR.csn = LTRInfo.GetByteSN(csn);

            //передаем IP-адрес ltr-сервера в управляющую структуру
            if (servIP != "")
                tLTR.saddr = LTRInfo.GetServerIP(servIP);

            //задаем состояние подключия крейта
            this.IPStatus = ipStatus;

            //задаем IP-адрес самого крейта
            this.IPAddress = crateIP;

            //выделяем память для списка модулей крейта
            modules = new List<CrateModule>();

            //получаем информацию о крейте
            GetCrateInfo();

            //получаем список модулей крейта
            GetCrateModules();

            //если крейт двухместный, то оставляем в списке модулей только 2 модуля
            if (this.CrateType == (byte)LTRInfo.CrateType.CRATE_TYPE_LTR021)
                for (int i = this.modules.Count - 1; i > 1; i--)
                    this.modules.RemoveAt(i);
        }
示例#4
0
        static void Main(string[] args)
        {
            _LTRNative.OpenOutFlags out_flags = 0;
            /* LTR24_Init() вызывается уже в конструкторе */
            ltr27api hltr27 = new ltr27api();

            /* отрываем модуль. Входной флаг REOPEN указывает, что разрешено подключение
             * к модулю с запущенным сбором без его сброса. В out_flags указывается,
             * в действительности установленно соединение с модулем, по которому уже
             * был запущен сбор (установлен флаг REOPEN) или открыто новое соединение
             * (флаг REOPEN сброшен) */
            _LTRNative.LTRERROR err = hltr27.OpenEx(SLOT,_LTRNative.OpenInFlags.REOPEN,out out_flags);
            if (err != _LTRNative.LTRERROR.OK)
            {
                Console.WriteLine("Не удалось открыть модуль. Ошибка {0}: {1}",
                                  err,ltr27api.GetErrorString(err));
            }
            else
            {
                Console.WriteLine("Модуль открыт успешно!");
                if ((out_flags & _LTRNative.OpenOutFlags.REOPEN) != 0)
                {
                    Console.WriteLine("Было осуществлено подключение к работающему модулю");
                }
            }

            if (err == _LTRNative.LTRERROR.OK)
            {
                /* Считываем информацию о конфигурации модуля и о мезанинах, только
                 * если это новое соединение. Если восстановили старое - то
                 * это информация уже восстановлена и идет сбор - т.е. явно считать нельзя */
                if ((out_flags & _LTRNative.OpenOutFlags.REOPEN) == 0)
                {
                    err = hltr27.GetConfig();
                    if (err != _LTRNative.LTRERROR.OK)
                    {
                        Console.WriteLine("Не удалось прочитать конфигурацию модуля. Ошибка {0}: {1}",
                                          err,ltr27api.GetErrorString(err));
                    }
                    else
                    {
                        err = hltr27.GetDescription(ltr27api.Descriptions.MODULE);


                        for (int i = 0; (i < ltr27api.LTR27_MEZZANINE_NUMBER) &&
                             (err == _LTRNative.LTRERROR.OK); i++)
                        {
                            if (hltr27.Mezzanine[i].Name != "EMPTY")
                            {
                                err = hltr27.GetDescription((ushort)(1 << i));
                            }
                        }

                        if (err != _LTRNative.LTRERROR.OK)
                        {
                            Console.WriteLine("Не удалось прочитать описание модуля или мезонинов. Ошибка {0}: {1}",
                                              err,ltr27api.GetErrorString(err));
                        }
                    }
                }
            }

            /* выводим информацию о модуле */
            if (err == _LTRNative.LTRERROR.OK)
            {
                Console.WriteLine("  Информация о модуле :");
                Console.WriteLine("      Название        : {0}",hltr27.ModuleInfo.Module.DeviceName);
                Console.WriteLine("      Серийный номер  : {0}",hltr27.ModuleInfo.Module.SerialNumber);

                if (hltr27.ModuleInfo.Cpu.Active)
                {
                    Console.WriteLine("  Информация о процессоре :");
                    Console.WriteLine("     Название        : {0}",hltr27.ModuleInfo.Cpu.Name);
                    Console.WriteLine("     Частота клока   : {0} Hz",hltr27.ModuleInfo.Cpu.ClockRate);
                    Console.WriteLine("     Версия прошивки : {0}.{1}.{2}.{3}",
                                      (hltr27.ModuleInfo.Cpu.FirmwareVersion >> 24) & 0xFF,
                                      (hltr27.ModuleInfo.Cpu.FirmwareVersion >> 16) & 0xFF,
                                      (hltr27.ModuleInfo.Cpu.FirmwareVersion >> 8) & 0xFF,
                                      hltr27.ModuleInfo.Cpu.FirmwareVersion & 0xFF);
                    Console.WriteLine("     Комментарий     : {0}",hltr27.ModuleInfo.Cpu.Comment);
                }
                else
                {
                    Console.WriteLine("  Не найдено действительное описание процессора!!!");
                }

                for (int i = 0; (i < ltr27api.LTR27_MEZZANINE_NUMBER); i++)
                {
                    if (hltr27.ModuleInfo.Mezzanine[i].Active)
                    {
                        Console.WriteLine("    Информация о мезонине в слоте {0} :",i + 1);
                        Console.WriteLine("      Название        : {0}",hltr27.ModuleInfo.Mezzanine[i].Name);
                        Console.WriteLine("      Серийный номер  : {0}",hltr27.ModuleInfo.Mezzanine[i].SerialNumber);
                        Console.WriteLine("      Ревизия         : {0}",hltr27.ModuleInfo.Mezzanine[i].Revision);
                        for (int j = 0; (j < 4); j++)
                        {
                            Console.WriteLine("      Калибр. коэф. {0} : {1}",j,
                                              hltr27.ModuleInfo.Mezzanine[i].Calibration[j].ToString("F5"));
                        }
                    }
                }
            }

            /* Запись настроек (только если не был уже запущен сбор) */
            if ((err == _LTRNative.LTRERROR.OK) &&
                ((out_flags & _LTRNative.OpenOutFlags.REOPEN) == 0))
            {
                /* выбираем частоту дискретизции 1000Гц */
                hltr27.FrequencyDivisor = 255;

                err = hltr27.SetConfig();
                if (err != _LTRNative.LTRERROR.OK)
                {
                    Console.WriteLine("Не удалось записать настройки модуля. Ошибка {0}: {1}",
                                      err,ltr27api.GetErrorString(err));
                }
            }

            /* Запуск сбора данных (если не был запущен) */
            if ((err == _LTRNative.LTRERROR.OK) &&
                ((out_flags & _LTRNative.OpenOutFlags.REOPEN) == 0))
            {
                err = hltr27.ADCStart();
                if (err != _LTRNative.LTRERROR.OK)
                {
                    Console.WriteLine("Не удалось запустить сбор данных. Ошибка {0}: {1}",
                                      err,ltr27api.GetErrorString(err));
                }
            }


            if (err == _LTRNative.LTRERROR.OK)
            {
                uint     size             = RECV_FRAMES * 2 * ltr27api.LTR27_MEZZANINE_NUMBER;
                uint[]   buf              = new uint[size];
                double[] data             = new double[size];
                bool     search_start_req = (out_flags & _LTRNative.OpenOutFlags.REOPEN) != 0;

                Console.WriteLine("Сбор данных запущен успешно");

                for (int b = 0; b < RECV_BLOCK_CNT; b++)
                {
                    err = RecvData(hltr27,buf,size);
                    if ((err == _LTRNative.LTRERROR.OK) && search_start_req)
                    {
                        /* если подсоединились к уже запущенному сбору данных, то
                         * нужно найти начало кадра в принятых словах */
                        uint frame_index;
                        err = hltr27.SearchFirstFrame(buf,size,out frame_index);
                        if (err != _LTRNative.LTRERROR.OK)
                        {
                            Console.WriteLine("Ошибка поиска начала кадра. Ошибка {0}: {1}",
                                              err,ltr27api.GetErrorString(err));
                        }
                        else if (frame_index > 0)
                        {
                            /* если начала кадра не совпадает с началом принятого буфера,
                             * то нужно откинуть из начала лишние данные и допринять
                             * в конец столько же */
                            uint[] end_buf = new uint[frame_index];
                            err = RecvData(hltr27,end_buf,frame_index);

                            if (err == _LTRNative.LTRERROR.OK)
                            {
                                Array.Copy(buf,frame_index,buf,0,size - frame_index);
                                Array.Copy(end_buf,0,buf,size - frame_index,frame_index);
                            }
                        }
                        search_start_req = false;
                    }

                    if (err == _LTRNative.LTRERROR.OK)
                    {
                        err = hltr27.ProcessData(buf,data,size,true,true);
                        if (err == _LTRNative.LTRERROR.OK)
                        {
                            /* отображаем данные */
                            Console.WriteLine("Успешно приняли блок данных {0}:",b + 1);
                            for (int i = 0; (i < RECV_FRAMES); i++)
                            {
                                for (int j = 0; (j < 2 * ltr27api.LTR27_MEZZANINE_NUMBER); j++)
                                {
                                    if (hltr27.Mezzanine[j >> 1].Name != "EMPTY")
                                    {
                                        Console.Write(" {0} {1}",data[i * 2 * ltr27api.LTR27_MEZZANINE_NUMBER]
                                                      .ToString("F4"),hltr27.Mezzanine[j >> 1].Unit);
                                    }
                                }
                                Console.Write("\n");
                            }
                        }
                        else
                        {
                            Console.WriteLine("Ошибка обработки данных! Ошибка {0}: {1}",
                                              err,ltr27api.GetErrorString(err));
                        }
                    }
                }


                /* останов сбора данных */
                if (stop_module)
                {
                    _LTRNative.LTRERROR stoperr = hltr27.ADCStop();
                    if (stoperr != _LTRNative.LTRERROR.OK)
                    {
                        Console.WriteLine("Не удалось остановить сбор данных. Ошибка {0}: {1}",
                                          stoperr,ltr27api.GetErrorString(stoperr));
                        if (err == _LTRNative.LTRERROR.OK)
                        {
                            err = stoperr;
                        }
                    }
                    else
                    {
                        Console.WriteLine("Сбор данных остановлен успешно");
                    }
                }
            } /*if (err == LTR_OK)*/

            /* сохранение настроек модуля во flash-память крейта */
            if ((err == _LTRNative.LTRERROR.OK) && store_config)
            {
                err = hltr27.StoreConfig(start_mode);
                if (err == _LTRNative.LTRERROR.OK)
                {
                    Console.WriteLine("Конфигурация модуля успешно сохранена");
                }
                else
                {
                    Console.WriteLine("Не удалось сохранить конфигурацию модуля. Ошибка {0}: {1}",
                                      err,ltr27api.GetErrorString(err));
                }
            }

            /* сохранение настроек крейта (автономная работа) во flash-память */
            if ((err == _LTRNative.LTRERROR.OK) && store_config)
            {
                _LTRNative.TLTR hltr = new _LTRNative.TLTR();
                err = _LTRNative.LTR_Init(ref hltr);
                if (err == _LTRNative.LTRERROR.OK)
                {
                    hltr.cc = 0; /* управляющее соединение */

                    /* устанавливаем соединение с тем крейтом, в котором
                     * установлен ltr27 */
                    hltr.saddr  = hltr27.Channel.saddr;
                    hltr.sport  = hltr27.Channel.sport;
                    hltr.Serial = hltr27.Channel.Serial;

                    err = _LTRNative.LTR_Open(ref hltr);
                }
                if (err == _LTRNative.LTRERROR.OK)
                {
                    _LTRNative.TLTR_SETTINGS set = new _LTRNative.TLTR_SETTINGS();

                    set.Init();
                    set.AutorunIsOn = autorun;
                    err             = _LTRNative.LTR_PutSettings(ref hltr,ref set);
                    if (err == _LTRNative.LTRERROR.OK)
                    {
                        Console.WriteLine("Кофигурация крейта успешно сохранена");
                    }
                    _LTRNative.LTRERROR closerr = _LTRNative.LTR_Close(ref hltr);
                    if (closerr != _LTRNative.LTRERROR.OK)
                    {
                        Console.WriteLine("Не удалось закрыть соединение с крейтом. Ошибка {0}: {1}",
                                          closerr,ltr27api.GetErrorString(closerr));
                        if (err == _LTRNative.LTRERROR.OK)
                        {
                            err = closerr;
                        }
                    }
                }

                if (err != _LTRNative.LTRERROR.OK)
                {
                    Console.WriteLine("Не удалось сохранить конфигурацию крейта. Ошибка {0}: {1}",
                                      err,ltr27api.GetErrorString(err));
                }
            }



            /* разрываем соединение */
            _LTRNative.LTRERROR closeerr = hltr27.Close();
            if (closeerr != _LTRNative.LTRERROR.OK)
            {
                Console.WriteLine("Не удалось закрыть соединение с модулем. Ошибка {0}: {1}",
                                  closeerr,ltr27api.GetErrorString(closeerr));
                if (err == _LTRNative.LTRERROR.OK)
                {
                    err = closeerr;
                }
            }
            else
            {
                Console.WriteLine("Соединение с модулем закрыто успешно");
            }
        }
示例#5
0
 static extern _LTRNative.LTRERROR LTR_SetLogLevel(ref _LTRNative.TLTR ltr, LogLevel level, bool permanent);
示例#6
0
 static extern _LTRNative.LTRERROR LTR_GetLogLevel(ref _LTRNative.TLTR ltr, out LogLevel level);
示例#7
0
 public static extern _LTRNative.LTRERROR ltr032_get_legacy_interface(IntPtr hnd, out _LTRNative.TLTR ltr);
示例#8
0
 /** Возвращает структуру TLTR для работы через интерфейс LTRAPI.
  *  Используется, например, для включения секундных меток.
  */
 public virtual _LTRNative.LTRERROR GetLegacyInterface(out _LTRNative.TLTR ltr)
 {
     return(ltr032_get_legacy_interface(hnd, out ltr));
 }
示例#9
0
 static extern _LTRNative.LTRERROR LTR_Config(ref _LTRNative.TLTR ltr, ref Config conf);