public AddEditDeviceDialog(ModulesConfiguration configuration, Device device)
        {
            //
            // The InitializeComponent() call is required for Windows Forms designer support.
            //
            InitializeComponent();

            comboBox1.Items.Add(DeviceType.Type1);
            comboBox1.Items.Add(DeviceType.Type2);

            Device = device;

            if (Device != null)
            {
                Text = "Zmień ustawienia urządzenia";
                // pokazanie ustawień
                comboBox1.SelectedItem = Device.Type;
                textBox4.Text          = Device.Id;
                textBox5.Text          = Device.Description;
            }
            else
            {
                Text = "Dodaj nowe urządzenie";
            }

            _configuration = configuration;
        }
示例#2
0
        private void LoadConfiguration()
        {
            // wczytanie konfiguracji
            _configuration = ModulesConfiguration.Load();

            List <InputVariable> inputs = new List <InputVariable>();

            inputs.AddRange(_configuration.DigitalInputs);
            foreach (Device d in _configuration.Devices)
            {
                inputs.AddRange(d.DeviceInputVariables);
            }
            _inputs = inputs.ToArray();

            List <OutputVariable> outputs = new List <OutputVariable>();

            outputs.AddRange(_configuration.DigitalOutputs);
            outputs.AddRange(_configuration.LED7DisplayOutputs);
            foreach (Device d in _configuration.Devices)
            {
                outputs.AddRange(d.DeviceOutputVariables);
            }

            #warning TODO 7led
            // dla każdego pojedynczego wyświetlacza dodać zmienną typu int do bitowego sterowania segmentami

            _outputs = outputs.ToArray();
        }
示例#3
0
        public TestDialog(SkalarkiIO skalarkiIO, ModulesConfiguration configuration)
        {
            //
            // The InitializeComponent() call is required for Windows Forms designer support.
            //
            InitializeComponent();

            _configuration = configuration;

            // pokazanie urządzeń
            foreach (Device d in _configuration.Devices)
            {
                ListViewItem item = new ListViewItem(d.Id);
                item.SubItems.Add("");
                item.Tag = d;
                listView1.Items.Add(item);
            }

            // pokazanie wejść
            foreach (DigitalInput di in _configuration.DigitalInputs)
            {
                int r = dataGridView1.Rows.Add(di.ID, di.Description, false.ToString());
                dataGridView1.Rows[r].Tag = di;
            }
            dataGridView1.PerformLayout();

            // pokazanie wyjść
            foreach (DigitalOutput _do in _configuration.DigitalOutputs)
            {
                int r = dataGridView2.Rows.Add(_do.ID, _do.Description, false);
                dataGridView2.Rows[r].Tag = _do;
            }
            dataGridView2.PerformLayout();

            // pokazanie wyświetlaczy
            foreach (LED7DisplayOutput led in _configuration.LED7DisplayOutputs)
            {
                int r = dataGridView3.Rows.Add(led.ID, led.Description, "");
                dataGridView3.Rows[r].Tag = led;
            }
            dataGridView3.PerformLayout();

            // pokazanie dodatkowych zmiennych
            List <OutputVariable> outputs = new List <OutputVariable>();

            foreach (Device d in _configuration.Devices)
            {
                outputs.AddRange(d.DeviceOutputVariables);
            }
            foreach (OutputVariable ov in outputs)
            {
                int r = dataGridView4.Rows.Add(ov.ID, ov.Description, ov.Type, "");
                dataGridView4.Rows[r].Tag = ov;
            }

            Working      = false;
            _inputsEvent = new HomeSimCockpitSDK.VariableChangeSignalDelegate(InputEvent);
            _skalarkiIO  = skalarkiIO;
        }
        public ConfigurationDialog(SkalarkiIO skalarkiIO, ModulesConfiguration configuration)
        {
            InitializeComponent();

            Configuration = configuration;

            _inputsRepeatAfter.CellTemplate    = new NumericCellMin0MaxIntMax();
            _inputsRepeatInterval.CellTemplate = new NumericCellMin0MaxIntMax();

            RefreshConfiguration();
            _skalarkiIO = skalarkiIO;
        }
