Ejemplo n.º 1
0
        private dynamic GetPrivateConstants(byte na, byte ch, DateTime date)
        {
            dynamic answer = ReadParameters(na, ch, PrivateParameters.Keys.ToArray());

            if (!answer.success)
            {
                return(answer);
            }

            dynamic        constant   = new ExpandoObject();
            List <dynamic> records    = new List <dynamic>();
            List <dynamic> parameters = answer.parameters;

            Dictionary <string, string> units = new Dictionary <string, string>();

            units.Add(Glossary.P(ch), GetUnit(parameters[10]));
            units.Add(Glossary.dP(ch), GetUnit(parameters[15]));

            for (int i = 0; i < parameters.Count; i++)
            {
                string name = string.Format(PrivateParameters[(byte)i], ch);
                if (i == 10 || i == 15)
                {
                    continue;
                }
                if (i == 8 || i == 11 || i == 12 || i == 13)
                {
                    name = string.Format("{0}({1})", name, units[Glossary.P(ch)]);
                }

                if (i == 14 || i == 16 || i == 17 || i == 18 || i == 19 || i == 21)
                {
                    name = string.Format("{0}({1})", name, units[Glossary.dP(ch)]);
                }

                records.Add(MakeConstantRecord(name, parameters[i], date));
            }

            constant.success = true;
            constant.error   = string.Empty;
            constant.records = records;
            constant.units   = units;
            return(constant);
        }
Ejemplo n.º 2
0
        private dynamic GetGeneralConstants(byte na, DateTime date)
        {
            dynamic answer = ReadParameters(na, 0x00, GeneralParameters.Keys.ToArray());

            if (!answer.success)
            {
                return(answer);
            }

            dynamic        constant   = new ExpandoObject();
            List <dynamic> records    = new List <dynamic>();
            List <dynamic> parameters = answer.parameters;

            var units = new Dictionary <string, string>();

            units.Add(Glossary.P(3), GetUnit(parameters[14]));
            units.Add(Glossary.dP(3), GetUnit(parameters[19]));
            units.Add(Glossary.dP(4), GetUnit(parameters[22]));
            units.Add(Glossary.Pb, GetUnit(parameters[26]));

            for (int i = 0; i < parameters.Count; i++)
            {
                string name = GeneralParameters[(byte)i];
                if (i == 14 || i == 19 || i == 22 || i == 26)
                {
                    continue;
                }

                if (i == 13 || i == 15 || i == 16 || i == 17)
                {
                    name = string.Format(name, units[Glossary.P(3)]);
                }

                if (i == 18 || i == 20)
                {
                    name = string.Format(name, units[Glossary.dP(3)]);
                }
                if (i == 21 || i == 23)
                {
                    name = string.Format(name, units[Glossary.dP(4)]);
                }
                if (i == 24 || i == 27)
                {
                    name = string.Format(name, units[Glossary.Pb]);
                }

                if (i == 7)
                {
                    int contractHour = 0;
                    if (!int.TryParse(parameters[7], out contractHour))
                    {
                        constant.success = false;
                        constant.error   = "не удалось прочитать значение контрактного часа";
                        return(constant);
                    }
                    constant.contractHour = contractHour;
                }
                records.Add(MakeConstantRecord(name, parameters[i], date));
            }
            constant.success = true;
            constant.error   = string.Empty;
            constant.records = records;
            constant.units   = units;
            return(constant);
        }
