Exemple #1
0
        public override Capacity GetCapacity(ControlProcessorHardware cph, DeviceSubType deviceSubType)
        {
            if (deviceSubType == DeviceSubType.Motherboard && (cph.ModuleType == HardwareModuleType.Button || cph.ModuleType == HardwareModuleType.Axis))
            {
                return new Capacity {
                           Names = GetConnectedDevices().ToArray()
                }
            }
            ;
            if (cph.ModuleType == HardwareModuleType.Axis && deviceSubType == DeviceSubType.Control)
            {
                return new Capacity {
                           Names = Enumerable.Range(0, ((JoystickDevice)Devices[cph.MotherBoardId]).GetCapabilities().AxesCount).ToArray().Select(x => x.ToString(CultureInfo.InvariantCulture)).ToArray()
                }
            }
            ;
            if (cph.ModuleType == HardwareModuleType.Button && deviceSubType == DeviceSubType.Control)
            {
                return new Capacity {
                           Names = Enumerable.Range(0, ((JoystickDevice)Devices[cph.MotherBoardId]).GetCapabilities().ButtonCount).ToArray().Select(x => x.ToString(CultureInfo.InvariantCulture)).ToArray()
                }
            }
            ;
            return(new Capacity {
                DeviceSubtypeIsNotSuitableForCurrentHardware = true
            });
        }
    }
}
        public override Capacity GetCapacity(ControlProcessorHardware cph, DeviceSubType deviceSubType)
        {
            if (cph.ModuleType != HardwareModuleType.Button)
            {
                return new Capacity {
                           DeviceSubtypeIsNotSuitableForCurrentHardware = true
                }
            }
            ;

            switch (deviceSubType)
            {
            case DeviceSubType.Motherboard:
                return(new Capacity {
                    Names = GetConnectedDevices().ToArray()
                });

            case DeviceSubType.Control:
                return(new Capacity {
                    Names = Enumerable.Range(0, 255).ToArray().Select(x => x.ToString(CultureInfo.InvariantCulture)).ToArray()
                });

            default:
                return(new Capacity {
                    DeviceSubtypeIsNotSuitableForCurrentHardware = true
                });
            }
        }
    }
        public IEnumerable <ControlEventBase> GetNewEvent()
        {
            if (string.IsNullOrEmpty(Connections[0].GetAssignedHardware()))
            {
                return(null);
            }

            var ad         = Profile.AccessDescriptor.GetAccessDesciptorById(AssignedAccessDescriptorId);
            var lineState  = ((DescriptorBinaryOutput)ad).GetLineState();
            var powerState = ad.IsPowerOn();

            if (lineState == _previousState && powerState == _previousPowerState)
            {
                return(null);
            }
            _previousState      = lineState;
            _previousPowerState = powerState;
            var ev = new LampEvent
            {
                Hardware = ControlProcessorHardware.GenerateByGuid(Connections[0].GetAssignedHardware()),
                IsOn     = _previousPowerState && _previousState
            };

            return(new List <ControlEventBase> {
                ev
            });
        }
Exemple #4
0
        public override void LoadAdditionals(XPathNavigator reader)
        {
            _usedHardware.Clear();
            Connections.Clear();
            var readerAdd = reader.Select("UsedHardware/Hardware");

            while (readerAdd.MoveNext())
            {
                var id = readerAdd.Current.GetAttribute("Id", readerAdd.Current.NamespaceURI);
                id = ControlProcessorHardware.FixForNewVersion(id);
                _usedHardware.Add(id, false);
            }
            readerAdd = reader.Select("Connectors/Connector");
            while (readerAdd.MoveNext())
            {
                var c = new Connector
                {
                    Id    = int.Parse(readerAdd.Current.GetAttribute("Id", readerAdd.Current.NamespaceURI)),
                    Order = int.Parse(readerAdd.Current.GetAttribute("Order", readerAdd.Current.NamespaceURI)),
                    Name  = readerAdd.Current.GetAttribute("Name", readerAdd.Current.NamespaceURI),
                };
                var item = new Assignment();
                item.SetConnector(c);
                item.SetAssignedHardware(readerAdd.Current.GetAttribute("AssignedCode", readerAdd.Current.NamespaceURI));
                Connections.Add(item);
            }
        }
