Exemple #1
0
 /// <summary> Sets the address. </summary>
 private void SetAddress()
 {
     if (IsConnected && CanReaddress)
     {
         BackgroundThreadManager.RunBackgroundFunction((s, e) => _ellDevice.ReaddressDevice(OldAddress, NewAddress),
                                                       e =>
         {
             ELLDeviceBaseViewModel vm = _deviceViewModels[OldAddress];
             vm.UpdateAddress();
             _deviceViewModels.Remove(OldAddress);
             _deviceViewModels[NewAddress] = vm;
             _sequenceViewModel.ReaddressSequence(OldAddress, NewAddress);
             UpdateUI();
         });
     }
 }
Exemple #2
0
        private void ConnectEx()
        {
            if (ELLDevicePort.IsConnected)
            {
                DisconnectEx();
            }
            else
            {
                bool connected;
                try
                {
                    connected = ELLDevicePort.Connect(SelectedPort);
                }
                catch (Exception ex)
                {
                    OutputUpdate(ex.Message, OutputItem.OutputItemType.Error);
                    connected = false;
                }
                IsConnected = ELLDevicePort.IsConnected;
                if (!connected)
                {
                    return;
                }
                if (MinSearchLimit > MaxSearchLimit)
                {
                    MaxSearchLimit = MinSearchLimit;
                }
                ELLDevicePort.DataSent     = DataSent;
                ELLDevicePort.DataReceived = DataReceived;
                _deviceViewModels.Clear();
                _ellDevice.ClearDevices();
                List <string> devices = _ellDevice.ScanAddresses(MinSearchLimit, MaxSearchLimit);
                if (devices.Count > 0)
                {
                    foreach (string deviceID in devices)
                    {
                        _ellDevice.Configure(deviceID);
                        _ellDevice.Connect();
                        char address = deviceID[0];
                        ELLDeviceBaseViewModel vm         = null;
                        DeviceID.DeviceTypes   deviceType = _ellDevice.AddressedDevice(address).DeviceInfo.DeviceType;
                        if (deviceType == DeviceID.DeviceTypes.Paddle)
                        {
                            ELLPaddlePolariser device = _ellDevice.AddressedDevice(address) as ELLPaddlePolariser;
                            vm = new ELLPaddlePolariserViewModel(this, device);
                        }
                        else
                        {
                            ELLDevice device = _ellDevice.AddressedDevice(address) as ELLDevice;
                            switch (deviceType)
                            {
                            case DeviceID.DeviceTypes.Actuator:
                                vm = new ELLActuatorViewModel(this, device);
                                break;

                            case DeviceID.DeviceTypes.Shutter:
                                vm = new ELLShutterViewModel(this, device, 2);
                                break;

                            case DeviceID.DeviceTypes.Shutter4:
                                vm = new ELLShutterViewModel(this, device, 4);
                                break;

                            case DeviceID.DeviceTypes.Rotator:
                                vm = new ELLStageViewModel(this, device, 2, true, true, false);
                                break;

                            case DeviceID.DeviceTypes.OpticsRotator:
                                vm = new ELLStageViewModel(this, device, 2, true, true, true);
                                break;

                            case DeviceID.DeviceTypes.RotaryStage18:
                                vm = new ELLStageViewModel(this, device, 2, true, false, true);
                                break;

                            case DeviceID.DeviceTypes.RotaryStage:
                                vm = new ELLStageViewModel(this, device, 2, true, false, false);
                                break;

                            case DeviceID.DeviceTypes.LinearStage:
                            case DeviceID.DeviceTypes.LinearStage2:
                                vm = new ELLStageViewModel(this, device, 2, false, false, false);
                                break;

                            case DeviceID.DeviceTypes.LinearStage17:
                            case DeviceID.DeviceTypes.LinearStage20:
                                vm = new ELLStageViewModel(this, device, 2, false, false, true);
                                break;
                            }
                        }
                        if (vm != null)
                        {
                            _deviceViewModels[address] = vm;
                            foreach (ELLMotorViewModel motor in vm.Motors)
                            {
                                motor.GetMotorInfoDirect();
                            }
                            vm.InitializeViewModel();
                        }
                        _sequenceViewModel.DeviceTypes = _deviceViewModels.ToDictionary(item => item.Key, item => item.Value.Device.DeviceInfo.DeviceType);
                    }
                }
                else
                {
                    DisconnectEx();
                }
            }
        }