private async void UARTconnect() { try { var dis = await DeviceInformation.FindAllAsync( SerialDevice.GetDeviceSelector("UART0")); serialPort = await SerialDevice.FromIdAsync(dis[0].Id); if (serialPort == null) { throw new IOException(); } // Configure serial settings serialPort.WriteTimeout = TimeSpan.FromMilliseconds(13); serialPort.ReadTimeout = TimeSpan.FromMilliseconds(13); serialPort.BaudRate = 76800; serialPort.Parity = SerialParity.None; serialPort.StopBits = SerialStopBitCount.One; serialPort.DataBits = 8; serialPort.Handshake = SerialHandshake.None; // Create the DataWriter object and attach to OutputStream dataWriteObject = new DataWriter(serialPort.OutputStream); BusReady?.Invoke(); } catch (Exception ex) { Debug.WriteLine(ex); } }
public void InitializeDeviceWatchers() { var deviceSelector = SerialDevice.GetDeviceSelector(); var deviceWatcher = DeviceInformation.CreateWatcher(deviceSelector); AddDeviceWatcher(deviceWatcher, deviceSelector); }
public async void InitializeReader(Action <string> callback) { //Selector nadje device var selector = SerialDevice.GetDeviceSelector(port); //info na onsovu selektora var devices = await DeviceInformation.FindAllAsync(selector); //nadje se device info if (devices.Any()) { var deviceInfo = devices.First(); //najosjetljivija metoda, vraca null ako nesto nije uredu //to moze biti da nije capability naveden u manifestu, da device ne prepoznaje ili da je device zauzet od druge aplikacije //da je user blokirao ili sistem //moze biti null iako je nadjen device information serialDevice = await SerialDevice.FromIdAsync(deviceInfo.Id); //Set up serial device according to device specifications: //This might differ from device to device //specifikacije com porta, nacin na koj iuredjaj salje bite serialDevice.BaudRate = 9600; serialDevice.DataBits = 8; serialDevice.Parity = SerialParity.None; serialDevice.StopBits = SerialStopBitCount.One; serialDevice.ReadTimeout = TimeSpan.FromMilliseconds(1000); //ima sekundu izmedju dva citanja, ako se kartica brzo provuce dvaput biti ce 28 bita ReadCancellationTokenSource = new CancellationTokenSource(); //pokretanje uredjaja Listen(callback); } }
public WinIotPackageManager() { try { _sequenceDataList = new List <byte[]>(); _packetRecived = new AutoResetEvent(false); var deviceSelector = SerialDevice.GetDeviceSelector(); var devices = Task.Run(async() => await DeviceInformation.FindAllAsync(deviceSelector)).Result; if (devices.Count <= 0) { throw new Exception("Device not found -->[WinIotPakcgeManager_Constructor]"); } var entry = devices.Single(x => x.Name.Equals("CP2102 USB to UART Bridge Controller")); //CP2102 USB to UART Bridge Controller _serialDevice = SerialDevice.FromIdAsync(entry.Id).AsTask().Result; // Configure serial settings _serialDevice.WriteTimeout = TimeSpan.FromMilliseconds(250); _serialDevice.ReadTimeout = TimeSpan.FromMilliseconds(250); _serialDevice.BaudRate = 57600; _serialDevice.Parity = SerialParity.None; _serialDevice.StopBits = SerialStopBitCount.One; _serialDevice.DataBits = 8; // Create cancellation token object to close I/O operations when closing the device _readCancellationTokenSource = new CancellationTokenSource(); ListenToSerialPort(); } catch (Exception ex) { throw new Exception($"{ex.Message} -->[WinIotPakcgeManager_Constructor]", ex.InnerException); } }
/// <summary> /// 列出可用串口 /// </summary> private async void ListAvailablePorts() { try { string aqs = SerialDevice.GetDeviceSelector(); var dis = await DeviceInformation.FindAllAsync(aqs); listOfDevices.Clear(); DeviceListCbx.Items.Clear(); DeviceListCbx.SelectedIndex = -1; for (int i = 0; i < dis.Count; i++) { listOfDevices.Add(dis[i]); DeviceListCbx.Items.Add(dis[i].Name); if (dis[i].Name.Contains(lastPortName)) { DeviceListCbx.SelectedIndex = i; } } ReadCancellationTokenSource = new CancellationTokenSource(); } catch { MainPage.Notify("无可用串口\n"); } }
/// <summary>Finds the device and connects to it</summary> private static async Task <SerialDevice> GetDevice() { if (Device == null) { //It should be the only device that contains "USB" var devices = await DeviceInformation.FindAllAsync(SerialDevice.GetDeviceSelector()); var deviceId = devices.FirstOrDefault(x => x.Id.Contains("USB"))?.Id; if (deviceId == null) { Connected = false; return(null); } Device = await SerialDevice.FromIdAsync(deviceId); if (Device == null) { Connected = false; return(null); } Device.BaudRate = 115200; Device.StopBits = SerialStopBitCount.One; Device.Parity = SerialParity.None; Device.DataBits = 8; Device.Handshake = SerialHandshake.None; Device.ReadTimeout = TimeSpan.FromMilliseconds(Timeout); Device.WriteTimeout = TimeSpan.FromMilliseconds(Timeout); } Connected = true; return(Device); }
public async Task InitSerial() { var devices = await DeviceInformation.FindAllAsync(SerialDevice.GetDeviceSelector()); foreach (var device in devices) { SerialDevice serialDevice; try { serialDevice = await SerialDevice.FromIdAsync(device.Id); serialDevice.BaudRate = 9600; serialDevice.DataBits = 8; serialDevice.StopBits = SerialStopBitCount.One; serialDevice.Parity = SerialParity.None; serialDevice.Handshake = SerialHandshake.None; serialDevice.ReadTimeout = TimeSpan.FromMilliseconds(1000); serialDevice.WriteTimeout = TimeSpan.FromMilliseconds(1000); serialDevices.Add(serialDevice); dataWriters.Add(new DataWriter(serialDevice.OutputStream)); } catch (Exception ex) { Debug.WriteLine("Serial初期化中のエラー: " + ex.Message); continue; } } }
private async System.Threading.Tasks.Task <bool> TryOpenComportAsync() { Boolean openSuccess = false; var aqsFilter = SerialDevice.GetDeviceSelector(ViewModels.SharedData.SharedDataInstance.CurrentTNCDevice.CommPort.Comport); var devices = await DeviceInformation.FindAllAsync(aqsFilter); if (devices.Count > 0) { DeviceInformation deviceInfo = devices[0]; if (deviceInfo != null) { // Create an EventHandlerForDevice to watch for the device we are connecting to EventHandlerForDevice.CreateNewEventHandlerForDevice(); // Get notified when the device was successfully connected to or about to be closed EventHandlerForDevice.Current.OnDeviceConnected = this.OnDeviceConnected; EventHandlerForDevice.Current.OnDeviceClose = this.OnDeviceClosing; openSuccess = await EventHandlerForDevice.Current.OpenDeviceAsync(deviceInfo, aqsFilter); //SerialDevice device = await SerialDevice.FromIdAsync(deviceInfo.Id); //if (openSuccess) //{ // //device.Dispose(); // EventHandlerForDevice.Current.CloseDevice(); // openSuccess = true; //} } } return(openSuccess); }
public static async Task <Pn532CommunicationHsu> CreateSerialPort(string deviceName) { string deviceQuery = SerialDevice.GetDeviceSelector(deviceName); var discovered = await DeviceInformation.FindAllAsync(deviceQuery); var readerInfo = discovered.FirstOrDefault(/*x => x.Name.IndexOf(deviceName, StringComparison.OrdinalIgnoreCase) > -1*/); //var readerInfo = discovered.FirstOrDefault(); SerialDevice reader = null; if (readerInfo != null) { reader = await SerialDevice.FromIdAsync(readerInfo.Id); if (reader != null) { reader.WriteTimeout = TimeSpan.FromMilliseconds(1000); reader.ReadTimeout = TimeSpan.FromMilliseconds(1000); reader.BaudRate = 115200; reader.Parity = SerialParity.None; reader.StopBits = SerialStopBitCount.One; reader.DataBits = 8; } else { throw new Exception("Reader Not configured"); } } else { throw new Exception("Reader Not configured"); } return(new Pn532CommunicationHsu(reader)); }
public async void SerialStuff() { var dis = await DeviceInformation.FindAllAsync(SerialDevice.GetDeviceSelector()); Debug.WriteLine(dis.First().Name); Debug.WriteLine(dis.First().Id.ToString()); serialPort = await SerialDevice.FromIdAsync(dis.First().Id); if (serialPort != null) { serialPort.WriteTimeout = TimeSpan.FromMilliseconds(1000); serialPort.ReadTimeout = TimeSpan.FromMilliseconds(1000); serialPort.BaudRate = 9600; serialPort.Parity = SerialParity.None; serialPort.StopBits = SerialStopBitCount.One; serialPort.DataBits = 8; serialPort.Handshake = SerialHandshake.None; ReadCancellationTokenSource = new CancellationTokenSource(); Listen(); } else { Debug.WriteLine("Serial system not connected."); } }
/// <summary> /// 初始化DeviceWatcher /// </summary> private void InitializeDeviceWatcher() { // var deviceSelector = SerialDevice.GetDeviceSelector(); aqs = SerialDevice.GetDeviceSelector(); deviceWatcher = DeviceInformation.CreateWatcher(aqs); AddDeviceWatcher(deviceWatcher, aqs); }
public static async Task <bool> IsSerialPortPresentedAsync(string serialPortName) { var aqsFilter = SerialDevice.GetDeviceSelector(serialPortName); var deviceInformation = (await DeviceInformation.FindAllAsync(aqsFilter)).FirstOrDefault(); return(deviceInformation != null); }
private async Task ListAvailablePorts(Device deviceConnect) { try { string aqs = SerialDevice.GetDeviceSelector(); var devicesList = await DeviceInformation.FindAllAsync(aqs); if (devicesList != null && devicesList.Count > 0) { foreach (var device in devicesList) { if (device.Id.Contains(deviceConnect.Identifier)) { await Connect(device); deviceConnect.Estado = true; } } } } catch (Exception ex) { } }
private async Task <SerialDevice> GetSerialPort(string portName) { // Get the device selector for serial ports var deviceSelector = SerialDevice.GetDeviceSelector(); // Find all the serial ports var devices = await DeviceInformation.FindAllAsync(deviceSelector); var deviceList = devices.ToList(); // If the are any devices found, attempt to find the one required if (devices.Count > 0) { // Loop through all discovered serial devices foreach (var device in devices) { // If the device name matches return the serial device if (device.Name.StartsWith(portName, StringComparison.CurrentCultureIgnoreCase)) //if (string.Compare(device.Name, portName, true) == 0) { return(await SerialDevice.FromIdAsync(device.Id)); } } } // Serial Device was not found so return null return(null); }
private async void RefreshSerialDevices() { //Prevent null exceptions SerialList.SelectionChanged -= SerialList_OnSelectionChanged; string _serialSelector = SerialDevice.GetDeviceSelector(); //SerialInfoTextBlock.Text = SerialDevice.GetDeviceSelectorFromUsbVidPid(2341, 8041); tempInfo = await DeviceInformation.FindAllAsync(_serialSelector); SerialList.DataContext = tempInfo; SerialList.Items?.Clear(); SerialList.SelectionChanged += SerialList_OnSelectionChanged; foreach (var item in tempInfo) { SerialList.Items.Add(item.Name); //Fast track selection if (item.Name.Contains("Arduino") || item.Name.Contains("BTG")) { SerialList.SelectedItem = item.Name; } } if (tempInfo.Count == 0) { SerialList.PlaceholderText = "No serial devices available"; } }
private async void ConnCom_Button_Click(object _, RoutedEventArgs e) { var devices = await DeviceInformation.FindAllAsync(SerialDevice.GetDeviceSelector()); device_writer = await SerialDevice.FromIdAsync(devices[0].Id); device_writer.BaudRate = 57600; if (device_writer != null) { FindDevice_List.Text += $"Connect to {device_writer.PortName}: {device_writer.BaudRate} \r\n"; } else { FindDevice_List.Text += $"Connect to {device_writer.PortName} Failed \r\n"; } /* * device_reader = await SerialDevice.FromIdAsync(devices[1].Id); * if (device_reader != null) * { * FindDevice_List.Text += $"Connect to {device_reader.PortName}: {device_reader.BaudRate} \r\n"; * } * else * { * FindDevice_List.Text += $"Connect to {device_reader.PortName} Failed \r\n"; * } */ }
public async Task <bool> InitializeConnection() { var result = false; var filter = SerialDevice.GetDeviceSelector("UART0"); var devices = await DeviceInformation.FindAllAsync(filter); if (devices.Any()) { var deviceId = devices.First().Id; var serialDevice = await SerialDevice.FromIdAsync(deviceId); if (serialDevice != null) { serialDevice.WriteTimeout = TimeSpan.FromMilliseconds(1000); serialDevice.ReadTimeout = TimeSpan.FromMilliseconds(1000); serialDevice.BaudRate = 9600; serialDevice.StopBits = SerialStopBitCount.One; serialDevice.DataBits = 8; serialDevice.Parity = SerialParity.None; serialDevice.Handshake = SerialHandshake.None; _reader = new DataReader(serialDevice.InputStream) { InputStreamOptions = InputStreamOptions.Partial }; _writer = new DataWriter(serialDevice.OutputStream); result = true; } } return(result); }
public override async Task <Connections> GetConnections() { var identifyingSubstring = "VID_2341"; try { var devices = SerialDevice.GetDeviceSelector(); var peers = await DeviceInformation.FindAllAsync(devices); var connections = new Connections(); foreach (var peer in peers) { if (peer.Name.Contains(identifyingSubstring) || peer.Id.Contains(identifyingSubstring)) { connections.Add(new Connection(peer.Name, peer)); } } return(connections); } catch (Exception) { return(null); } }
public async Task Initialize() { var serialSelector = SerialDevice.GetDeviceSelector(); var serialDevices = (await DeviceInformation.FindAllAsync(serialSelector)).ToList(); var hostNames = NetworkInformation.GetHostNames().Select(hostName => hostName.DisplayName.ToUpper()).ToList(); // So we can ignore inbuilt ports foreach (var deviceInfo in serialDevices) { if (hostNames.FirstOrDefault(hostName => hostName.StartsWith(deviceInfo.Name.ToUpper())) == null) { try { var serialDevice = await SerialDevice.FromIdAsync(deviceInfo.Id); if (serialDevice != null) { _SerialDevices.Add(deviceInfo.Id, serialDevice); } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.ToString()); } } } }
private async System.Threading.Tasks.Task InitGPIOAsync() { aqs = SerialDevice.GetDeviceSelector(); dis = await DeviceInformation.FindAllAsync(aqs); using (SerialDevice serialPort = await SerialDevice.FromIdAsync(dis[0].Id)) { /* Configure serial settings */ serialPort.WriteTimeout = TimeSpan.FromMilliseconds(1000); serialPort.ReadTimeout = TimeSpan.FromMilliseconds(1000); serialPort.BaudRate = 9600; /* mini UART: only standard baudrates */ serialPort.Parity = SerialParity.None; /* mini UART: no parities */ serialPort.StopBits = SerialStopBitCount.One; /* mini UART: 1 stop bit */ serialPort.DataBits = 8; /* Write a string out over serial */ // turn on autocalibration byte[] send79Buffer = { 0XFF, 0x01, 0x79, 0xA0, 0x00, 0x00, 0x00, 0x00, 0x79 }; DataWriter dataWriter = new DataWriter(); //dataWriter.WriteString(txBuffer); dataWriter.WriteBytes(send79Buffer); uint bytesWritten = await serialPort.OutputStream.WriteAsync(dataWriter.DetachBuffer()); Debug.WriteLine("Autokalibrace vypnuta."); } }
public async Task <bool> FindDevicebyName(string deviceName) { try { string aqs = SerialDevice.GetDeviceSelector(); var dis = await DeviceInformation.FindAllAsync(aqs); //var a = dis.ToList(); //if (count == 1) //{ // Device = dis[2]; // return true; //} foreach (var device in dis) { if (device.Name.Contains(deviceName)) { Device = device; return(true); } } return(false); } catch (Exception ex) { Debug.WriteLine(ex); return(false); } }
/// <summary> /// Initialisation du port série /// 9600, pas de parité, un bit de stop, 8bits /// début de réception /// </summary> /// <param name="BaudRate"></param> /// <returns></returns> public async Task Initialise(uint BaudRate) //NOTE - THIS IS AN ASYNC METHOD! { try { // Recherche du port série string aqs = SerialDevice.GetDeviceSelector("UART0"); var dis = await DeviceInformation.FindAllAsync(aqs); UartPort = await SerialDevice.FromIdAsync(dis[0].Id); //Configuration du port série //mS before a time-out occurs when a write operation does not finish (default=InfiniteTimeout). UartPort.WriteTimeout = TimeSpan.FromMilliseconds(10000); //mS before a time-out occurs when a read operation does not finish (default=InfiniteTimeout). UartPort.ReadTimeout = TimeSpan.FromMilliseconds(10000); UartPort.BaudRate = 9600; UartPort.Parity = SerialParity.None; UartPort.StopBits = SerialStopBitCount.One; UartPort.DataBits = 8; DataReaderObject = new DataReader(UartPort.InputStream); DataReaderObject.InputStreamOptions = InputStreamOptions.Partial; DataWriterObject = new DataWriter(UartPort.OutputStream); // Début de la réception StartReceive(); } catch (Exception ex) { throw new Exception("Uart Initialise Error", ex); } }
public static async void OpenSerialAsync(string colorValue) { var selector = SerialDevice.GetDeviceSelector("COM5"); var devices = await DeviceInformation.FindAllAsync(selector); if (devices.Any()) { var deviceInfo = devices.First().Id; SerialDevice serialDevice = await SerialDevice.FromIdAsync(deviceInfo); if (serialDevice != null) { serialDevice.BaudRate = 9600; serialDevice.DataBits = 8; serialDevice.StopBits = SerialStopBitCount.One; serialDevice.Parity = SerialParity.None; serialDevice.Handshake = SerialHandshake.None; DataWriter dataWriter = new DataWriter(serialDevice.OutputStream); dataWriter.WriteString(colorValue + "\n"); await dataWriter.StoreAsync(); dataWriter.DetachStream(); serialDevice.Dispose(); } } else { MessageDialog popup = new MessageDialog("Sorry, no device found."); await popup.ShowAsync(); } }
private async void ListAvailablePorts() { try { string aqs = SerialDevice.GetDeviceSelector(); var dis = await DeviceInformation.FindAllAsync(aqs); listOfDevices.Add(dis[0]); //statusBox.Text = "Select a device and connect"; //for (int i = 0; i < dis.Count; i++) //{ // listOfDevices.Add(dis[i]); //} // DeviceListSource.Source = listOfDevices; comPortInput.IsEnabled = true; //ConnectDevices.SelectedIndex = -1; } catch (Exception ex) { statusBox.Text = ex.Message; } }
/// <summary> /// 异步加载串口列表 /// </summary> public async void SerialList() { string selectors = SerialDevice.GetDeviceSelector(); DeviceInformationCollection decices = await DeviceInformation.FindAllAsync(selectors); if (decices.Any()) { for (int i = 0; i < decices.Count(); i++) { if (AllPortName.Contains(decices[i].Name)) { continue; } else { AllPortName.Add(decices[i].Name); } } //PortName = PortName.Distinct().ToList(); } else { AllPortName.Clear(); } }
// blew up gertbot board, so commenting out //private void _gertbot_GertbotInterrupt(object sender, GertbotEventArgs e) //{ // if (StatusUpdate != null) // { // StatusUpdate(this, new HttpServerStatusArgs(1, "hardware update", 0)); // } //} public async void InitialiseHardware() { // PI Face intialisation await _spiDriver.InitHardware(); //await _gertbot.InitHardware(); // bluetooth serial string aqs = SerialDevice.GetDeviceSelector(); DeviceInformationCollection devices_info = await DeviceInformation.FindAllAsync(aqs); // making an assumption here that the serial we want is #1 // this will only work with Windows IOT version Insider Preview Build Number 10556.0 _serialDevice = await SerialDevice.FromIdAsync(devices_info[0].Id); if (_serialDevice != null) { // Configure serial settings _serialDevice.WriteTimeout = TimeSpan.FromMilliseconds(1000); _serialDevice.ReadTimeout = TimeSpan.FromMilliseconds(1000); _serialDevice.BaudRate = 115200; _serialDevice.Parity = SerialParity.None; _serialDevice.StopBits = SerialStopBitCount.One; _serialDevice.DataBits = 8; _serialDevice.Handshake = SerialHandshake.None; _dw = new DataWriter(_serialDevice.OutputStream); _dr = new DataReader(_serialDevice.InputStream); _dr.InputStreamOptions = InputStreamOptions.None; // start the read thread StartReadThread(); } // turn the relay on and power up the motordriver SetBitState(MOTOR_POWER, 0); }
//Copied from the below address to connect db 410c using uart1 //https://docs.microsoft.com/en-us/windows/iot-core/learn-about-hardware/pinmappings/pinmappingsdb public async void Serial() { string aqs = SerialDevice.GetDeviceSelector("UART1"); /* Find the selector string for the serial device */ var dis = await DeviceInformation.FindAllAsync(aqs); /* Find the serial device with our selector string */ SerialDevice SerialPort = await SerialDevice.FromIdAsync(dis[0].Id); /* Create an serial device with our selected device */ /* Configure serial settings */ SerialPort.WriteTimeout = TimeSpan.FromMilliseconds(1000); SerialPort.ReadTimeout = TimeSpan.FromMilliseconds(1000); SerialPort.BaudRate = 9600; SerialPort.Parity = SerialParity.None; SerialPort.StopBits = SerialStopBitCount.One; SerialPort.DataBits = 8; /* Write a string out over serial */ string txBuffer = "Hello Serial"; DataWriter dataWriter = new DataWriter(); dataWriter.WriteString(txBuffer); uint bytesWritten = await SerialPort.OutputStream.WriteAsync(dataWriter.DetachBuffer()); /* Read data in from the serial port */ const uint maxReadLength = 1024; DataReader dataReader = new DataReader(SerialPort.InputStream); uint bytesToRead = await dataReader.LoadAsync(maxReadLength); string rxBuffer = dataReader.ReadString(bytesToRead); }
internal async Task <SerialDevice> GetSerialDeviceAsync(string identifier, int baudRate, TimeSpan readTimeout, TimeSpan writeTimeout) { var deviceInformationCollection = await DeviceInformation.FindAllAsync(SerialDevice.GetDeviceSelector()); var selectedPort = deviceInformationCollection.FirstOrDefault(d => d.Id.Contains(identifier) || d.Name.Equals(identifier)); if (selectedPort == null) { return(null); } var serialDevice = await SerialDevice.FromIdAsync(selectedPort.Id); if (serialDevice == null) { return(null); } serialDevice.ReadTimeout = readTimeout; serialDevice.WriteTimeout = writeTimeout; serialDevice.BaudRate = (uint)baudRate; serialDevice.Parity = SerialParity.None; serialDevice.StopBits = SerialStopBitCount.One; serialDevice.DataBits = 8; serialDevice.Handshake = SerialHandshake.None; Debug.WriteLine($"Found - {identifier}"); return(serialDevice); }
/// <summary> /// Initialize device watchers to watch for the Serial Devices. /// /// GetDeviceSelector return an AQS string that can be passed directly into DeviceWatcher.createWatcher() or DeviceInformation.createFromIdAsync(). /// /// In this sample, a DeviceWatcher will be used to watch for devices because we can detect surprise device removals. /// </summary> private void InitializeDeviceWatchers() { // Target all Serial Devices present on the system var deviceSelector = SerialDevice.GetDeviceSelector(); // Other variations of GetDeviceSelector() usage are commented for reference // // Target a specific USB Serial Device using its VID and PID (here Arduino VID/PID is used) // var deviceSelector = SerialDevice.GetDeviceSelectorFromUsbVidPid(0x2341, 0x0043); // // Target a specific Serial Device by its COM PORT Name - "COM3" // var deviceSelector = SerialDevice.GetDeviceSelector("COM3"); // // Target a specific UART based Serial Device by its COM PORT Name (usually defined in ACPI) - "UART1" // var deviceSelector = SerialDevice.GetDeviceSelector("UART1"); // // Create a device watcher to look for instances of the Serial Device that match the device selector // used earlier. var deviceWatcher = DeviceInformation.CreateWatcher(deviceSelector); // Allow the EventHandlerForDevice to handle device watcher events that relates or effects our device (i.e. device removal, addition, app suspension/resume) AddDeviceWatcher(deviceWatcher, deviceSelector); }
public static async Task InitTrain() { myParamRail = await LoadParamRail(); MySecurityKey = myParamRail.SecurityKey; securityKey = paramSecurityKey + ParamEqual + MySecurityKey; //// then Lego Infrared myLego = new LegoInfrared(); // then Signal mySignal = new Signal(myParamRail.NumberOfSignals); mySwitch = new Switch(myParamRail.NumberOfSwitchs, myParamRail.MinDuration, myParamRail.MaxDuration, myParamRail.MinAngle, myParamRail.MaxAngle, myParamRail.ServoAngle); if (myParamRail.Serial) { mySerial = new Serial(); string aqs = SerialDevice.GetDeviceSelector(); var dis = await DeviceInformation.FindAllAsync(aqs); SerialDevice serialPort = null; for (int i = 0; i < dis.Count; i++) { Debug.WriteLine(string.Format("Serial device found: {0}", dis[i].Id)); if (dis[i].Id.IndexOf("BCM2836") != -1) { serialPort = await SerialDevice.FromIdAsync(dis[i].Id); } } mySerial.SelectAndInitSerial(serialPort).Wait(); isSerialRunning = true; ThreadReading = ThreadPool.RunAsync(ContinuousUpdate, WorkItemPriority.High).AsTask(); } }