Exemple #5
0
        public IEnumerable <ControlEventBase> GetNewEvent()
        {
            if (string.IsNullOrEmpty(Connections[0].GetAssignedHardware()))
            {
                return(null);
            }

            var ad       = Profile.AccessDescriptor.GetAccessDesciptorById(AssignedAccessDescriptorId);
            var position = ((DescriptorIndicator)ad).GetIndicatorValue();

            if (position == null || position == _previousPosition)
            {
                return(null);
            }
            _previousPosition = position;
            var ev = new SteppingMotorEvent
            {
                Hardware = ControlProcessorHardware.GenerateByGuid(Connections[0].GetAssignedHardware()),
                Position = (short)CalculateStepperPosition((short)position)
            };

            return(new List <ControlEventBase> {
                ev
            });
        }
Exemple #6
0
        /// <summary>
        /// Прекратить поиск
        /// </summary>
        public static void StopComponentSearch()
        {
            if (string.IsNullOrEmpty(_contolInSearchGuid))
            {
                return;
            }
            ControlEventBase ev = null;

            if (SoftDumpCache.ContainsKey(_contolInSearchGuid))
            {
                ev = SoftDumpCache[_contolInSearchGuid];
            }
            if (ev == null)
            {
                var hardware = ControlProcessorHardware.GenerateByGuid(_contolInSearchGuid);
                if (hardware.ModuleType == HardwareModuleType.BinaryOutput)
                {
                    ev = new LampEvent
                    {
                        Hardware = hardware,
                        IsOn     = false
                    };
                }
                if (hardware.ModuleType == HardwareModuleType.Indicator || hardware.ModuleType == HardwareModuleType.LedMatrixIndicator)
                {
                    ev = new IndicatorEvent
                    {
                        Hardware      = hardware,
                        IndicatorText = "       "
                    };
                }
            }
            PostOutgoingSearchEvent(ev);
            _contolInSearchGuid = string.Empty;
        }
Exemple #7
0
        /// <summary>
        /// Событие таймера при котором меняется фаза поиска (погасить контрол/включить контрол)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void OnTimedEvent(object sender, EventArgs e)
        {
            _searchPhase = !_searchPhase;
            if (string.IsNullOrEmpty(_contolInSearchGuid))
            {
                return;
            }
            var hardware = ControlProcessorHardware.GenerateByGuid(_contolInSearchGuid);

            if (hardware.ModuleType == HardwareModuleType.BinaryOutput)
            {
                var ev = new LampEvent
                {
                    Hardware = hardware,
                    IsOn     = _searchPhase
                };
                PostOutgoingSearchEvent(ev);
            }
            if (hardware.ModuleType == HardwareModuleType.Indicator)
            {
                var ev = new IndicatorEvent
                {
                    Hardware      = hardware,
                    IndicatorText = _searchPhase ? "-------" : "       "
                };
                PostOutgoingSearchEvent(ev);
            }
        }
Exemple #8
0
        /// <summary>
        /// Получить информацию о возможностях устройства
        /// </summary>
        /// <param name="cph"></param>
        /// <param name="deviceSubType"></param>
        public static Capacity GetCapacity(ControlProcessorHardware cph, DeviceSubType deviceSubType)
        {
            if (deviceSubType != DeviceSubType.Motherboard)
            {
                foreach (var hardware in Hardwares.Where(hardware => hardware.GetConnectedDevices().Contains(cph.MotherBoardId)))
                {
                    return(hardware.GetCapacity(cph, deviceSubType));
                }
            }
            var capacity = new Capacity();

            foreach (var c in Hardwares.Select(hardware => hardware.GetCapacity(cph, deviceSubType)))
            {
                capacity.Add(c);
            }
            return(capacity);
        }
        public override void LoadAdditionals(XPathNavigator reader)
        {
            Connections.Clear();
            var readerAdd = reader.Select("Connectors/Connector");

            while (readerAdd.MoveNext())
            {
                var c = new Connector();
                c.Id    = int.Parse(readerAdd.Current.GetAttribute("Id", readerAdd.Current.NamespaceURI));
                c.Order = c.Id;
                c.Name  = readerAdd.Current.GetAttribute("Name", readerAdd.Current.NamespaceURI);
                var a = new AssignmentForButton();
                a.SetInverseState(bool.Parse(readerAdd.Current.GetAttribute("Invert", readerAdd.Current.NamespaceURI)));
                a.SetAssignedHardware(ControlProcessorHardware.FixForNewVersion(readerAdd.Current.GetAttribute("AssignedHardware", readerAdd.Current.NamespaceURI)));
                a.SetConnector(c);
                Connections.Add(a);
            }
        }