Ejemplo n.º 3
0
        private dynamic GetPrivateCurrent(byte na, byte ch, dynamic dunits, DateTime date)
        {
            var units = (Dictionary <string, string>)dunits;

            log(string.Format("Приватные курренты на {0} канал {1} юнитов {2}", date, ch, units.Count), level: 3);

            dynamic answer = ReadParameters(na, ch, PrivateCurrentParameters.Keys.ToArray());

            if (!answer.success)
            {
                return(answer);
            }

            dynamic        current    = new ExpandoObject();
            List <dynamic> records    = new List <dynamic>();
            List <dynamic> parameters = answer.parameters;

            if (parameters.Count != 10)
            {
                current.success = false;
                current.error   = "получены не все необходимые параметры";
                return(current);
            }

            log(string.Format("Параметры({0}): {1}", parameters.Count, string.Join("; ", parameters.Select(r => r.ToString()).ToArray())), level: 3);

            double p = 0.0;

            if (double.TryParse(parameters[0].ToString(), out p))
            {
                records.Add(MakeCurrentRecord(Glossary.Vp(ch), p, "м³", date));
            }

            if (double.TryParse(parameters[1].ToString(), out p))
            {
                records.Add(MakeCurrentRecord(Glossary.V(ch), p, "м³", date));
            }

            if (double.TryParse(parameters[2].ToString(), out p))
            {
                var unit = units.ContainsKey(Glossary.P(ch)) ? units[Glossary.P(ch)] : "";
                records.Add(MakeCurrentRecord(Glossary.P(ch), p, unit, date));
            }

            if (double.TryParse(parameters[3].ToString(), out p))
            {
                records.Add(MakeCurrentRecord(Glossary.T(ch), p, "°C", date));
            }

            if (double.TryParse(parameters[4].ToString(), out p))
            {
                var unit = units.ContainsKey(Glossary.dP(ch)) ? units[Glossary.dP(ch)] : "";
                records.Add(MakeCurrentRecord(Glossary.dP(ch), p, unit, date));
            }

            if (double.TryParse(parameters[5].ToString(), out p))
            {
                records.Add(MakeCurrentRecord(Glossary.Vрч(ch), p, "м³", date));
            }

            if (double.TryParse(parameters[6].ToString(), out p))
            {
                records.Add(MakeCurrentRecord(Glossary.Vч(ch), p, "м³", date));
            }


            current.success = true;
            current.error   = string.Empty;
            current.records = records;
            current.date    = date;
            return(current);
        }
Ejemplo n.º 4
0
        private dynamic ParseArchiveResponse(List <dynamic> parameters, DateTime date, ArchiveType type, dynamic units, byte ch)
        {
            dynamic archive = new ExpandoObject();

            archive.isEmpty = false;
            archive.success = true;
            archive.error   = string.Empty;
            archive.date    = date;

            List <dynamic> records = new List <dynamic>();

            //Среднее значение давления P3
            records.Add(MakeArchiveRecord(Glossary.P(3), parameters[3], units[Glossary.P(3)], archive.date, type));

            //Среднее значение перепада давления ∆Р3
            records.Add(MakeArchiveRecord(Glossary.dP(3), parameters[4], units[Glossary.dP(3)], archive.date, type));

            //Среднее значение перепада давления ∆Р4
            records.Add(MakeArchiveRecord(Glossary.dP(4), parameters[5], units[Glossary.dP(4)], archive.date, type));

            //Стандартный объем
            records.Add(MakeArchiveRecord(Glossary.Vс, parameters[7], "м³", archive.date, type));

            //Время интегрирования
            records.Add(MakeArchiveRecord(Glossary.ВНР, parameters[9], "ч", archive.date, type));


            ////Нештатные ситуации
            //records.Add(MakeArchiveRecord(Glossary.HC, parameters[10], "", archive.date, type));


            int offset = 0;

            if (ch == 0x02)
            {
                offset = 8;
            }

            //Среднее значение давления по каналу
            records.Add(MakeArchiveRecord(Glossary.P(ch), parameters[11 + offset], units[Glossary.P(ch)], archive.date, type));

            //Среднее значение температуры по каналу
            records.Add(MakeArchiveRecord(Glossary.T(ch), parameters[12 + offset], "°C", archive.date, type));

            //Среднее значение перепада давления по каналу
            records.Add(MakeArchiveRecord(Glossary.dP(ch), parameters[13 + offset], units[Glossary.dP(ch)], archive.date, type));

            //Рабочий объем по каналу
            records.Add(MakeArchiveRecord(Glossary.Vp(ch), parameters[14 + offset], "м³", archive.date, type));

            //Приведенный объем по каналу
            records.Add(MakeArchiveRecord(Glossary.V(ch), parameters[15 + offset], "м³", archive.date, type));

            //Допускаемый перепад давления по каналу
            records.Add(MakeArchiveRecord(Glossary.dPd(ch), parameters[16 + offset], units[Glossary.dP(ch)], archive.date, type));

            //Среднее значение коэффициента сжимаемости по каналу
            records.Add(MakeArchiveRecord(Glossary.Ksj(ch), parameters[17 + offset], "", archive.date, type));

            //Среднее значение коэффициента приведения по каналу
            records.Add(MakeArchiveRecord(Glossary.Kpr(ch), parameters[18 + offset], "", archive.date, type));

            archive.records = records;
            return(archive);
        }