public SearchAddress(CompressorSetting setting)
        {
            _setting = setting;
            InitializeComponent();

            portLabel.Text = "Порт " + setting.ComPortName;
        }
Beispiel #2
0
        private void AddPoints(CompressorSetting compressorSetting, IList <StatValue> statValues)
        {
            _numberOfComp++;
            var series = chart1.Series.Add($"Комп. {_numberOfComp} ({compressorSetting})");

            var list = new List <StatValue>();

            foreach (var statValue in statValues)
            {
                if (_lastDateTime.AddSeconds(_interval) > statValue.DateTime)
                {
                    continue;
                }
                list.Add(statValue);
                _lastDateTime = statValue.DateTime;
            }

            var values = list.Skip(list.Count - _numberOfValues).ToList();

            series.ChartType = SeriesChartType.Line;
            //series.SmartLabelStyle.Enabled = true;
            series.IsVisibleInLegend = false;
            series.Tag = statValues;

            AddCustomLegendItem(series);

            foreach (var statValue in values)
            {
                series.Points.AddXY(statValue.DateTime, statValue.Value);
            }

            AddPointSeries(series, values);
        }
Beispiel #3
0
 public CompressorItemControl(CompressorSetting compressorSetting, ICompressorListControl parent)
 {
     _parent = parent;
     InitializeComponent();
     CompressorData    = new CompressorData();
     CompressorSetting = compressorSetting;
 }
 private bool CheckExistingCompressor(CompressorSetting c, bool isNew, CompressorSetting existingCompressor)
 {
     if (Options.Compressors.Any(u => u.Address == c.Address && u.ComPortName == c.ComPortName && u != existingCompressor))
     {
         MessageBox.Show($"На панели уже присутствует интерфейс с адресом {c.ComPortName} ({c.Address})", isNew ? "Невозможно добавить новый компрессор" : "Невозможно отредактировать компрессор",
                         MessageBoxButtons.OK, MessageBoxIcon.Information);
         return(true);
     }
     return(false);
 }
Beispiel #5
0
        public void RefreshIndexes()
        {
            var defaultValue = "-";

            var    x = CompressorSetting.Indexes?.SpecialFunctions.FirstOrDefault(u => u.SpecialFunction.HasFlag(SpecialFunction.Pressure));
            string temp;

            if (x != null)
            {
                var z = ModbusTool.Read(x.Index, CompressorSetting);
                temp = z.ToString();
                CompressorSetting.AddPressure(DateTime.Now, z);
            }
            else
            {
                temp = defaultValue;
            }

            Invoke(() => CompressorData.Pressure = temp);

            string temp2;

            x = CompressorSetting.Indexes?.SpecialFunctions.FirstOrDefault(u => u.SpecialFunction.HasFlag(SpecialFunction.Temperature));
            if (x != null)
            {
                var z = ModbusTool.Read(x.Index, CompressorSetting);
                temp2 = z.ToString();
                CompressorSetting.AddTemperature(DateTime.Now, z);
            }
            else
            {
                temp2 = defaultValue;
            }

            Invoke(() => CompressorData.Temperature = temp2);

            bool?temp3 = null;

            x = CompressorSetting.Indexes?.SpecialFunctions.FirstOrDefault(u => u.SpecialFunction.HasFlag(SpecialFunction.Status));
            if (x != null)
            {
                temp3 = ModbusTool.Read(x.Index, CompressorSetting) == 1;
            }
            else
            {
                x = CompressorSetting.Indexes?.SpecialFunctions.FirstOrDefault(u => u.SpecialFunction.HasFlag(SpecialFunction.Status0));
                if (x != null)
                {
                    temp3 = ModbusTool.Read(x.Index, CompressorSetting) == 0;
                }
            }

            Invoke(() => CompressorData.InnerStatus = temp3);
        }