Exemple #10
0
        public IEnumerable <ControlEventBase> GetClearEvent()
        {
            if (string.IsNullOrEmpty(Connections[0].GetAssignedHardware()))
            {
                return(new ControlEventBase[0]);
            }
            var ev = new LampEvent
            {
                Hardware = ControlProcessorHardware.GenerateByGuid(Connections[0].GetAssignedHardware()),
                IsOn     = false
            };

            // Требуется для того, чтобы при изменении, например, числа цифр в индикаторе не оставались гореть цифры
            _previousState = false;
            return(new List <ControlEventBase> {
                ev
            });
        }
        private string GetSelectedHardwareGuid()
        {
            if (!IsCorrectData().IsDataFilledCorrectly)
            {
                return(string.Empty);
            }

            var cph = new ControlProcessorHardware
            {
                ModuleType    = _hardwareSupported,
                MotherBoardId = (string)_motherboardList.SelectedItem,
                BlockId       = uint.Parse(string.IsNullOrEmpty((string)_blockId.SelectedItem) ? "0" : (string)_blockId.SelectedItem),
                ModuleId      = uint.Parse(string.IsNullOrEmpty((string)_moduleList.SelectedItem) ? "0" : (string)_moduleList.SelectedItem),
                ControlId     = uint.Parse(string.IsNullOrEmpty((string)_controlId.SelectedItem) ? "0" : (string)_controlId.SelectedItem),
            };

            return(cph.GetHardwareGuid());
        }
        public IEnumerable <ControlEventBase> GetClearEvent()
        {
            if (string.IsNullOrEmpty(Connections[0].GetAssignedHardware()))
            {
                return(new ControlEventBase[0]);
            }
            var eventArray = new List <ControlEventBase>();

            var digitsNumber          = ((DescriptorIndicator)AccessDescriptor).GetNumberOfDigits();
            var elementInDigitCounter = 0;
            var digitsCounter         = 0;
            var hw               = ControlProcessorHardware.GenerateByGuid(Connections[0].GetAssignedHardware());
            var currentBlockId   = hw.BlockId;
            var currentControlId = hw.ControlId;

            while (digitsCounter < digitsNumber)
            {
                var hardware = ControlProcessorHardware.GenerateByGuid(Connections[0].GetAssignedHardware());
                if (currentControlId == 16)
                {
                    currentBlockId++;
                    currentControlId = 0;
                }

                hardware.ControlId = currentControlId;
                hardware.BlockId   = currentBlockId;
                var ev = new LampEvent
                {
                    Hardware = hardware,
                    IsOn     = false
                };
                eventArray.Add(ev);
                currentControlId++;
                elementInDigitCounter++;
                if (elementInDigitCounter == 8)
                {
                    elementInDigitCounter = 0;
                    digitsCounter++;
                }
            }
            // Требуется для того, чтобы при изменении, например, числа цифр в индикаторе не оставались гореть цифры
            _previousIndicatorText = "";
            return(eventArray);
        }
        private void RememberSelectedItemOnOpenCombobox(ComboBox cb, DeviceSubType deviceSubType)
        {
            _selectedItemOfOpenedCombobox = (string)cb.SelectedItem;
            var cph = new ControlProcessorHardware
            {
                ModuleType    = _hardwareSupported,
                MotherBoardId = (string)_motherboardList.SelectedItem,
                BlockId       = uint.Parse(string.IsNullOrEmpty((string)_blockId.SelectedItem) ? "0" : (string)_blockId.SelectedItem),
                ModuleId      = uint.Parse(string.IsNullOrEmpty((string)_moduleList.SelectedItem) ? "0" : (string)_moduleList.SelectedItem),
                ControlId     = uint.Parse(string.IsNullOrEmpty((string)_controlId.SelectedItem) ? "0" : (string)_controlId.SelectedItem),
            };

            cb.Items.Clear();
            var capacity = HardwareManager.GetCapacity(cph, deviceSubType).Names;

            foreach (var c in capacity)
            {
                cb.Items.Add(c);
            }
        }