示例#5
0
        public bool Configuration(System.Windows.Forms.IWin32Window parent)
        {
            if (_working)
            {
                System.Windows.Forms.MessageBox.Show(parent, "Konfiguracja jest niedostępna w trakcie działania skryptu korzystającego z tego modułu.", "Uwaga", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Warning);
                return(false);
            }
            ConfigurationDialog d = new ConfigurationDialog(this, ModulesConfiguration.Load());

            if (d.ShowDialog(parent) == System.Windows.Forms.DialogResult.OK)
            {
                d.Configuration.Save();
                ModulesConfiguration.Reload();
                LoadConfiguration();
                return(true);
            }
            return(false);
        }
        public AddEditEncoder(ModulesConfiguration configuration, Encoder encoder)
        {
            //
            // The InitializeComponent() call is required for Windows Forms designer support.
            //
            InitializeComponent();

            _configuration = configuration;
            _encoder       = encoder;

            for (int i = 0; i < _configuration.DigitalInputs.Length; i++)
            {
                comboBox1.Items.Add(new D(_configuration.DigitalInputs[i]));
                comboBox2.Items.Add(new D(_configuration.DigitalInputs[i]));
            }


            if (_encoder != null)
            {
                Text = "Edytuj parę wejść enkodera";
                for (int i = 0; i < comboBox1.Items.Count; i++)
                {
                    D d = (D)comboBox1.Items[i];
                    if (d.Input == _encoder.LeftInput)
                    {
                        comboBox1.SelectedItem = d;
                        break;
                    }
                }
                for (int i = 0; i < comboBox2.Items.Count; i++)
                {
                    D d = (D)comboBox2.Items[i];
                    if (d.Input == _encoder.RightInput)
                    {
                        comboBox2.SelectedItem = d;
                        break;
                    }
                }
            }
            else
            {
                Text = "Dodaj parę wejść enkodera";
            }
        }
        public AddEditDigitalOutputSetDialog(ModulesConfiguration configuration, DigitalOutputSet digitalOutputSet)
        {
            //
            // The InitializeComponent() call is required for Windows Forms designer support.
            //
            InitializeComponent();

            _configuration   = configuration;
            DigitalOutputSet = digitalOutputSet;

            foreach (DigitalOutput dos in _configuration.DigitalOutputs)
            {
                if (!(dos is DigitalOutputSet))
                {
                    checkedListBox1.Items.Add(new Output()
                    {
                        DO = dos
                    });
                }
            }

            if (DigitalOutputSet == null)
            {
                Text = "Dodaj nową grupę wyjść cyfrowych";
            }
            else
            {
                textBox2.Text = DigitalOutputSet.ID;
                textBox1.Text = DigitalOutputSet.Description;

                foreach (DigitalOutput dos in DigitalOutputSet.DigitalOutputs)
                {
                    for (int i = 0; i < checkedListBox1.Items.Count; i++)
                    {
                        if (dos == ((Output)checkedListBox1.Items[i]).DO)
                        {
                            checkedListBox1.SetItemChecked(i, true);
                            break;
                        }
                    }
                }
            }
        }
 public static ModulesConfiguration Reload()
 {
     __instance = null;
     return(Load());
 }
        public static ModulesConfiguration Load()
        {
            if (__instance == null)
            {
                if (!File.Exists(ConfigurationFilePath))
                {
                    throw new FileNotFoundException(ConfigurationFilePath);
                }
                ModulesConfiguration c   = new ModulesConfiguration();
                XmlDocument          xml = new XmlDocument();
                xml.Load(ConfigurationFilePath);

                // zmienna pomocnicza
                Device f = null;


                // wczytanie urządzeń
                List <Device> devices = new List <Device>();
                XmlNodeList   nodes   = xml.SelectNodes("configuration/devices/device");
                foreach (XmlNode node in nodes)
                {
                    Device d = Device.Load(node);
                    f = devices.Find(delegate(Device o)
                    {
                        return(o.Id == d.Id);
                    });
                    if (f == null)
                    {
                        devices.Add(Device.Load(node));
                    }
                    else
                    {
                        throw new Exception("Istnieje już urządzenie o identyfikatorze '" + d.Id + "'.");
                    }
                }

                c.Devices = devices.ToArray();


                // wczytanie konfiguracji wyjść cyfrowych
                List <DigitalOutput> outputs = new List <DigitalOutput>();
                nodes = xml.SelectNodes("configuration/digitalOutputs/output");
                foreach (XmlNode node in nodes)
                {
                    DigitalOutput output = DigitalOutput.Load(node);

                    // znalezienie urządzenia

                    f = devices.Find(delegate(Device o)
                    {
                        return(o.Id == output.DeviceId);
                    });
                    if (f == null)
                    {
                        throw new Exception("Konfiguracja nie zawiera informacji o urządzeniu z identyfikatorem '" + output.DeviceId + "'.");
                    }

                    output.Device = f;

                    outputs.Add(output);
                }
                c.DigitalOutputs = outputs.ToArray();

                // wczytanie konfiguracji zbiorów wyjść cyfrowych
                nodes = xml.SelectNodes("configuration/digitalOutputs/outputSet");
                foreach (XmlNode node in nodes)
                {
                    DigitalOutputSet dos = DigitalOutputSet.Load(c.DigitalOutputs, node);
                    outputs.Add(dos);
                }
                c.DigitalOutputs = outputs.ToArray();


                // wczytanie konfiguracji wejść cyfrowych
                List <DigitalInput> inputs = new List <DigitalInput>();
                nodes = xml.SelectNodes("configuration/digitalInputs/input");
                foreach (XmlNode node in nodes)
                {
                    DigitalInput input = DigitalInput.Load(node);

                    // znalezienie urządzenia

                    f = devices.Find(delegate(Device o)
                    {
                        return(o.Id == input.DeviceId);
                    });
                    if (f == null)
                    {
                        throw new Exception("Konfiguracja nie zawiera informacji o urządzeniu z identyfikatorem '" + input.DeviceId + "'.");
                    }

                    input.Device = f;

                    inputs.Add(input);
                }

                c.DigitalInputs = inputs.ToArray();

                // wczytanie konfiguracji enkoderów
                List <Encoder> encoders = new List <Encoder>();
                nodes = xml.SelectNodes("configuration/encoders/encoder");
                foreach (XmlNode node in nodes)
                {
                    Encoder e = Encoder.Load(c.DigitalInputs, node);
                    encoders.Add(e);
                }
                c.Encoders = encoders.ToArray();

                // wczytanie konfiguracji wyświetlaczy 7-led
                List <LED7DisplayOutput> ledOutputs = new List <LED7DisplayOutput>();
                nodes = xml.SelectNodes("configuration/displays7LED/display");
                foreach (XmlNode node in nodes)
                {
                    LED7DisplayOutput output = LED7DisplayOutput.Load(node);

                    // znalezienie urządzenia

                    f = devices.Find(delegate(Device o)
                    {
                        return(o.Id == output.DeviceId);
                    });
                    if (f == null)
                    {
                        throw new Exception("Konfiguracja nie zawiera informacji o urządzeniu z identyfikatorem '" + output.DeviceId + "'.");
                    }

                    output.Device = f;

                    ledOutputs.Add(output);
                }

                // sprawdzenie czy jakaś nazwa się nie powtarza
                foreach (DigitalOutput digo in outputs)
                {
                    int index = ledOutputs.Count;
                    while (index-- > 0)
                    {
                        if (ledOutputs[index].ID == digo.ID)
                        {
                            ledOutputs.RemoveAt(index);
                        }
                    }
                }

                c.LED7DisplayOutputs = ledOutputs.ToArray();

                // wczytanie konfiguracji zbiorów wyświetlaczy
                nodes = xml.SelectNodes("configuration/displays7LED/displaySet");
                foreach (XmlNode node in nodes)
                {
                    LED7DisplayOutputSet dos = LED7DisplayOutputSet.Load(c.LED7DisplayOutputs, node);
                    ledOutputs.Add(dos);
                }
                c.LED7DisplayOutputs = ledOutputs.ToArray();

                // wczytanie słownika dla wyświetlaczy 7-led
                LED7DisplaysDictionary.Load(xml.SelectSingleNode("configuration/displays7LEDDictionary"));

                CreateOrDeletePeripherals(c);

                __instance = c;
            }
            return(__instance);
        }
        public static void CreateOrDeletePeripherals(ModulesConfiguration configuration)
        {
            if (configuration.Devices != null)
            {
                List <DigitalInput>      inputs   = new List <DigitalInput>();
                List <DigitalOutput>     outputs  = new List <DigitalOutput>();
                List <LED7DisplayOutput> displays = new List <LED7DisplayOutput>();
                List <Encoder>           encoders = new List <Encoder>();
                foreach (Device d in configuration.Devices)
                {
                    // znalezienie wszystkich wejść tego urządzenia
                    List <DigitalInput> dis = new List <DigitalInput>();
                    if (configuration.DigitalInputs != null)
                    {
                        foreach (DigitalInput di in configuration.DigitalInputs)
                        {
                            if (di.DeviceId == d.Id && di.Index >= 0 && di.Index < d.Type.DigitalInputs)
                            {
                                DigitalInput ddd = dis.Find(delegate(DigitalInput o)
                                {
                                    return(o.Index == di.Index);
                                });
                                if (ddd == null)
                                {
                                    dis.Add(di);
                                }
                            }
                        }
                    }
                    // dodanie brakujących
                    for (int i = 0; i < d.Type.DigitalInputs; i++)
                    {
                        if (dis.Find(delegate(DigitalInput o)
                        {
                            return(o.Index == i);
                        }) == null)
                        {
                            dis.Add(new DigitalInput()
                            {
                                DeviceId       = d.Id,
                                Device         = d,
                                Index          = i,
                                ID             = string.Format("{0}:input_{1}", d.Id, i.ToString("000")),
                                Description    = "Cyfrowe wejście",
                                Repeat         = false,
                                RepeatAfter    = 200,
                                RepeatInterval = 200,
                            });
                        }
                    }

                    inputs.AddRange(dis);

                    // sprawdzenie czy istnieją wszystkie wejścia dla enkoderów
                    if (configuration.Encoders != null)
                    {
                        List <DigitalInput> reserved = new List <DigitalInput>();
                        foreach (Encoder e in configuration.Encoders)
                        {
                            DigitalInput linput = inputs.Find(delegate(DigitalInput o)
                            {
                                return(o.ID == e.LeftInput.ID);
                            });
                            if (linput == null)
                            {
                                throw new Exception("Brak wejścia '" + e.LeftInput.ToString() + "' do obsługi enkodera.");
                            }

                            if (reserved.Contains(linput))
                            {
                                continue;
                            }

                            DigitalInput rinput = inputs.Find(delegate(DigitalInput o)
                            {
                                return(o.ID == e.RightInput.ID);
                            });
                            if (rinput == null)
                            {
                                throw new Exception("Brak wejścia '" + e.RightInput.ToString() + "' do obsługi enkodera.");
                            }

                            if (reserved.Contains(rinput))
                            {
                                continue;
                            }

                            reserved.Add(linput);
                            reserved.Add(rinput);
                            e.LeftInput  = linput;
                            e.RightInput = rinput;
                            encoders.Add(e);
                        }
                    }

                    // znalezienie wszystkich wyjść cyfrowych tego urządzenia
                    List <DigitalOutput> dos = new List <DigitalOutput>();
                    if (configuration.DigitalOutputs != null)
                    {
                        foreach (DigitalOutput di in configuration.DigitalOutputs)
                        {
                            if (di.DeviceId == d.Id && di.Index >= 0 && di.Index < d.Type.DigitalOutputs)
                            {
                                DigitalOutput ddd = dos.Find(delegate(DigitalOutput o)
                                {
                                    return(o.Index == di.Index);
                                });
                                if (ddd == null)
                                {
                                    dos.Add(di);
                                }
                            }
                        }
                    }
                    // dodanie brakujących
                    for (int i = 0; i < d.Type.DigitalOutputs; i++)
                    {
                        if (dos.Find(delegate(DigitalOutput o)
                        {
                            return(o.Index == i);
                        }) == null)
                        {
                            dos.Add(new DigitalOutput()
                            {
                                DeviceId    = d.Id,
                                Device      = d,
                                Index       = i,
                                ID          = string.Format("{0}:output_{1}", d.Id, i.ToString("000")),
                                Description = "Cyfrowe wyjście",
                            });
                        }
                    }

                    // sprawdzenie zbiorów wyjść
                    if (configuration.DigitalOutputs != null)
                    {
                        List <DigitalOutputSet> dosets = new List <DigitalOutputSet>();
                        foreach (DigitalOutput di in configuration.DigitalOutputs)
                        {
                            if (di is DigitalOutputSet)
                            {
                                DigitalOutputSet dose = (DigitalOutputSet)di;
                                if (dose.DigitalOutputs != null && dose.DigitalOutputs.Length > 0)
                                {
                                    List <DigitalOutput> doses = new List <DigitalOutput>(dose.DigitalOutputs);
                                    int index = doses.Count;
                                    while (index-- > 0)
                                    {
                                        // znalezienie wyjścia o danym id
                                        if (dos.Find(delegate(DigitalOutput digo)
                                        {
                                            return(digo.ID == doses[index].ID);
                                        }) == null)
                                        {
                                            doses.RemoveAt(index);
                                        }
                                    }

                                    if (doses.Count > 0)
                                    {
                                        dose.DigitalOutputs = doses.ToArray();
                                        dosets.Add(dose);
                                    }
                                }
                            }
                        }
                        dos.AddRange(dosets.ToArray());
                    }

                    outputs.AddRange(dos);

                    // znalezienie wszystkich wyświetlaczy 7led
                    List <LED7DisplayOutput> led7 = new List <LED7DisplayOutput>();
                    if (configuration.LED7DisplayOutputs != null)
                    {
                        foreach (LED7DisplayOutput di in configuration.LED7DisplayOutputs)
                        {
                            if (di.DeviceId == d.Id && di.Index >= 0 && di.Index < d.Type.Displays7LED)
                            {
                                LED7DisplayOutput ddd = led7.Find(delegate(LED7DisplayOutput o)
                                {
                                    return(o.Index == di.Index);
                                });
                                if (ddd == null)
                                {
                                    di.Device = d;
                                    led7.Add(di);
                                }
                            }
                        }
                    }
                    // dodanie brakujących
                    for (int i = 0; i < d.Type.Displays7LED; i++)
                    {
                        if (led7.Find(delegate(LED7DisplayOutput o)
                        {
                            return(o.Index == i);
                        }) == null)
                        {
                            led7.Add(new LED7DisplayOutput()
                            {
                                DeviceId    = d.Id,
                                Device      = d,
                                Index       = i,
                                ID          = string.Format("{0}:7ledDisplay_{1}", d.Id, i.ToString("000")),
                                Description = "Wyświetlacz 7-LED",
                            });
                        }
                    }

                    // sprawdzenie zbiorów wyjść
                    if (configuration.LED7DisplayOutputs != null)
                    {
                        List <LED7DisplayOutputSet> dosets = new List <LED7DisplayOutputSet>();
                        foreach (LED7DisplayOutput di in configuration.LED7DisplayOutputs)
                        {
                            if (di is LED7DisplayOutputSet)
                            {
                                LED7DisplayOutputSet dose = (LED7DisplayOutputSet)di;
                                if (dose.Displays != null && dose.Displays.Length > 0)
                                {
                                    List <Display> doses = new List <Display>(dose.Displays);
                                    int            index = doses.Count;
                                    while (index-- > 0)
                                    {
                                        // znalezienie wyjścia o danym id
                                        if (led7.Find(delegate(LED7DisplayOutput digo)
                                        {
                                            return(digo.ID == doses[index].LED7Display.ID);
                                        }) == null)
                                        {
                                            doses.RemoveAt(index);
                                        }
                                    }

                                    if (doses.Count > 0)
                                    {
                                        dose.Displays = doses.ToArray();
                                        dosets.Add(dose);
                                    }
                                }
                            }
                        }
                        led7.AddRange(dosets.ToArray());
                    }

                    displays.AddRange(led7);
                }

                configuration.DigitalInputs      = inputs.ToArray();
                configuration.Encoders           = encoders.ToArray();
                configuration.DigitalOutputs     = outputs.ToArray();
                configuration.LED7DisplayOutputs = displays.ToArray();
            }
        }
        public AddEditLED7DisplayOutputSetDialog(ModulesConfiguration configuration, LED7DisplayOutputSet led7DisplayOutputSet)
        {
            //
            // The InitializeComponent() call is required for Windows Forms designer support.
            //
            InitializeComponent();

            _configuration       = configuration;
            LED7DisplayOutputSet = led7DisplayOutputSet;

            comboBox1.Items.Add(Align.Left);
            comboBox1.Items.Add(Align.Center);
            comboBox1.Items.Add(Align.Right);
            comboBox1.SelectedItem = Align.Left;
            comboBox2.Items.Add(Trim.Left);
            comboBox2.Items.Add(Trim.Right);
            comboBox2.SelectedItem = Trim.Right;
            comboBox3.Items.Add(Append.None);
            comboBox3.Items.Add(Append.Left);
            comboBox3.Items.Add(Append.Right);
            comboBox3.SelectedItem = Append.None;

            foreach (LED7DisplayOutput dos in _configuration.LED7DisplayOutputs)
            {
                if (!(dos is LED7DisplayOutputSet))
                {
                    listBox1.Items.Add(new Output()
                    {
                        DO = dos
                    });
                }
            }

            if (LED7DisplayOutputSet == null)
            {
                Text = "Dodaj nową grupę wyświetlaczy 7-LED";
            }
            else
            {
                Text = "Edytuj grupę wyświetlaczy 7-LED";
                Array.Sort(LED7DisplayOutputSet.Displays);
                for (int i = 0; i < LED7DisplayOutputSet.Displays.Length; i++)
                {
                    for (int j = 0; j < listBox1.Items.Count; j++)
                    {
                        if (LED7DisplayOutputSet.Displays[i].LED7Display == ((Output)listBox1.Items[j]).DO)
                        {
                            Output o = (Output)listBox1.Items[j];
                            listBox1.Items.Remove(o);
                            listBox2.Items.Add(o);
                            break;
                        }
                    }
                }
                textBox2.Text          = LED7DisplayOutputSet.ID;
                textBox1.Text          = LED7DisplayOutputSet.Description;
                comboBox1.SelectedItem = LED7DisplayOutputSet.Align;
                comboBox2.SelectedItem = LED7DisplayOutputSet.Trim;
                comboBox3.SelectedItem = LED7DisplayOutputSet.Append;
                textBox3.Text          = LED7DisplayOutputSet.AppendString;
            }
        }
        void Button1Click(object sender, EventArgs e)
        {
            // sprawdzenie czy wybrano typ
            if (comboBox1.SelectedIndex == -1)
            {
                MessageBox.Show(this, "Nie wybrano typu urządzenia.", "Uwaga", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                comboBox1.Focus();
                return;
            }
            DeviceType dt = (DeviceType)comboBox1.SelectedItem;

            // sprawdzenie czy można dodać urządzenie tego typu (tylko jedno urządzenie danego typu może być w systemie - nie dotyczy rozszerzeń)
            foreach (Device d in _configuration.Devices)
            {
                if (d.Type == dt)
                {
                    MessageBox.Show(this, "Nie można dodać urządzenia o wybranym typie. Tylko jedno urządzenie danego typu może być używane. Proszę wybrać inny typ lub anulować.", "Uwaga", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    comboBox1.Focus();
                    return;
                }
            }

            // sprawdzenie czy wpisano id
            string id = textBox4.Text.Trim();

            if (string.IsNullOrEmpty(id))
            {
                textBox4.Text = "";
                MessageBox.Show(this, "Nie wpisano identyfikatora urządzenia.", "Uwaga", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                textBox4.Focus();
                return;
            }

            string description = textBox5.Text;

            if (Device != null)
            {
                // sprawdzenie czy wybrany typ ma mniejsze możliwości i ostrzeżenie użytkownika
                if (Device.Type != dt && (Device.Type.DigitalInputs < dt.DigitalInputs || Device.Type.DigitalOutputs < dt.DigitalOutputs || Device.Type.Displays7LED < dt.Displays7LED))
                {
                    if (MessageBox.Show(this, "Nowy typ urządzenia ma mniejsze możliwości od poprzedniego. Zmiana typu spowoduje usunięcie dostępnych peryferii spoza zakresu.\r\n\r\nCzy na pewno chcesz zmienić typ urządzenia ?", "Pytanie", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
                    {
                        return;
                    }
                }
                Device dd = Device.Create(id, description, dt);

                // podmiana urządzenia do którego porzypięte są peryferia
                foreach (DigitalInput di in _configuration.DigitalInputs)
                {
                    if (di.DeviceId == Device.Id)
                    {
                        di.Device = dd;
                    }
                }

                // podmiana urządzenia
                List <Device> devices = new List <Device>(_configuration.Devices);
                devices.Remove(Device);
                devices.Add(dd);
                devices.Sort();
                _configuration.Devices = devices.ToArray();
            }
            else
            {
                Device = Device.Create(id, description, dt);
                List <Device> devices = new List <Device>(_configuration.Devices);
                devices.Add(Device);
                devices.Sort();
                _configuration.Devices = devices.ToArray();
            }
            ModulesConfiguration.CreateOrDeletePeripherals(_configuration);
            DialogResult = DialogResult.OK;
            Close();
        }