public async void ConnectAndListen()
{
// attempt to connect to the first available serial device - will have to do for now
try
{
string aqs = SerialDevice.GetDeviceSelector();
var dis = await DeviceInformation.FindAllAsync(aqs);
if (dis.Count < 1)
{
// Status = "No serial devices found";
}
var entry = dis[0];
serialPort = await SerialDevice.FromIdAsync(entry.Id);
// Configure serial settings
serialPort.WriteTimeout = TimeSpan.FromMilliseconds(1000);
serialPort.ReadTimeout = TimeSpan.FromMilliseconds(1000);
serialPort.BaudRate = 57600;
serialPort.Parity = SerialParity.None;
serialPort.StopBits = SerialStopBitCount.One;
serialPort.DataBits = 8;
serialPort.Handshake = SerialHandshake.None;
// Create cancellation token object to close I/O operations when closing the device
ReadCancellationTokenSource = new CancellationTokenSource();
Listen();
}
catch (Exception ex)
{
// Status = ex.Message;
}
}
public async Task ConnectToDevice(DeviceInformation device)
{
this.State = ConnectionState.Connecting;
try
{
serialConnection = await SerialDevice.FromIdAsync(device.Id);
if (serialConnection != null)
{
serialConnection.BaudRate = 115200;
serialConnection.DataBits = 8;
serialConnection.Parity = SerialParity.None;
writer = new DataWriter(serialConnection.OutputStream);
reader = new DataReader(serialConnection.InputStream);
Task listen = ListenForMessagesAsync();
this.State = ConnectionState.Connected;
}
else {
Debugger.ReportToDebugger(this, "Unable to create service.\nMake sure that the 'serialcommunication' capability is declared with a function of type 'name:serialPort' in Package.appxmanifest.", Debugger.Device.Pc);
this.State = ConnectionState.Failure;
}
}
catch (TaskCanceledException ex)
{
this.State = ConnectionState.Failure;
Debugger.ReportToDebugger(this, ex.Message, Debugger.Device.Pc);
}
catch (Exception ex)
{
this.State = ConnectionState.Failure;
Debugger.ReportToDebugger(this, ex.Message, Debugger.Device.Pc);
}
}
static void Main(string[] args)
{
SerialDevice sd;
STPv3Reader reader;
STPv3Request request;
STPv3Response response;
Tag tag = new Tag();
tag.Type = TagType.AUTO_DETECT;
string port;
byte[] resp;
float temp;
if (args.Length < 1)
port = "COM1";
else
port = args[0];
sd = new SerialDevice();
reader = new STPv3Reader(sd);
try
{
sd.Address = port;
sd.BaudRate = 38400;
sd.Open();
// read product code, reader name, hw version, fw version, and reader ID
Console.Out.WriteLine(String.Format("Product Code: {0}", reader.ProductCode));
Console.Out.WriteLine(String.Format("Reader Name: {0}", reader.ReaderName));
Console.Out.WriteLine(String.Format("Hardware Version: {0}", reader.HardwareVersion));
Console.Out.WriteLine(String.Format("Firmware Version: {0}", reader.FirmwareVersion));
Console.Out.WriteLine(String.Format("Reader ID: {0}",
String.Join("", Array.ConvertAll<byte, string>(reader.ReaderID, delegate(byte value){ return String.Format("{0:X2}", value); }))));
//scan for tags
request = new STPv3Request();
request.Tag = tag;
request.Command = STPv3Commands.SELECT_TAG;
request.Inventory = true;
request.Issue(sd);
while (((response = request.GetResponse()) != null) && (response.Success))
{
if (response.ResponseCode == STPv3ResponseCode.SELECT_TAG_PASS)
{
Console.Out.WriteLine(String.Format("Tag found: {0} -> {1}",
Enum.GetName(typeof(SkyeTek.Tags.TagType),
response.TagType), String.Join("",
Array.ConvertAll<byte, string>(response.TID,
delegate(byte value) { return String.Format("{0:X2}", value); }))));
}
}
}
catch (Exception ex)
{
Console.Out.WriteLine(ex.ToString());
}
Console.In.ReadLine();
}
private async void btnConnect_Click(object sender, RoutedEventArgs e)
{
string deviceQuery = SerialDevice.GetDeviceSelector();
//using Windows.Devices.Enumeration
var deviceInfo = await DeviceInformation.FindAllAsync(deviceQuery);
if (deviceInfo != null && deviceInfo.Count > 0)
{
//your board name may differ, introspect the return value of deviceInfo to
//determine the serial hardware you have your modem attached to
var serialBoardName = "CP2102 USB to UART Bridge Controller";
var zbInfo = deviceInfo.Where(x => x.Name.Equals(serialBoardName)).First();
_zbCoordinator = await SerialDevice.FromIdAsync(zbInfo.Id);
// Configure serial settings
_zbCoordinator.WriteTimeout = TimeSpan.FromMilliseconds(1000);
_zbCoordinator.ReadTimeout = TimeSpan.FromMilliseconds(1000);
_zbCoordinator.BaudRate = 9600;
_zbCoordinator.Parity = SerialParity.None;
_zbCoordinator.StopBits = SerialStopBitCount.One;
_zbCoordinator.DataBits = 8;
btnConnect.IsEnabled = false;
btnSend.IsEnabled = true;
btnRead.IsEnabled = true;
}
else
{
this.txtHeader.Text = "Something went wrong :( -- Device not found";
}
}
public async Task Open()
{
if (Status == ModbusServerStatus.Initialled)
{
try
{
Status = ModbusServerStatus.Opening;
string aqs = SerialDevice.GetDeviceSelector(portName);
var dis = await DeviceInformation.FindAllAsync(aqs);
serialPort = await SerialDevice.FromIdAsync(dis[0].Id);
serialPort.WriteTimeout = TimeSpan.FromMilliseconds(WRITE_TIMEOUT);
serialPort.ReadTimeout = TimeSpan.FromMilliseconds(READ_TIMEOUT);
serialPort.BaudRate = BAUD_RATE;
serialPort.Parity = SERIAL_PARITY;
serialPort.StopBits = SERIAL_STOP_BIT_COUNT;
serialPort.DataBits = DATA_BITS;
serialPort.Handshake = SERIAL_HANDSHAKE;
readCancellationTokenSource = new CancellationTokenSource();
listen(1024);
Status = ModbusServerStatus.Opened;
}
catch (Exception ex)
{
throw ex;
}
}
}
public override async Task<bool> Connect(Connection newConnection)
{
var deviceInfo = newConnection.Source as DeviceInformation;
if (deviceInfo != null)
{
this.service = await SerialDevice.FromIdAsync(deviceInfo.Id);
if (this.service == null)
{
return false;
}
this.service.BaudRate = 115200;
this.service.StopBits = SerialStopBitCount.One;
this.service.Handshake = SerialHandshake.None;
this.service.DataBits = 8;
this.service.ReadTimeout = TimeSpan.FromSeconds(5);
this.service.WriteTimeout = TimeSpan.FromSeconds(5);
this.service.IsDataTerminalReadyEnabled = false;
return this.InstrumentSocket(this.service.InputStream, this.service.OutputStream);
}
return false;
}
async Task<bool> onewireReset(string deviceId)
{
try
{
if (serialPort != null)
serialPort.Dispose();
serialPort = await SerialDevice.FromIdAsync(deviceId);
// 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;
serialPort.Handshake = SerialHandshake.None;
dataWriteObject = new DataWriter(serialPort.OutputStream);
dataWriteObject.WriteByte(0xF0);
await dataWriteObject.StoreAsync();
dataReaderObject = new DataReader(serialPort.InputStream);
await dataReaderObject.LoadAsync(1);
byte resp = dataReaderObject.ReadByte();
if (resp == 0xFF)
{
System.Diagnostics.Debug.WriteLine("Nothing connected to UART");
return false;
}
else if (resp == 0xF0)
{
System.Diagnostics.Debug.WriteLine("No 1-wire devices are present");
return false;
}
else
{
System.Diagnostics.Debug.WriteLine("Response: " + resp);
serialPort.Dispose();
serialPort = await SerialDevice.FromIdAsync(deviceId);
// Configure serial settings
serialPort.WriteTimeout = TimeSpan.FromMilliseconds(1000);
serialPort.ReadTimeout = TimeSpan.FromMilliseconds(1000);
serialPort.BaudRate = 115200;
serialPort.Parity = SerialParity.None;
serialPort.StopBits = SerialStopBitCount.One;
serialPort.DataBits = 8;
serialPort.Handshake = SerialHandshake.None;
dataWriteObject = new DataWriter(serialPort.OutputStream);
dataReaderObject = new DataReader(serialPort.InputStream);
return true;
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Exception: " + ex.Message);
return false;
}
}
private async void InitializeSerial()
{
//Selector nadje device
var selector = SerialDevice.GetDeviceSelector("COM4"); //podesiti tacno koji je 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.WriteTimeout = TimeSpan.FromMilliseconds(300);
serialDevice.ReadTimeout = TimeSpan.FromMilliseconds(1000);
// Create cancellation token object to close I/O operations when closing the device
ReadCancellationTokenSource = new CancellationTokenSource();
Listen();
}
}
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 SerialConnection(SerialDevice serialDevice)
{
_serialDevice = serialDevice;
_input = _serialDevice.InputStream;
_output = _serialDevice.OutputStream;
_serialDevice.ErrorReceived += _serialDevice_ErrorReceived;
_buffer = new byte[1024];
}
public void Close()
{
if (serialPort != null)
{
serialPort.Dispose();
serialPort = null;
}
}
public void shutdown()
{
if (serialPort != null)
{
serialPort.Dispose();
serialPort = null;
}
}
public XBeeDevice(SerialDevice serialDevice)
{
_serialDevice = serialDevice;
_serialDevice.ErrorReceived += _serialDevice_ErrorReceived;
_input = _serialDevice.InputStream;
_output = _serialDevice.OutputStream;
Task.Run(() => ReadLoop(_cts.Token));
}
public void Close()
{
if (_device != null)
{
_inputStream = null;
_outputStream = null;
_device.Dispose();
_device = null;
}
}
internal async Task<bool> InitializeAsync()
{
_serialDevice = await StartupTask.SerialDeviceHelper.GetSerialDeviceAsync("AH03FK33", 57600, new TimeSpan(0, 0, 0, 1), new TimeSpan(0, 0, 0, 1));
if (_serialDevice == null)
return false;
_arduinoDataReader = new DataReader(_serialDevice.InputStream);
return true;
}
public static async Task <Brick> InitializeInstance(SerialDevice serialDevice)
{
instance = new Brick(serialDevice);
Task configSerialTask = instance.ConfigureSerialPort();
Task <GpioController> gpioControllerTask = GpioController.GetDefaultAsync().AsTask <GpioController>();
await Task.WhenAll(configSerialTask, gpioControllerTask);
instance.arduino1Led = new BrickLed(gpioControllerTask.Result, Arduino.Arduino1);
instance.arduino2Led = new BrickLed(gpioControllerTask.Result, Arduino.Arduino2);
return(instance);
}
/// <summary>
/// comPortInput_Click: Action to take when 'Connect' button is clicked
/// - Get the selected device index and use Id to create the SerialDevice object
/// - Configure default settings for the serial port
/// - Create the ReadCancellationTokenSource token
/// - Add text to rcvdText textbox to invoke rcvdText_TextChanged event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void comPortInput_Click(object sender, RoutedEventArgs e)
{
System.Collections.IList selection = null; //= ConnectDevices.SelectedItems;
if (selection != null)
{
if (selection.Count <= 0)
{
//status.Text = "Select a device and connect";
return;
}
}
DeviceInformation entry = (DeviceInformation)selection[0];
try
{
serialPort = await SerialDevice.FromIdAsync(entry.Id);
// Disable the 'Connect' button
//comPortInput.IsEnabled = false;
// 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;
// Display configured settings
//status.Text = "Serial port configured successfully!\n ----- Properties ----- \n";
//status.Text += "BaudRate: " + serialPort.BaudRate.ToString() + "\n";
//status.Text += "DataBits: " + serialPort.DataBits.ToString() + "\n";
//status.Text += "Handshake: " + serialPort.Handshake.ToString() + "\n";
//status.Text += "Parity: " + serialPort.Parity.ToString() + "\n";
//status.Text += "StopBits: " + serialPort.StopBits.ToString() + "\n";
// Set the RcvdText field to invoke the TextChanged callback
// The callback launches an async Read task to wait for data
// rcvdText.Text = "Waiting for data...";
// Create cancellation token object to close I/O operations when closing the device
ReadCancellationTokenSource = new CancellationTokenSource();
// Enable 'WRITE' button to allow sending data
//sendTextButton.IsEnabled = true;
}
catch (Exception ex)
{
//status.Text = ex.Message;
//comPortInput.IsEnabled = true;
//sendTextButton.IsEnabled = false;
}
}
public MainPage()
{
this.InitializeComponent();
myKey = "";
AutoResetEvent AutoEvent = new AutoResetEvent(true);
pilotTimer = new Timer(new TimerCallback(checkStatus), AutoEvent, 0, 1);
currentController = 0;
string selector = SerialDevice.GetDeviceSelector("COM3");
}
/// <summary>
/// CloseDevice:
/// - Disposes SerialDevice object
/// - Clears the enumerated device Id list
/// </summary>
private void CloseDevice()
{
if (serialPort != null)
{
serialPort.Dispose();
}
serialPort = null;
sendTextButton.IsEnabled = false;
ClearInputData();
listOfDevices.Clear();
}
internal SerialWatcher()
{
_devices = new List <string>();
string _deviceSelector = SerialDevice.GetDeviceSelector();
_deviceWatcher = DeviceInformation.CreateWatcher(_deviceSelector);
_deviceWatcher.Added += OnNewDeviceAdded;
_deviceWatcher.Removed += OnDeviceRemoved;
_deviceWatcher.Updated += OnDeviceCollectionUpdated;
_deviceWatcher.EnumerationCompleted += OnDeviceEnumerationCompleted;
}
private void StartLookup()
{
if (_deviceWatcher == null)
{
var aqsFilter = SerialDevice.GetDeviceSelector();
_deviceWatcher = DeviceInformation.CreateWatcher(aqsFilter);
_deviceWatcher.Added += DeviceWatcher_Added;
_deviceWatcher.Removed += DeviceWatcher_Removed;
_deviceWatcher.Start();
}
}
private async void AcceptButton_Click(object sender, RoutedEventArgs e)
{
var connection = _viewModel.Connection;
connection.Device = await SerialDevice.FromIdAsync(connection.Id);
MainPage.ViewModel.DeviceConnections.Add(connection);
MainPage.ViewModel.SelectedDeviceConnection = connection;
Frame.GoBack();
}
public void Close()
{
if (device != null)
{
device.Dispose();
device = null;
info = null;
}
Source?.Dispose();
Source = null;
}
protected virtual void DetruirePortSerie()
{
lock (_portSerieLock)
{
if (_portSerie != null)
{
_portSerie.Dispose();
}
_portSerie = null;
}
}
internal async Task<bool> InitializeAsync()
{
_lcdSerialDevice = await StartupTask.SerialDeviceHelper.GetSerialDeviceAsync("DN01E099", 9600, new TimeSpan(0, 0, 0, 1), new TimeSpan(0, 0, 0, 1));
if (_lcdSerialDevice == null)
return false;
_outputStream = new DataWriter(_lcdSerialDevice.OutputStream);
return true;
}
public MainPage()
{
this.InitializeComponent();
this.serialPort = null;
this.dataReader = null;
this.deviceList = new ObservableCollection <DeviceInformation>();
this.readCancellationTokenSource = null;
this.ListAvailablePort();
}
/// <summary>
/// comPortInput_Click: Action to take when 'Connect' button is clicked
/// - Get the selected device index and use Id to create the SerialDevice object
/// - Configure default settings for the serial port
/// - Create the ReadCancellationTokenSource token
/// - Start listening on the serial port input
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void comPortInput_Click(object sender, RoutedEventArgs e)
{
var selection = ConnectDevices.SelectedItems;
if (selection.Count <= 0)
{
status.Text = "Select a device and connect";
return;
}
DeviceInformation entry = (DeviceInformation)selection[0];
try
{
serialPort = await SerialDevice.FromIdAsync(entry.Id);
// Disable the 'Connect' button
comPortInput.IsEnabled = false;
// Configure serial settings
serialPort.WriteTimeout = TimeSpan.FromMilliseconds(1000);
serialPort.ReadTimeout = TimeSpan.FromMilliseconds(1000);
serialPort.BaudRate = 57600;
serialPort.Parity = SerialParity.None;
serialPort.StopBits = SerialStopBitCount.One;
serialPort.DataBits = 8;
serialPort.Handshake = SerialHandshake.None;
// Display configured settings
status.Text = "Serial port configured successfully: ";
status.Text += serialPort.BaudRate + "-";
status.Text += serialPort.DataBits + "-";
status.Text += serialPort.Parity.ToString() + "-";
status.Text += serialPort.StopBits;
// Set the RcvdText field to invoke the TextChanged callback
// The callback launches an async Read task to wait for data
// Create cancellation token object to close I/O operations when closing the device
ReadCancellationTokenSource = new CancellationTokenSource();
// Enable 'WRITE' button to allow sending data
sendTextButton.IsEnabled = true;
Listen();
}
catch (Exception ex)
{
status.Text = ex.Message;
comPortInput.IsEnabled = true;
sendTextButton.IsEnabled = false;
}
}
private void CloseSerialPortDevice()
{
try
{
_serialDevice?.Dispose();
_serialDevice = null;
}
catch (Exception ex)
{
throw new Exception($"{ex.Message} -->[WinIotPakcgeManager_CloseingDevice]", ex.InnerException);
}
}
private async void Page_Loaded(object sender, RoutedEventArgs e)
{
string aqs = SerialDevice.GetDeviceSelector();
var dis = await DeviceInformation.FindAllAsync(aqs);
DataContext = _viewModel =
new AddConnectionViewModel
{
DeviceIds = dis.Select(d => d.Id).ToList(),
Connection = null
};
}
public void InitWatcher()
{
string devSelector = SerialDevice.GetDeviceSelectorFromUsbVidPid(Vid, Pid);
watcher = DeviceInformation.CreateWatcher(devSelector);
watcher.Added += Watcher_Added;
watcher.Removed += Watcher_Removed;
watcher.EnumerationCompleted += Watcher_EnumerationCompleted;
watcher.Start();
InitTimer();
}
private async void InitializeComPort()
{
string aqs = SerialDevice.GetDeviceSelector();
DeviceInformationCollection dic = await DeviceInformation.FindAllAsync(aqs).AsTask();
DeviceInformation di = dic.FirstOrDefault();
_serialPort = await SerialDevice.FromIdAsync(di.Id).AsTask();
_serialPort.IsDataTerminalReadyEnabled = true;
_serialPort.BaudRate = 9600;
_readCancellationTokenSource = new CancellationTokenSource();
}
/// <summary>
/// CloseDevice:
/// - Disposes SerialDevice object
/// - Clears the enumerated device Id list
/// </summary>
private void CloseDevice()
{
if (serialPort != null)
{
serialPort.Dispose();
}
serialPort = null;
comPortInput.IsEnabled = true;
rcvdText.Text = "";
listOfDevices.Clear();
}
/// <summary>
/// Constructor configures the Serial settings for interfacing
/// with the Cottonwood board
/// </summary>
/// <param name="device">Serial device object representing
/// the Cottonwood board</param>
public Cottonwood(SerialDevice device)
{
//configures the serial settings for interfacing with
//the Cottonwood board
_rfidReader = device;
_rfidReader.WriteTimeout = TimeSpan.FromMilliseconds(1000);
_rfidReader.ReadTimeout = TimeSpan.FromMilliseconds(1000);
_rfidReader.BaudRate = 9600;
_rfidReader.Parity = SerialParity.None;
_rfidReader.StopBits = SerialStopBitCount.One;
_rfidReader.DataBits = 8;
}
private async Task SetupConnection()
{
//CLose any previous connections before associating the new one
CloseConnection();
serialDevice = await SerialDevice.FromIdAsync(serialDeviceId);
if (serialDevice != null)
{
//Configure connection
SerialCommunicationHelper.SetDefaultConfiguration(serialDevice);
}
}
private async void DeviceWatcher_Removed(DeviceWatcher sender, DeviceInformationUpdate args)
{
var device = await SerialDevice.FromIdAsync(args.Id);
if (_device != null && args.Id == _deviceId)
{
_device.DataReceived -= _device_DataReceived;
_device.Stop();
_device = null;
_deviceId = string.Empty;
}
}
public void Dispose()
{
lock (this)
{
if (_serialDevice != null)
{
_serialDevice.Dispose();
_serialDevice = null;
}
}
throw new NotImplementedException();
}
private static void _sds011_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
if (e.EventType == SerialData.Chars)
{
// Ignore the in between noise
}
else if (e.EventType == SerialData.WatchChar)
{
SerialDevice serDev = (SerialDevice)sender;
using (DataReader dr = new DataReader(serDev.InputStream))
{
dr.InputStreamOptions = InputStreamOptions.Partial;
uint bytesRead = dr.Load(serDev.BytesToRead);
if (bytesRead > 0)
{
byte[] rawData = new byte[bytesRead];
dr.ReadBytes(rawData);
// If rawData.Length == 10 and rawData[0] = 0xAA and rawData[9] = 0xAB and rawData[1] = 0xC0
// this means we have a valid measure package from the sensor
// and byte[2] = low byte, byte[3] = high byte of uint representing the AQI for PM 2.5
if (rawData.Length >= 10)
{
if ((rawData[0] == 0xAA) && (rawData[1] == 0xC0) && (rawData[9] == 0xAB))
{
// Need to do checksum
byte crc = 0;
for (int i = 0; i < 6; i++)
{
crc += rawData[i + 2];
}
if (crc == rawData[8])
{
// All right, we have a go !!!!
float pm25 = 0, pm10 = 0;
pm25 = (float)((int)rawData[2] | (int)(rawData[3] << 8)) / 10;
pm10 = (float)((int)rawData[4] | (int)(rawData[5] << 8)) / 10;
Console.WriteLine(String.Format("Air quality index: {0}\tPM 10\t{1} µg / m3\tPM 2.5\t{2} µg / m3\tSensor: {3}",
DateTime.UtcNow.ToString("yyyy'-'MM'-'dd'\t'HH':'mm':'ss"),
pm10.ToString("N1"),
pm25.ToString("N1"),
"SDS011"));
}
}
}
}
}
}
}
/// <summary>
/// Constructor configures the Serial settings for interfacing
/// with the Cottonwood board
/// </summary>
/// <param name="device">Serial device object representing
/// the Cottonwood board</param>
public Cottonwood(SerialDevice device)
{
//configures the serial settings for interfacing with
//the Cottonwood board
_rfidReader = device;
_rfidReader.WriteTimeout = TimeSpan.FromMilliseconds(1000);
_rfidReader.ReadTimeout = TimeSpan.FromMilliseconds(1000);
_rfidReader.BaudRate = 9600;
_rfidReader.Parity = SerialParity.None;
_rfidReader.StopBits = SerialStopBitCount.One;
_rfidReader.DataBits = 8;
}
public async Task LookForDevices()
{
State = ConnectionState.Enumerating;
Devices.Clear();
var serviceInfoCollection = await DeviceInformation.FindAllAsync(SerialDevice.GetDeviceSelector());
foreach (var serviceInfo in serviceInfoCollection)
{
Devices.Add(serviceInfo);
}
State = ConnectionState.Enumerated;
}
/// <summary>
/// 向串口发送数据
/// </summary>
/// <param name="data"></param>
public void SendData(byte[] data)
{
try
{
SerialDevice.DiscardInBuffer();
SerialDevice.Write(data, 0, data.Length);
}
catch (Exception ex)
{
ExceptionProcess(ex);
}
}
/// <summary>
/// 关闭串口资源
/// </summary>
public void Close()
{
try
{
SerialDevice.Close();
SerialDevice.Dispose();
}
catch (Exception ex)
{
ExceptionProcess(ex);
}
}
private void CloseDevice()
{
if (serialPort != null)
{
serialPort.Dispose();
}
serialPort = null;
connectButton.IsEnabled = true;
outputTextBox.Text = "";
deviceList.Clear();
}
public SerialPort(ushort vendorId, ushort productId)
{
var selector = SerialDevice.GetDeviceSelectorFromUsbVidPid(vendorId, productId);
var devices = Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(selector, null).AsTask().Result;
if (!devices.Any())
{
throw new ArgumentOutOfRangeException("Serialport not found, invalid vendorId or productId");
}
_id = devices.First().Id;
}
private void serialConnectButton_Click(object sender, RoutedEventArgs e)
{
Task.Run(async () =>
{
if (serialPort != null)
{
serialPort.Dispose(); // close Serial Port connection
serialPort = null;
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
serialConnectButton.Content = "Connect";
printLog("Board Disconnected");
serialChooseBox.IsEnabled = true;
});
}
else
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
{
var selection = serialChooseBox.SelectedIndex;
if ((serialChooseBox.Items.Count > 0) && (selection >= 0))
{
ComboBoxItem selectedItem = (ComboBoxItem)serialChooseBox.SelectedItem;
int serialConnectionStatus = await connectToSerial((string)selectedItem.Tag); // tag is holding info for serial connection (from doSerialScan)
// Ui
if (serialConnectionStatus == 0)
{
serialChooseBox.IsEnabled = false;
serialConnectButton.Content = "Disconnect";
// after connection is established, ask for board version
int version = await utpAskHwVersion();
if (version >= 0)
{
printLog(("Test Board v." + version.ToString()));
}
else
{
printLog("Connected, but couldn't get board version");
}
}
}
else
{
printLog("No Serial Port selected");
}
});
}
});
}
public SerialPort(string name)
{
var selector = SerialDevice.GetDeviceSelector(name);
var devices = Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(selector, null).AsTask().Result;
if (!devices.Any())
{
throw new ArgumentOutOfRangeException(nameof(name), name, "Serialport not found");
}
_id = devices.First().Id;
}
/// <summary>
/// Initialize and spawn serial device based on DeviceInformation and baud rate
/// </summary>
/// <param name="info">The device information for spawning the serial device</param>
/// <param name="baudRate">Specified baud rate</param>
/// <returns>The initialized SerialDevice</returns>
private static async Task <SerialDevice> InitializeSerialPort(DeviceInformation info, uint baudRate)
{
var retSerialPort = await SerialDevice.FromIdAsync(info.Id);
retSerialPort.Parity = SerialParity.None;
retSerialPort.StopBits = SerialStopBitCount.One;
retSerialPort.DataBits = 8;
retSerialPort.BaudRate = baudRate;
retSerialPort.Handshake = SerialHandshake.None;
return(retSerialPort);
}
public Arduino(SerialDevice uredjaj)
{
this.Uredjaj = uredjaj;
temperatura = vlaznostZemlje = "Nije procitano";
uredjaj.BaudRate = 9600;
uredjaj.DataBits = 8;
uredjaj.Parity = SerialParity.None;
uredjaj.Handshake = SerialHandshake.None;
uredjaj.StopBits = SerialStopBitCount.One;
uredjaj.ReadTimeout = TimeSpan.FromMilliseconds(1000);
uredjaj.WriteTimeout = TimeSpan.FromMilliseconds(1000);
}
private void SetupSerialDevice(SerialDevice serialDevice)
{
serialDevice.BaudRate = BaudRate;
serialDevice.StopBits = SerialStopBitCount.One;
serialDevice.DataBits = 8;
serialDevice.Parity = SerialParity.None;
serialDevice.Handshake = SerialHandshake.None;
serialDevice.IsDataTerminalReadyEnabled = true;
serialDevice.IsRequestToSendEnabled = false;
serialDevice.ReadTimeout = TimeSpan.FromMilliseconds(3); // default 5 seconds, we want instant response from Arduino boards
serialDevice.WriteTimeout = TimeSpan.FromMilliseconds(10000);
}
/// <summary>
/// Gets all serial devices connected to the computer and sets the SerialDevices collection
/// </summary>
public async void GetSerialDevices()
{
try
{
//Gets all COM and Blutooth ports
var aqs = SerialDevice.GetDeviceSelector();
SerialDevices = await DeviceInformation.FindAllAsync(aqs);
}
catch (Exception ex)
{
}
}
internal async Task<bool> InitializeAsync()
{
_gpsSerialDevice = await StartupTask.SerialDeviceHelper.GetSerialDeviceAsync("AH03F3RY", 57600, TimeSpan.FromMilliseconds(200), TimeSpan.FromMilliseconds(200));
if (_gpsSerialDevice == null)
return false;
_outputStream = new DataWriter(_gpsSerialDevice.OutputStream);
_inputStream = new DataReader(_gpsSerialDevice.InputStream) {InputStreamOptions = InputStreamOptions.Partial};
return true;
}
/// <summary>
/// WriteAsync: Task that asynchronously writes data from the input text box 'sendText' to the OutputStream
/// </summary>
public async Task OpenDevices(ListBox devices_list)
{
var selection = devices_list.SelectedItems;
error = false;
if (selection.Count <= 0)
{
error = true;
status = "СТАТУС: ВЫБЕРИТЕ И ПОДКЛЮЧИТЕ УСТРОЙСТВО";
return;
}
DeviceInformation entry = (DeviceInformation)selection[0];
try
{
serialport = await SerialDevice.FromIdAsync(entry.Id);
// Configure serial settings
serialport.WriteTimeout = TimeSpan.FromMilliseconds(50);
serialport.ReadTimeout = TimeSpan.FromMilliseconds(50);
serialport.BaudRate = 9600;
serialport.Parity = SerialParity.None;
serialport.StopBits = SerialStopBitCount.One;
serialport.DataBits = 8;
serialport.Handshake = SerialHandshake.None;
// Display configured settings
status = "СТАТУС: ПОДКЛЮЧЕНО - ";
status += serialport.BaudRate + "-";
status += serialport.DataBits + "-";
status += serialport.Parity.ToString() + "-";
status += serialport.StopBits;
wait_answer = 0;
// Create cancellation token object to close I/O operations when closing the device
ReadCancellationTokenSource = new CancellationTokenSource();
// Enable 'WRITE' button to allow sending data
// sendTextButton.IsEnabled = true;
Listen();
}
catch (Exception ex)
{
status = "СТАТУС: " + ex.Message;
error = true;
}
}
public void Open()
{
_device = SerialDevice.FromIdAsync(_id).AsTask().Result;
if (_device == null)
throw new Exception("Error opening serialdevice, make sure the app manifest contains a DeviceCapability section for the serialport.");
_device.BaudRate = 115200;
_device.Parity = SerialParity.None;
_device.DataBits = 8;
_device.StopBits = SerialStopBitCount.One;
_inputStream = new SerialReadStream(_device.InputStream);
_outputStream = new SerialWriteStream(_device.OutputStream);
}
private async Task Initialize()
{
var device = SerialDevice.GetDeviceSelectorFromUsbVidPid(0x1F00, 0x2012);
var usbDevices = await DeviceInformation.FindAllAsync(device);
var currentDevice = usbDevices.FirstOrDefault();
_realDevice = await SerialDevice.FromIdAsync(currentDevice.Id);
_realDevice.Handshake = SerialHandshake.XOnXOff;
_realDevice.BaudRate = 9600;
_realDevice.Parity = SerialParity.None;
_realDevice.StopBits = SerialStopBitCount.One;
_realDevice.DataBits = 8;
_realDevice.IsDataTerminalReadyEnabled = true;
}
public async void SerialConnection()
{
SetStatus("Retrieving RFID Reader through UART Bridge ...");
string deviceQuery = SerialDevice.GetDeviceSelector();
var discovered = await DeviceInformation.FindAllAsync(deviceQuery);
var readerInfo = discovered.Where(x => x.Name == _uartBridgeName).First();
_rfidReader = await SerialDevice.FromIdAsync(readerInfo.Id);
_rfidReader.WriteTimeout = TimeSpan.FromMilliseconds(1000);
_rfidReader.ReadTimeout = TimeSpan.FromMilliseconds(1000);
_rfidReader.BaudRate = 9600;
_rfidReader.Parity = SerialParity.None;
_rfidReader.StopBits = SerialStopBitCount.One;
_rfidReader.DataBits = 8;
SetStatus("Reader ready and configured");
}
//Create a device from a module connected to COM1 serial port
public Boolean CreateSerialDevice()
{
SerialDevice sd = new SerialDevice();
try
{
sd.Address = "COM1";
sd.BaudRate = 38400;
sd.ReadTimeout = 200;
device = sd;
}
catch (Exception ex)
{
Console.Out.WriteLine("EXCEPTION:" + ex.ToString());
}
return true;
}
private ArduinoDevice(SerialDevice device)
{
_Device = device;
_Device.BaudRate = 115200;
_Device.DataBits = 8;
_Device.Parity = SerialParity.None;
_Device.StopBits = SerialStopBitCount.One;
_Device.Handshake = SerialHandshake.None;
_Device.WriteTimeout = TimeSpan.FromMilliseconds(1000);
_Device.ReadTimeout = TimeSpan.FromMilliseconds(1000);
_DeviceWriter = new DataWriter(_Device.OutputStream);
_DeviceReader = new DataReader(_Device.InputStream);
_DeviceReader.InputStreamOptions = InputStreamOptions.Partial;
}
private async Task Init()
{
_serialPort = await SerialDevice.FromIdAsync(_device.Id);
// Configure serial settings
_serialPort.BaudRate = 115200;
_serialPort.Parity = SerialParity.None;
_serialPort.StopBits = SerialStopBitCount.One;
_serialPort.DataBits = 8;
_dataReader = new DataReader(_serialPort.InputStream);
await Task.Run(async () =>
{
while (!_cancellation.Token.IsCancellationRequested)
{
await ReadAsync();
}
}, _cancellation.Token);
}
private async Task OpenPort(string deviceId)
{
serialPort = await SerialDevice.FromIdAsync(deviceId);
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;
txtStatus.Text = "Serial port configured successfully";
btnOne.IsEnabled = true;
btnZero.IsEnabled = true;
}
}
public async Task<bool> Open()
{
var devices = await DeviceInformation.FindAllAsync(SerialDevice.GetDeviceSelector());
if (devices.Count > 0)
{
serialPort = await SerialDevice.FromIdAsync(devices[0].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;
return await SendAsync("AT", "AT");
}
}
return false;
}
/// <summary>
/// This functions initimlaize a serial port and pass it to the brick
/// </summary>
/// <returns></returns>
private async Task InitSerial()
{
string aqs = SerialDevice.GetDeviceSelector();
var dis = await DeviceInformation.FindAllAsync(aqs);
for (int i = 0; i < dis.Count; i++)
{
Debug.WriteLine(string.Format("Serial device found: {0}", dis[i].Id));
if (dis[i].Id.IndexOf("UART0") != -1)
{
serialPort = await SerialDevice.FromIdAsync(dis[i].Id);
}
}
if (serialPort != null)
{
Debug.WriteLine("Serial port initialiazed");
brick = new Brick(serialPort);
Debug.WriteLine("Brick initialiazed");
}
}