Exemple #14
0
        public ControlProcessorHardware[] GetAllAssignedHardwares()
        {
            var modulesString = new List <string>();
            var modules       = new List <ControlProcessorHardware>();

            foreach (var controlProcessor in _storage.Values)
            {
                var a = controlProcessor.GetUsedHardwareList().Distinct();
                foreach (var assignment in a)
                {
                    if (string.IsNullOrEmpty(assignment))
                    {
                        continue;
                    }

                    var cph = ControlProcessorHardware.GenerateByGuid(assignment);
                    if (cph == null)
                    {
                        continue;
                    }

                    if (cph.ModuleType != HardwareModuleType.Button)
                    {
                        continue;
                    }

                    var module = cph.MotherBoardId + "|" + cph.ModuleType + "|" + cph.ModuleId;

                    if (modulesString.Contains(module))
                    {
                        continue;
                    }

                    modules.Add(cph);
                    modulesString.Add(module);
                }
            }
            return(modules.ToArray());
        }
        public IEnumerable <ControlEventBase> GetNewEvent()
        {
            if (string.IsNullOrEmpty(Connections[0].GetAssignedHardware()))
            {
                return(null);
            }
            var text = AccessDescriptor.GetIndicatorText();

            if (text == _previousIndicatorText)
            {
                return(null);
            }
            _previousIndicatorText = text;
            var ev = new IndicatorEvent
            {
                Hardware      = ControlProcessorHardware.GenerateByGuid(Connections[0].GetAssignedHardware()),
                IndicatorText = text,
            };

            return(new List <ControlEventBase> {
                ev
            });
        }
 public virtual void LoadAdditionals(XPathNavigator reader)
 {
     // Фикс для старой версии профиля
     Connections[0].SetAssignedHardware(reader.GetAttribute("AssignedHardware", reader.NamespaceURI));
     if (string.IsNullOrEmpty(Connections[0].GetAssignedHardware()))
     {
         Connections.Clear();
         var readerAdd = reader.Select("Connectors/Connector");
         while (readerAdd.MoveNext())
         {
             var c = new Connector
             {
                 Id    = int.Parse(readerAdd.Current.GetAttribute("Id", readerAdd.Current.NamespaceURI)),
                 Order = int.Parse(readerAdd.Current.GetAttribute("Order", readerAdd.Current.NamespaceURI)),
                 Name  = readerAdd.Current.GetAttribute("Name", readerAdd.Current.NamespaceURI)
             };
             var a = new AssignmentForButton();
             a.SetInverseState(bool.Parse(readerAdd.Current.GetAttribute("Invert", readerAdd.Current.NamespaceURI)));
             a.SetAssignedHardware(ControlProcessorHardware.FixForNewVersion(readerAdd.Current.GetAttribute("AssignedHardware", readerAdd.Current.NamespaceURI)));
             a.SetConnector(c);
             Connections.Add(a);
         }
     }
 }
