public dynamic ToDailyRecord()
 {
     return(MakeRecord.Day(parameter, value, unit, date));
 }
Example #2
0
        private Result All(string components, List <DateTimeRange> hourRanges, List <DateTimeRange> dayRanges, Version ver, Status status)
        {
            DateTime currentDate;

            try
            {
                currentDate = Parser.ParseDate(Send(MakeRequest.ReadCurrentParameters(currentParameter.Where(cp => cp.Value.type == CurrentParameterType.Date).FirstOrDefault().Value.P)).Body, 0)
                              .Add(Parser.ParseTime(Send(MakeRequest.ReadCurrentParameters(currentParameter.Where(cp => cp.Value.type == CurrentParameterType.Time).FirstOrDefault().Value.P)).Body, 0));
            }
            catch (DriverException ex)
            {
                return(MakeResult(201, ex.DeviceError, $"Не удалось получить дату/время: {ex.Message}"));
            }
            catch (Exception ex)
            {
                return(MakeResult(201, DeviceError.NO_ERROR, $"Не удалось получить дату/время: {ex.Message}"));
            }

            setTimeDifference(DateTime.Now - currentDate);
            log(string.Format("Дата/время на вычислителе: {0:dd.MM.yy HH:mm:ss}", currentDate));

            if (getEndDate == null)
            {
                getEndDate = (type) => currentDate;
            }

            if (components.Contains("Current"))
            {
                try
                {
                    List <dynamic>   current = new List <dynamic>();
                    CurrentParameter par;
                    foreach (var cp in currentParameter.Where(c => c.Value.type == CurrentParameterType.Float && c.Value.name != "tw"))
                    {
                        par = cp.Value;
                        if (((par.vmask == VersionMask.No_SA94_1) && (ver.verHw == VersionHardware.SA94_1)) ||
                            ((par.vmask == VersionMask.No_SA94_100_200_300_M100_M200_M300) && (
                                 ver.verSw == VersionSoftware.ver100 ||
                                 ver.verSw == VersionSoftware.ver200 ||
                                 ver.verSw == VersionSoftware.ver300 ||
                                 ver.verSw == VersionSoftware.verM100 ||
                                 ver.verSw == VersionSoftware.verM200 ||
                                 ver.verSw == VersionSoftware.verM300)))
                        {
                            continue;
                        }
                        current.Add(MakeRecord.Current(par.name, Parser.ParseFloat(Send(MakeRequest.ReadCurrentParameters(par.P)).Body, 0), par.unit, currentDate));
                    }

                    par = currentParameter.Where(c => c.Value.name == "tw").FirstOrDefault().Value;
                    if (par.unit == "с")
                    {
                        current.Add(MakeRecord.Current(par.name, Parser.ParseFloat(Send(MakeRequest.ReadCurrentParameters(par.P)).Body, 0) / 3600.0, "ч", currentDate));
                    }
                    else if (par.unit == "мин")
                    {
                        current.Add(MakeRecord.Current(par.name, Parser.ParseFloat(Send(MakeRequest.ReadCurrentParameters(par.P)).Body, 0) / 60.0, "ч", currentDate));
                    }
                    else
                    {
                        current.Add(MakeRecord.Current(par.name, Parser.ParseFloat(Send(MakeRequest.ReadCurrentParameters(par.P)).Body, 0), par.unit, currentDate));
                    }

                    records(current);
                    log(string.Format("Текущие на {0} прочитаны: всего {1}", currentDate, current.Count), level: 1);
                }
                catch (DriverException ex)
                {
                    log($"Не удалось получить текущие: {ex.Message}", level: 1);
                    return(MakeResult(201, ex.DeviceError, $"Не удалось получить текущие: {ex.Message}"));
                }
                catch (Exception ex)
                {
                    log($"Не удалось получить текущие: {ex.Message}", level: 1);
                    return(MakeResult(201, DeviceError.NO_ERROR, $"Не удалось получить текущие: {ex.Message}"));
                }
            }


            if (components.Contains("Constant"))
            {
                try
                {
                    byte[] sets1;
                    byte[] sets2;
                    if (ver.verSw == VersionSoftware.ver100 || ver.verSw == VersionSoftware.ver200 || ver.verSw == VersionSoftware.ver300 || ver.verSw == VersionSoftware.verM100 || ver.verSw == VersionSoftware.verM300) //двухбайтовая команда
                    {
                        sets1 = Send(MakeRequest.ReadStatistics(Segment.Service1, 0)).Body;
                        sets2 = Send(MakeRequest.ReadStatistics(Segment.Service1, 0x100)).Body;
                    }
                    else if (ver.verSw == VersionSoftware.ver101 || ver.verSw == VersionSoftware.ver201 || ver.verSw == VersionSoftware.verMTE1 || ver.verSw == VersionSoftware.ver301 || ver.verSw == VersionSoftware.verM101 || ver.verSw == VersionSoftware.verM301) //трехбайтовая команда
                    {
                        sets1 = Send(MakeRequest.ReadStatisticsExt(Segment.Service1, 0)).Body;
                        sets2 = Send(MakeRequest.ReadStatisticsExt(Segment.Service1, 0x100)).Body;
                    }
                    else
                    {
                        throw new Exception($"драйвер не рассчитан на считывание констант у версии {ver.verHw} {ver.verSw}");
                    }
                    Version testver = Parser.ParseVersion(sets2, 0, log);
                    if (testver.verSw != ver.verSw)
                    {
                        log($"Обнаружена версия прибора, которая отличается от выбранной: {testver.verText} ({testver.verHw} {testver.verSw})", level: 1);
                        ver = testver;
                    }
                    double Tprog = Helper.ToInt16Reverse(sets1, 0x09) / 100.0;

                    List <dynamic> constants = new List <dynamic>();
                    constants.Add(MakeRecord.Constant("Тип прибора", testver.GetVerHwText(), currentDate));
                    constants.Add(MakeRecord.Constant("Версия программы", testver.verText, currentDate));
                    constants.Add(MakeRecord.Constant("Расширенная статистика", testver.isExtended? "Да" : "Нет", currentDate));
                    constants.Add(MakeRecord.Constant("Модифицированный", testver.isM ? "Да" : "Нет", currentDate));
                    constants.Add(MakeRecord.Constant("Режим", status.b4_isModeCount ? "Счет" : "Стоп", currentDate));
                    if (ver.verHw == VersionHardware.SA94_1)
                    {
                        constants.Add(MakeRecord.Constant("Температура (T2)", status.b1_SA94_1_isT2Programmed ? "Программируется" : "Измеряется", currentDate));
                        if (status.b1_SA94_1_isT2Programmed)
                        {
                            constants.Add(MakeRecord.Constant("Значение Т2прог, °C", $"{Tprog:0.00}", currentDate));
                        }
                    }
                    else if ((ver.verHw == VersionHardware.SA94_2) || (ver.verHw == VersionHardware.SA94_2M))
                    {
                        constants.Add(MakeRecord.Constant("Температура (Т3)", status.b1_SA94_2_2M_isT3Measured ? "Измеряется" : "Программируется", currentDate));
                        if (!status.b1_SA94_2_2M_isT3Measured)
                        {
                            constants.Add(MakeRecord.Constant("Значение Т3прог, °C", $"{Tprog:0.00}", currentDate));
                        }
                    }
                    constants.Add(MakeRecord.Constant("Заводской номер", $"{(sets1[3] | ((UInt32)sets1[2] << 8) | ((UInt32)sets1[1] << 16)):000000}", currentDate));
                    constants.Add(MakeRecord.Constant("Разность dTmin, °C", $"{(Helper.ToInt16Reverse(sets1, 0x0D) / 100.0):0.00}", currentDate));
                    constants.Add(MakeRecord.Constant("Количество токов", Helper.GetNumOfCurrentsFromByte(sets1[0x18]), currentDate));
                    constants.Add(MakeRecord.Constant("Параметр для Iвых1", Helper.GetParamIoutFromByte(sets1[0x1A], ver.verHw), currentDate));
                    constants.Add(MakeRecord.Constant("Параметр для Iвых2", Helper.GetParamIoutFromByte(sets1[0x1B], ver.verHw), currentDate));
                    constants.Add(MakeRecord.Constant("Диапазон тока Iвых1, мА", Helper.GetRangeIoutFromByte(sets1[0x1E]), currentDate));
                    constants.Add(MakeRecord.Constant("Диапазон тока Iвых2, мА", Helper.GetRangeIoutFromByte(sets1[0x1F]), currentDate));
                    constants.Add(MakeRecord.Constant("Тип термодатчика", Helper.GetTermosensorTypeFromByte(sets1[0x1C]), currentDate));

                    constants.Add(MakeRecord.Constant("№ ЭМ датчика 1", $"{(sets1[0x23] | ((UInt32)sets1[0x22] << 8) | ((UInt32)sets1[0x21] << 16)):000000}", currentDate));
                    int    Du1mm    = Helper.GetDummFromByte(sets1[0x24], ver);
                    double Q1max    = Helper.GetQmaxByDumm(sets1[0x25], Du1mm);
                    int    Q1minPrc = Helper.GetQminFromByte(sets1[0x26]);
                    constants.Add(MakeRecord.Constant("Ду1, мм", Du1mm, currentDate));
                    constants.Add(MakeRecord.Constant("Q1max, м/ч", Q1max, currentDate));
                    constants.Add(MakeRecord.Constant("Q1min, %", Q1minPrc, currentDate));
                    constants.Add(MakeRecord.Constant("Q1min, м/ч", Q1max * Q1minPrc / 100.0, currentDate));

                    if (ver.isExtended)
                    {
                        constants.Add(MakeRecord.Constant("Давление p1max, МПа", Helper.GetpmaxFromByte(sets1[0x19]), currentDate));
                        constants.Add(MakeRecord.Constant("Давление p2max, МПа", Helper.GetpmaxFromByte(sets1[0x1D]), currentDate));
                        constants.Add(MakeRecord.Constant("Диапазон тока Iвх1, мА", Helper.GetRangeIinFromByte(sets1[0x27]), currentDate));
                    }

                    if (ver.verHw != VersionHardware.SA94_1)
                    {
                        constants.Add(MakeRecord.Constant("№ ЭМ датчика 2", $"{(sets1[0x2B] | ((UInt32)sets1[0x2A] << 8) | ((UInt32)sets1[0x29] << 16)):000000}", currentDate));

                        int    Du2mm    = Helper.GetDummFromByte(sets1[0x2C], ver);
                        double Q2max    = Helper.GetQmaxByDumm(sets1[0x2D], Du2mm);
                        int    Q2minPrc = Helper.GetQminFromByte(sets1[0x2E]);
                        constants.Add(MakeRecord.Constant("Ду2, мм", Du2mm, currentDate));
                        constants.Add(MakeRecord.Constant("Q2max, м/ч", Q2max, currentDate));
                        constants.Add(MakeRecord.Constant("Q2min, %", Q2minPrc, currentDate));
                        constants.Add(MakeRecord.Constant("Q2min, м/ч", Q2max * Q2minPrc / 100.0, currentDate));

                        if (ver.isExtended)
                        {
                            constants.Add(MakeRecord.Constant("Диапазон тока Iвх2, мА", Helper.GetRangeIinFromByte(sets1[0x2F]), currentDate));
                        }
                    }

                    records(constants);
                    log(string.Format("Константы на {0} прочитаны: всего {1}", currentDate, constants.Count), level: 1);
                }
                catch (DriverException ex)
                {
                    log($"Не удалось получить константы: {ex.Message}", level: 1);
                    return(MakeResult(201, ex.DeviceError, $"Не удалось получить константы: {ex.Message}"));
                }
                catch (Exception ex)
                {
                    log($"Не удалось получить константы: {ex.Message}", level: 1);
                    return(MakeResult(201, DeviceError.NO_ERROR, $"Не удалось получить константы: {ex.Message}"));
                }
            }

            if (components.Contains("Hour"))
            {
                try
                {
                    List <dynamic> hours = new List <dynamic>();
                    if (hourRanges != null)
                    {
                        foreach (var range in hourRanges)
                        {
                            var startH = range.start;
                            var endH   = range.end;

                            if (startH > currentDate)
                            {
                                continue;
                            }
                            if (endH > currentDate)
                            {
                                endH = currentDate;
                            }

                            var hour = GetHourly(startH, endH, currentDate, ver);
                            hours.AddRange(hour);

                            log(string.Format("Прочитаны часовые с {0:dd.MM.yyyy HH:mm} по {1:dd.MM.yyyy HH:mm}: {2} записей", startH, endH, hours.Count), level: 1);
                        }
                    }
                    else
                    {
                        //чтение часовых
                        var startH = getStartDate("Hour");
                        var endH   = getEndDate("Hour");

                        var hour = GetHourly(startH, endH, currentDate, ver);
                        hours.AddRange(hour);

                        log(string.Format("Прочитаны часовые с {0:dd.MM.yyyy HH:mm} по {1:dd.MM.yyyy HH:mm}: {2} записей", startH, endH, hours.Count), level: 1);
                    }
                }
                catch (DriverException ex)
                {
                    log(string.Format("Ошибка при считывании часовых: {0}", ex.Message), level: 1);
                    return(MakeResult(105, ex.DeviceError, ex.Message));
                }
                catch (Exception ex)
                {
                    log(string.Format("Ошибка при считывании часовых: {0}", ex.Message), level: 1);
                    return(MakeResult(105, DeviceError.NO_ERROR, ex.Message));
                }
            }

            if (components.Contains("Day"))
            {
                try
                {
                    List <dynamic> days = new List <dynamic>();
                    if (dayRanges != null)
                    {
                        foreach (var range in dayRanges)
                        {
                            var startD = range.start;
                            var endD   = range.end;

                            if (startD > currentDate)
                            {
                                continue;
                            }
                            if (endD > currentDate)
                            {
                                endD = currentDate;
                            }

                            var day = GetDaily(startD.Date, endD, currentDate, ver);
                            days.AddRange(day);

                            log(string.Format("Прочитаны суточные с {0:dd.MM.yyyy} по {1:dd.MM.yyyy}: {2} записей", startD, endD, days.Count), level: 1);
                        }
                    }
                    else
                    {
                        //чтение суточных
                        var startD = getStartDate("Day");
                        var endD   = getEndDate("Day");

                        var day = GetDaily(startD.Date, endD, currentDate, ver);
                        days.AddRange(day);

                        log(string.Format("Прочитаны суточные с {0:dd.MM.yyyy} по {1:dd.MM.yyyy}: {2} записей", startD, endD, days.Count), level: 1);
                    }
                }
                catch (DriverException ex)
                {
                    log(string.Format("Ошибка при считывании суточных: {0}", ex.Message), level: 1);
                    return(MakeResult(104, ex.DeviceError, ex.Message));
                }
                catch (Exception ex)
                {
                    log(string.Format("Ошибка при считывании суточных: {0}", ex.Message), level: 1);
                    return(MakeResult(104, DeviceError.NO_ERROR, ex.Message));
                }
            }

            return(MakeResult(0, DeviceError.NO_ERROR, "опрос успешно завершен"));
        }
 public dynamic ToHourlyRecord()
 {
     return(MakeRecord.Hour(parameter, value, unit, date));
 }