Beispiel #6
0
        public CompressorMenu(CompressorSetting setting)
        {
            InitializeComponent();
            _compressorSetting = setting;

            if (Indexes == null)
            {
                return;
            }
            InitializeListBox();
            if (listBox1.Items.Count > 0)
            {
                listBox1.SelectedIndex = 0;
            }
        }
        public AddNewCompressor(CompressorSetting setting, bool isNew)
        {
            _isNew = isNew;
            InitializeComponent();

            CompressorSetting = setting;

            ComPortInitializer.Initialize();
            Options.Instance.LoadCompressorIndexes();

            TypeComboBox.DataSource    = Options.Instance.CompressorIndexes.Select(u => new KeyValuePair <string, string>(u.Name, u.Name)).ToList();
            ComPortComboBox.DataSource = Options.Instance.ComPortSettings.Select(u => new KeyValuePair <string, string>(u.Name, u.Name)).ToList();
            if (!isNew)
            {
                Text = "Редактировать компрессор";
            }
        }
        public void EditCompressor(CompressorItemControl control)
        {
            var editSetting = new CompressorSetting();

            editSetting.CopyFields(control.CompressorSetting);

            using (var dlg = new AddNewCompressor(editSetting, false))
            {
                if (dlg.ShowDialog() == DialogResult.OK)
                {
                    var c = dlg.CompressorSetting;
                    if (CheckExistingCompressor(c, false, control.CompressorSetting))
                    {
                        return;
                    }

                    control.CompressorSetting.CopyFields(editSetting);
                    Options.SaveCompressors();
                }
            }
        }
        public static decimal Read(BaseIndex index, CompressorSetting compressor, byte slaveId)
        {
            var master = compressor.ComPortSetting?.Master;

            if (master == null)
            {
                return(0);
            }
            var address = index.RealAddress;

            //var slaveId = compressor.Address;

            lock (master)
            {
                if (index is CoilStatus)
                {
                    return(master.ReadCoils(slaveId, address, 1)[0] ? 1 : 0);
                }
                if (index is InputStatus)
                {
                    return(master.ReadInputs(slaveId, address, 1)[0] ? 1 : 0);
                }

                if (index is BaseRegister)
                {
                    Func <byte, ushort, ushort, ushort[]> func = null;
                    if (index is InputRegister)
                    {
                        func = compressor.ComPortSetting.Master.ReadInputRegisters;
                    }
                    else if (index is HoldRegister)
                    {
                        func = compressor.ComPortSetting.Master.ReadHoldingRegisters;
                    }
                    var baseRegister = (BaseRegister)index;

                    switch (index.DataType)
                    {
                    case DataType.Int16:
                        //ushort -> short
                        return(ReadRegister <short>(baseRegister, slaveId, func));

                    case DataType.Int32:
                        //ushort -> int
                        return(ReadRegister <int>(baseRegister, slaveId, func));

                    case DataType.Int8:
                        //ushort -> sbyte
                        return(ReadRegister <sbyte>(baseRegister, slaveId, func));

                    case DataType.Float:
                    case DataType.Single:
                        //ushort -> float
                        return(ReadRegister <float>(baseRegister, slaveId, func));

                    case DataType.Double:
                        //ushort -> double
                        return(ReadRegister <double>(baseRegister, slaveId, func));

                    case DataType.Digital:
                        //ushort -> bool
                        return(ReadRegister <bool>(baseRegister, slaveId, func));

                    default:
                        return(Convert.ToDecimal(func(slaveId, address, 1)[0]) /
                               baseRegister.Multiplier);
                    }
                }
            }

            return(0);
        }
Beispiel #10
0
 public static decimal Read(BaseIndex index, CompressorSetting compressor)
 {
     return(Read(index, compressor, compressor.Address));
 }
Beispiel #11
0
        public static void Write(BaseIndex index, CompressorSetting compressor, decimal value)
        {
            var master = compressor.ComPortSetting?.Master;

            if (master == null)
            {
                return;
            }
            var address = index.RealAddress;
            var slaveId = compressor.Address;

            lock (master)
            {
                if (index is CoilStatus)
                {
                    master.WriteSingleCoil(slaveId, address, value == 1);
                    return;
                }
                if (index is InputStatus || index is InputRegister)
                {
                    //read only
                    return;
                }

                if (index is HoldRegister)
                {
                    var holdRegister = (HoldRegister)index;

                    switch (index.DataType)
                    {
                    case DataType.Int16:
                        //ushort <- short
                        WriteRegister <short>(holdRegister, slaveId, master, value);
                        break;

                    case DataType.Int32:
                        //ushort <- int
                        WriteRegister <int>(holdRegister, slaveId, master, value);
                        break;

                    case DataType.Int8:
                        //ushort <- sbyte
                        WriteRegister <sbyte>(holdRegister, slaveId, master, value);
                        break;

                    case DataType.Float:
                    case DataType.Single:
                        //ushort <- float
                        WriteRegister <float>(holdRegister, slaveId, master, value);
                        break;

                    case DataType.Double:
                        //ushort <- double
                        WriteRegister <double>(holdRegister, slaveId, master, value);
                        break;

                    case DataType.Digital:
                        //ushort <- bool
                        WriteRegister <bool>(holdRegister, slaveId, master, value);
                        break;

                    default:
                        master.WriteSingleRegister(slaveId, address, Convert.ToUInt16(value * holdRegister.Multiplier));
                        break;
                    }
                }
            }
        }