Exemple #17
0
        /// <summary>
        /// Циклическая функция отправки команд дампа по одной и ожидания дампа всех кнопок
        /// </summary>
        private void DumpLoop()
        {
            Thread.Sleep(2000);
            _inDump = true;
            var hardwareArray   = new ControlProcessorHardware[1];
            var dumpQueueHashes = new List <string>();

            foreach (var controlProcessorHardware in _allHardwareInUse)
            {
                // Если железо не Arcc
                if (!Devices.ContainsKey(controlProcessorHardware.MotherBoardId))
                {
                    continue;
                }

                // Если такая пара "материнская плата + модуль" уже обрабатывались
                var hash = controlProcessorHardware.MotherBoardId + "|" + controlProcessorHardware.ModuleId + "|" + controlProcessorHardware.ModuleType;
                if (dumpQueueHashes.Contains(hash))
                {
                    continue;
                }
                System.Diagnostics.Debug.Print("Dumping: " + controlProcessorHardware.MotherBoardId);//+ hash);
                lock (_dumpSyncRoot)
                {
                    // Очищаем массивы сработавших событий
                    for (var i = 0; i < _binaryInputDumpState.Length; i++)
                    {
                        _binaryInputDumpState[i] = false;
                    }
                    for (var i = 0; i < _buttonDumpState.Length; i++)
                    {
                        _buttonDumpState[i] = false;
                    }
                    // Отправляем пару "материнская плата + модуль" дампиться
                    HardwareInDump    = controlProcessorHardware;
                    hardwareArray[0]  = controlProcessorHardware;
                    _moduleTypeInDump = controlProcessorHardware.ModuleId > 255 ? ModuleTypeInDump.BinaryInput : ModuleTypeInDump.Button;
                }
                Devices[controlProcessorHardware.MotherBoardId].Dump(hardwareArray);
                var lastUpdateTime = DateTime.Now;
                var stateCount     = 0;

                //var m = string.Format("{0} module {1}", HardwareInDump.MotherBoardId, _moduleTypeInDump);
                //Problems.AddOrUpdateProblem(m, "Дамп ", ProblemHideOnFixOptions.HideItemAndDescription, false);
                // Ждём дампа всех кнопок модуля или перерыва в поставке данных и переходим к дампу следующего модуля
                while (true)
                {
                    if (_quit)
                    {
                        return;
                    }
                    lock (_dumpSyncRoot)
                    {
                        var buttonsDumpedCount = 0;
                        if (_moduleTypeInDump == ModuleTypeInDump.Button)
                        {
                            // Если все кнопки сдамплены переходим к следующему модулю
                            if (_buttonDumpState.All(b => b))
                            {
                                System.Diagnostics.Debug.Print("Dumped successfully");
                                var moduleType = _moduleTypeInDump.ToString();
                                var message    = string.Format("{0} module {1}", HardwareInDump.MotherBoardId, moduleType);
                                Problems.Problems.AddOrUpdateProblem(message, "", ProblemHideOnFixOptions.HideItemAndDescription, true);
                                break;
                            }
                            buttonsDumpedCount = _buttonDumpState.Count(b => b);
                        }
                        if (_moduleTypeInDump == ModuleTypeInDump.BinaryInput)
                        {
                            // Если все кнопки сдамплены переходим к следующему модулю
                            if (_binaryInputDumpState.All(b => b))
                            {
                                System.Diagnostics.Debug.Print("Dumped successfully");

                                var moduleType = _moduleTypeInDump.ToString();
                                var message    = string.Format("{0} module {1}", HardwareInDump.MotherBoardId, moduleType);
                                Problems.Problems.AddOrUpdateProblem(message, "", ProblemHideOnFixOptions.HideItemAndDescription, true);
                                break;
                            }
                            buttonsDumpedCount = _binaryInputDumpState.Count(b => b);
                        }
                        // Если прошло X миллисекунд и ни одной новой кнопки не сдамплено, значит дамп окончен
                        if (buttonsDumpedCount == stateCount)
                        {
                            if (DateTime.Now - lastUpdateTime > new TimeSpan(0, 0, 0, 0, 1000))
                            {
                                var moduleType   = _moduleTypeInDump.ToString();
                                var buttonsArray = _moduleTypeInDump == ModuleTypeInDump.Button
                                    ? _buttonDumpState
                                    : _binaryInputDumpState;
                                var undumpedButtonsCount = _moduleTypeInDump == ModuleTypeInDump.Button
                                    ? _buttonDumpState.Length - buttonsDumpedCount
                                    : _binaryInputDumpState.Length - buttonsDumpedCount;
                                var buttonsList = string.Empty;
                                for (var i = 0; i < buttonsArray.Length; i++)
                                {
                                    if (buttonsArray[i])
                                    {
                                        continue;
                                    }
                                    if (buttonsList != string.Empty)
                                    {
                                        buttonsList += ", ";
                                    }
                                    buttonsList += (i + 1).ToString(CultureInfo.InvariantCulture);
                                }

                                var description = string.Format("Can't dump {0} keys: {1}", undumpedButtonsCount, buttonsList);
                                var message     = string.Format("{0} module {1}", HardwareInDump.MotherBoardId, moduleType);
                                Problems.Problems.AddOrUpdateProblem(message, description, ProblemHideOnFixOptions.HideItemAndDescription, false);
                                System.Diagnostics.Debug.Print("Dump failed. Dumped: " + buttonsDumpedCount);
                                break;
                            }
                        }
                        else
                        {
                            lastUpdateTime = DateTime.Now;
                            stateCount     = buttonsDumpedCount;
                        }
                    }
                    Thread.Sleep(100);
                }
            }
            _inDump = false;
        }
        private IEnumerable <ControlEventBase> LetterToControlEvents(uint digitNumber, char symbol, bool addPoint)
        {
            var eventArray     = new List <LampEvent>();
            var symbolSegments = _symbolLightedSegments[symbol];

            foreach (var i in _segmentToPinMapping)
            {
                var ev = new LampEvent
                {
                    Hardware = ControlProcessorHardware.GenerateByGuid(Connections[0].GetAssignedHardware()),
                    IsOn     = symbolSegments.Contains(i.Key) || (addPoint && i.Key == 'P')
                };
                // Note: Только для железа, где блок состоит из 16 пинов (F3)
                uint addToBlock     = 0;
                uint addToControlId = 0;
                if (ev.Hardware.ControlId == 0)
                {
                    // 12 34 56 78 - номер символа
                    // 00 11 22 33 - добавить к блоку

                    // Если нечётное
                    if (digitNumber % 2 == 1)
                    {
                        addToBlock     = (digitNumber + 1) / 2 - 1;
                        addToControlId = 0;
                    }
                    else
                    {
                        addToBlock     = digitNumber / 2 - 1;
                        addToControlId = 8;
                    }
                }
                if (ev.Hardware.ControlId == 8)
                {
                    // 1 23 45 67
                    // 0 11 22 33

                    // Если нечётное
                    if (digitNumber % 2 == 1)
                    {
                        addToBlock     = (digitNumber + 1) / 2 - 1;
                        addToControlId = 8;
                    }
                    else
                    {
                        addToBlock     = digitNumber / 2;
                        addToControlId = 0;
                    }
                }
                ev.Hardware.BlockId  += addToBlock;
                ev.Hardware.ControlId = (uint)(addToControlId + i.Value);
                //if (ev.Hardware.ControlId >= 8)
                //    ev.Hardware.ControlId = 15 - (ev.Hardware.ControlId - 8);
                // Если вышли за пределы блоков - не сохраняем  событие
                var capacity = HardwareManager.GetCapacity(ev.Hardware, DeviceSubType.Block);
                if (capacity.Names.Length == 0 || capacity.DeviceSubtypeIsNotSuitableForCurrentHardware || ev.Hardware.BlockId > capacity.Names.Select(int.Parse).Max())
                {
                    continue;
                }
                eventArray.Add(ev);
            }
            return(eventArray);
        }
