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();
}
}