Exemple #19
0
        public override Capacity GetCapacity(ControlProcessorHardware cph, DeviceSubType deviceSubType)
        {
            if (deviceSubType == DeviceSubType.Motherboard)
            {
                if (cph.ModuleType == HardwareModuleType.Axis ||
                    cph.ModuleType == HardwareModuleType.BinaryOutput ||
                    cph.ModuleType == HardwareModuleType.Button ||
                    cph.ModuleType == HardwareModuleType.Encoder ||
                    cph.ModuleType == HardwareModuleType.Indicator)
                {
                    return new Capacity {
                               Names = GetConnectedDevices().ToArray()
                    }
                }
                ;

                return(new Capacity {
                    DeviceSubtypeIsNotSuitableForCurrentHardware = true
                });
            }

            // В ARCC id любой платы задаётся байтом. 0-255
            if (deviceSubType == DeviceSubType.ExtensionBoard)
            {
                return(new Capacity {
                    Names = Enumerable.Range(0, 255).ToArray().Select(x => x.ToString(CultureInfo.InvariantCulture)).ToArray()
                });
            }

            // ARCC не имеет подразделений типа "Block"
            if (deviceSubType == DeviceSubType.Block)
            {
                return new Capacity {
                           DeviceSubtypeIsNotSuitableForCurrentHardware = true
                }
            }
            ;

            switch (cph.ModuleType)
            {
            case HardwareModuleType.Axis:
                return(new Capacity {
                    Names = Enumerable.Range(1, 8).ToArray().Select(x => x.ToString(CultureInfo.InvariantCulture)).ToArray()
                });

            case HardwareModuleType.BinaryOutput:
                return(new Capacity {
                    Names = Enumerable.Range(1, 29).ToArray().Select(x => x.ToString(CultureInfo.InvariantCulture)).ToArray()
                });

            case HardwareModuleType.Button:
                return(new Capacity {
                    Names = Enumerable.Range(1, 168).ToArray().Select(x => x.ToString(CultureInfo.InvariantCulture)).ToArray()
                });

            case HardwareModuleType.Encoder:
                return(new Capacity {
                    Names = Enumerable.Range(1, 14).ToArray().Select(x => x.ToString(CultureInfo.InvariantCulture)).ToArray()
                });

            default:
                return(new Capacity {
                    DeviceSubtypeIsNotSuitableForCurrentHardware = true
                });
            }
        }
        /// <summary>
        /// Возвращает данные о том, какие значения могут принимать параметры модуль, контрол, блок в ControlProcessor
        /// </summary>
        /// <param name="cph">Железо</param>
        /// <param name="deviceSubType">Какая часть железа интересует (модуль, блок, контрол)</param>
        /// <returns>список значений, которое может принимать параметр</returns>
        public override Capacity GetCapacity(ControlProcessorHardware cph, DeviceSubType deviceSubType)
        {
            if (deviceSubType == DeviceSubType.Motherboard)
            {
                if (cph.ModuleType == HardwareModuleType.Axis ||
                    cph.ModuleType == HardwareModuleType.BinaryOutput ||
                    cph.ModuleType == HardwareModuleType.Button ||
                    cph.ModuleType == HardwareModuleType.LedMatrixIndicator ||
                    cph.ModuleType == HardwareModuleType.SteppingMotor)
                {
                    return new Capacity {
                               Names = GetConnectedDevices().ToArray()
                    }
                }
                ;
                return(new Capacity {
                    DeviceSubtypeIsNotSuitableForCurrentHardware = true
                });
            }
            if (!Devices.ContainsKey(cph.MotherBoardId))
            {
                return new Capacity {
                           DeviceSubtypeIsNotSuitableForCurrentHardware = true
                }
            }
            ;
            var device  = (F3Device)Devices[cph.MotherBoardId];
            var outInfo = device.OutInfo;

            var extensionDeviceCapacity = new List <int>();

            f3ioAPI.OutType type;
            switch (cph.ModuleType)
            {
            case HardwareModuleType.SteppingMotor:
                type = f3ioAPI.OutType.oAxis;

                break;

            case HardwareModuleType.BinaryOutput:
                type = f3ioAPI.OutType.oLed;
                break;

            case HardwareModuleType.LedMatrixIndicator:
                type = f3ioAPI.OutType.oLed;
                break;

            default:
                return(new Capacity {
                    DeviceSubtypeIsNotSuitableForCurrentHardware = true
                });
            }
            // Выбираем все модули, которые могут управлять указанным типом железа (HardwareModuleType)
            for (var i = 0; i < outInfo.device.Length; i++)
            {
                if (outInfo.device[i].BlockCount == 0)
                {
                    continue;
                }
                if (outInfo.device[i].Block.Any(b => b.Type == type))
                {
                    extensionDeviceCapacity.Add(i);
                }
            }

            // Если запрашивался диапазон значений для модуля - возвращаем результат
            if (deviceSubType == DeviceSubType.ExtensionBoard)
            {
                return new Capacity {
                           Names = extensionDeviceCapacity.ToArray().Select(x => x.ToString(CultureInfo.InvariantCulture)).ToArray()
                }
            }
            ;

            // Если запрашивался диапазон для блока, возвращаем все блоки, управляющие нужным типом (например, нужны блоки, управляющие светодиодами.
            // При этом, нужно исключить блок, управляющий яркостью или шаговыми двигателями)
            if (deviceSubType == DeviceSubType.Block)
            {
                if (!extensionDeviceCapacity.Contains((int)cph.ModuleId))
                {
                    return new Capacity {
                               DeviceSubtypeIsNotSuitableForCurrentHardware = true
                    }
                }
                ;

                var block = new List <int>();
                for (var i = 0; i < outInfo.device[cph.ModuleId].BlockCount; i++)
                {
                    if (outInfo.device[cph.ModuleId].Block[i].Type == type)
                    {
                        block.Add(i);
                    }
                }
                return(new Capacity {
                    Names = block.ToArray().Select(x => x.ToString(CultureInfo.InvariantCulture)).ToArray()
                });
            }


            if (deviceSubType != DeviceSubType.Control)
            {
                return new Capacity {
                           DeviceSubtypeIsNotSuitableForCurrentHardware = true
                }
            }
            ;
            // У модуля шагового двигателя шаги задаются в блоке, поэтому нет такого понятия как Control
            if (cph.ModuleType == HardwareModuleType.SteppingMotor)
            {
                return new Capacity {
                           DeviceSubtypeIsNotSuitableForCurrentHardware = true
                }
            }
            ;
            // Параноидальная проверка. Если указанный модуль не существует
            if (!extensionDeviceCapacity.Contains((int)cph.ModuleId))
            {
                return new Capacity {
                           DeviceSubtypeIsNotSuitableForCurrentHardware = true
                }
            }
            ;
            // Если число блоков модуля равно нулю (такого быть не должно)
            if (outInfo.device[cph.ModuleId].BlockCount == 0)
            {
                return new Capacity {
                           DeviceSubtypeIsNotSuitableForCurrentHardware = true
                }
            }
            ;

            return(cph.ModuleType == HardwareModuleType.LedMatrixIndicator
                ? new Capacity {
                Names = new[] { 0, 8 }.ToArray().Select(x => x.ToString(CultureInfo.InvariantCulture)).ToArray()
            }
                : new Capacity {
                Names = Enumerable.Range(0, outInfo.device[cph.ModuleId].Block[cph.BlockId].Capacity).ToArray().Select(x => x.ToString(CultureInfo.InvariantCulture)).ToArray()
            });
        }
    }
}
        /// <summary>
        /// Проверяет возможности железа и от этого скрывает или показывает нужные контролы.
        /// </summary>
        /// <returns>null - не все контролы заполнены, !null - всё в порядке, можно отправлять событие на поиск</returns>
        private ControlProcessorHardware CheckSelection()
        {
            var cph = new ControlProcessorHardware
            {
                ModuleType = _hardwareSupported,
            };

            var isPreviousFiledCheckPassedSuccessfully = true;

            // Проверяем Motherboard
            var c = HardwareManager.GetCapacity(cph, DeviceSubType.Motherboard);

            // Если материнская плата не используется
            if (c.DeviceSubtypeIsNotSuitableForCurrentHardware)
            {
                cph.MotherBoardId = string.Empty;
            }
            else
            {
                if (string.IsNullOrEmpty((string)_motherboardList.SelectedItem))
                {
                    isPreviousFiledCheckPassedSuccessfully = false;
                }
                else
                {
                    cph.MotherBoardId = (string)_motherboardList.SelectedItem;
                }
            }

            // Проверяем ExtensionBoard/ModuleList
            // Если предыдущий шаг провален - скрываем и считаем этот шаг также проваленым
            if (!isPreviousFiledCheckPassedSuccessfully)
            {
                ShowModuleList(false);
            }
            else
            {
                c = HardwareManager.GetCapacity(cph, DeviceSubType.ExtensionBoard);
                // Если материнская плата не используется
                if (c.DeviceSubtypeIsNotSuitableForCurrentHardware)
                {
                    ShowModuleList(false);
                    cph.ModuleId = 0;
                }
                else
                {
                    if (string.IsNullOrEmpty((string)_moduleList.SelectedItem))
                    {
                        ShowModuleList(true);
                        isPreviousFiledCheckPassedSuccessfully = false;
                    }

                    else
                    {
                        ShowModuleList(true);
                        cph.ModuleId = uint.Parse((string)_moduleList.SelectedItem);
                    }
                }
            }

            // Проверяем Block
            // Если предыдущий шаг провален - скрываем и считаем этот шаг также проваленым
            if (!isPreviousFiledCheckPassedSuccessfully)
            {
                ShowBlock(false);
            }
            else
            {
                c = HardwareManager.GetCapacity(cph, DeviceSubType.Block);
                // Если материнская плата не используется
                if (c.DeviceSubtypeIsNotSuitableForCurrentHardware)
                {
                    ShowBlock(false);
                    cph.BlockId = 0;
                }
                else
                {
                    if (string.IsNullOrEmpty((string)_blockId.SelectedItem))
                    {
                        ShowBlock(true);
                        isPreviousFiledCheckPassedSuccessfully = false;
                    }
                    else
                    {
                        ShowBlock(true);
                        cph.BlockId = uint.Parse((string)_blockId.SelectedItem);
                    }
                }
            }

            // Проверяем Control
            // Если предыдущий шаг провален - скрываем и считаем этот шаг также проваленым
            if (!isPreviousFiledCheckPassedSuccessfully)
            {
                ShowControl(false);
            }
            else
            {
                c = HardwareManager.GetCapacity(cph, DeviceSubType.Control);
                // Если материнская плата не используется
                if (c.DeviceSubtypeIsNotSuitableForCurrentHardware)
                {
                    cph.ControlId = 0;
                    ShowControl(false);
                }
                else
                {
                    if (string.IsNullOrEmpty((string)_controlId.SelectedItem))
                    {
                        isPreviousFiledCheckPassedSuccessfully = false;
                        ShowControl(true);
                    }

                    else
                    {
                        ShowControl(true);
                        cph.ControlId = uint.Parse((string)_controlId.SelectedItem);
                    }
                }
            }
            if (isPreviousFiledCheckPassedSuccessfully)
            {
                return(cph);
            }
            return(null);
        }