private async void GetAvailablePort()
{
try
{
string aqs = SerialDevice.GetDeviceSelector();
var dis = await DeviceInformation.FindAllAsync(SerialDevice.GetDeviceSelectorFromUsbVidPid(0x0D28, 0x0204));
serialPort = await SerialDevice.FromIdAsync(dis[0].Id);
try
{
// 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;
ReadCancellationTokenSource = new CancellationTokenSource();
Listen();
}
catch (Exception ex)
{
}
}
catch (Exception ex)
{
}
}
public static async Task Initiate()
{
if (writer != null || reader != null || serialDevice != null)
{
return;
}
var deviceSelector = SerialDevice.GetDeviceSelectorFromUsbVidPid(ArduinoDevice.Vid, ArduinoDevice.Pid);
var deviceWatcher = DeviceInformation.CreateWatcher(deviceSelector);
deviceWatcher.Added += DeviceWatcher_AddedAsync;
deviceWatcher.Removed += DeviceWatcher_Removed;
var device = await DeviceInformation.FindAllAsync(deviceSelector);
serialDevice = await SerialDevice.FromIdAsync(device[0].Id);
serialDevice.BaudRate = 9600;
serialDevice.DataBits = 8;
serialDevice.Parity = SerialParity.None;
serialDevice.StopBits = SerialStopBitCount.One;
serialDevice.ReadTimeout = System.TimeSpan.FromMilliseconds(500);
writer = new DataWriter(serialDevice.OutputStream);
reader = new DataReader(serialDevice.InputStream);
reader.InputStreamOptions = InputStreamOptions.Partial;
}
private async Task FindDevice()
{
Debug.WriteLine("begintest");
UInt16 vid = 0x2341;
UInt16 pid = 0x0001;
string aqs = SerialDevice.GetDeviceSelectorFromUsbVidPid(vid, pid);
var myDevices = await DeviceInformation.FindAllAsync(aqs);
if (myDevices.Count == 0)
{
Debug.WriteLine("Device not found!");
return;
}
try
{
Debug.WriteLine("testrange");
Debug.WriteLine(myDevices[0].Id);
serialPort = await SerialDevice.FromIdAsync(myDevices[0].Id);
if (serialPort == null)
{
Debug.WriteLine("null2");
return;
}
Debug.WriteLine("ok");
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;
Debug.WriteLine("ok2");
/*String debugtest = "Serial port configured successfully: ";
* debugtest += serialPort.BaudRate + "-";
* debugtest += serialPort.DataBits + "-";
* debugtest += serialPort.Parity.ToString() + "-";
* debugtest += serialPort.StopBits;
* debugtest += (DeviceInformation)myDevices[0];
*
* Debug.WriteLine("debugtest1");
* Debug.WriteLine(debugtest);*/
Debug.WriteLine("debugtest2");
await Listen();
}
catch (Exception exception)
{
Debug.WriteLine(exception.Message.ToString());
Debug.WriteLine("error");
}
finally
{
Debug.WriteLine("Opened device for communication.");
}
Debug.WriteLine("test2");
}
/// <summary>
/// ListAvailablePorts
/// - Use SerialDevice.GetDeviceSelector to enumerate all serial devices
/// - Attaches the DeviceInformation to the ListBox source so that DeviceIds are displayed
/// </summary>
private async Task <DeviceInformationCollection> ListAvailablePorts()
{
try
{
string aqs = "";
#if PI
aqs = SerialDevice.GetDeviceSelector();
#else
ushort vid = 0x067B;
ushort pid = 0x2303;
aqs = SerialDevice.GetDeviceSelectorFromUsbVidPid(vid, pid);
#endif
DeviceInformationCollection dic = await DeviceInformation.FindAllAsync(aqs);
return(dic);
//for (int i = 0; i < dic.Count; i++)
//{
// listOfDevices.Add(dic[i]);
//}
}
catch (Exception ex)
{
this.log.Error(ex.Message);
this.ViewModel.Status = ex.Message;
return(null);
}
}
/// <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(0x2A03, 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 void InitializeSerial(ushort vid, ushort pid)
{
string aqs = SerialDevice.GetDeviceSelectorFromUsbVidPid(vid, pid);
var myDevices = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(aqs, null);
if (myDevices.Count == 0)
{
Debug.Write("No device detected\r\n");
return;
}
else
{
try
{
Debug.Write("Device connected!\r\n");
serialDevice = await SerialDevice.FromIdAsync(myDevices[0].Id);
serialDevice.BaudRate = 9600;
serialDevice.StopBits = SerialStopBitCount.One;
serialDevice.DataBits = 8;
serialDevice.Parity = SerialParity.None;
serialDevice.Handshake = SerialHandshake.None;
Debug.Write(serialDevice.PortName + " open\r\n");
SendSetupCommands();
}
catch
{
Debug.Write("No device detected\r\n");
}
return;
}
}
public async void GetDevice(string model)
{
if (devices == null)
{
if (model == "MEGA")
{
string selector = SerialDevice.GetDeviceSelectorFromUsbVidPid(ArduinoDevice.MegaVid, ArduinoDevice.MegaPid);
this.devices = await DeviceInformation.FindAllAsync(selector);
}
if (model == "UNO")
{
string selector = SerialDevice.GetDeviceSelectorFromUsbVidPid(ArduinoDevice.UnoVid, ArduinoDevice.UnoPid);
this.devices = await DeviceInformation.FindAllAsync(selector);
}
}
if (devices.Count > 0)
{
try
{
this.deviceInfo = devices[0];
this.serialDevice = await SerialDevice.FromIdAsync(deviceInfo.Id);
this.serialDevice.BaudRate = 9600;
this.serialDevice.Parity = SerialParity.None;
this.serialDevice.StopBits = SerialStopBitCount.One;
this.serialDevice.Handshake = SerialHandshake.None;
this.serialDevice.DataBits = 8;
}
finally
{
}
}
}
private void InitializeDeviceWatchers()
{
string deviceSelector = SerialDevice.GetDeviceSelectorFromUsbVidPid(ArduinoDevice.Vid, ArduinoDevice.Pid);
var deviceWatcher = DeviceInformation.CreateWatcher(deviceSelector);
AddDeviceWatcher(deviceWatcher, deviceSelector);
}
/// <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()
{
string deviceSelector = SerialDevice.GetDeviceSelectorFromUsbVidPid(ArduinoDevice.Vid, ArduinoDevice.Pid);
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 RovConnector()
{
DeviceSelector = SerialDevice.GetDeviceSelectorFromUsbVidPid(UsbVendorId, UsbProductId);
Watcher = DeviceInformation.CreateWatcher(DeviceSelector);
Watcher.Added += Watcher_Added;
Watcher.Removed += Watcher_Removed;
Watcher.Updated += Watcher_Updated;
}
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;
}
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 static async void DeviceWatcher_AddedAsync(DeviceWatcher sender, DeviceInformation args)
{
var deviceSelector = SerialDevice.GetDeviceSelectorFromUsbVidPid(ArduinoDevice.Vid, ArduinoDevice.Pid);
var device = await DeviceInformation.FindAllAsync(deviceSelector);
serialDevice = await SerialDevice.FromIdAsync(device[0].Id);
serialDevice.BaudRate = 9600;
serialDevice.DataBits = 8;
serialDevice.Parity = SerialParity.None;
serialDevice.StopBits = SerialStopBitCount.One;
writer = new DataWriter(serialDevice.OutputStream);
reader = new DataReader(serialDevice.InputStream);
}
public static async Task <ManagedSerialPort> CreateForVendorProductAsync(ushort vendorId, ushort productId, SerialPortOptions options)
{
var serialPortSelector = SerialDevice.GetDeviceSelectorFromUsbVidPid(vendorId, productId);
var devices = await DeviceInformation.FindAllAsync(serialPortSelector);
if (devices.Count == 0)
{
throw new ArgumentException($"Unable to find serial device with VendorId 0x{vendorId:X}, ProductId 0x{productId:X}");
}
var serialPortDevice = await SerialDevice.FromIdAsync(devices[0].Id);
var serialPortImpl = new UWPSerialPortImplementation(serialPortDevice, options);
return(new ManagedSerialPort(serialPortImpl));
}
private async Task FindDevice()
{
//\\?\USB#VID_16C0&PID_0483#1439500#{86e0d1e0-8089-11d0-9ce4-08003e301f73}
string deviceSelector = SerialDevice.GetDeviceSelectorFromUsbVidPid(0x16C0, 0x0483);
DeviceInformationCollection devices = await DeviceInformation.FindAllAsync(deviceSelector);
if (devices.Count == 1)
{
SelectedDevice = devices[0];
OnPropertyChanged(nameof(Titel));
}
else
{
SelectedDevice = null;
}
}
public void Start()
{
if (Config == null)
{
return;
}
string deviceSelector = SerialDevice.GetDeviceSelectorFromUsbVidPid(Config.VendorId, Config.ProductId);
var deviceResult = DeviceInformation.FindAllAsync(deviceSelector).AsTask().GetAwaiter().GetResult();
var devices = deviceResult.ToList();
_device = SerialDevice.FromIdAsync(devices.First().Id).AsTask().GetAwaiter().GetResult();
_cancellationTokenSource = new CancellationTokenSource();
_readTask = Task.Run(ReadTask);
}
public static async Task <UWPSerialDevice[]> GetDevicesWithVidPidAsync(ushort vid, ushort pid)
{
var advancedQuerySyntax = SerialDevice.GetDeviceSelectorFromUsbVidPid(vid, pid);
var currentDeviceInfos = await DeviceInformation.FindAllAsync(advancedQuerySyntax)
.AsTask()
.ConfigureAwait(false);
UpdateDeviceCache(currentDeviceInfos);
var devices = new List <UWPSerialDevice>();
foreach (var deviceInfo in currentDeviceInfos)
{
DeviceCache.TryGetValue(deviceInfo.Id, out UWPSerialDevice device);
devices.Add(device);
}
return(devices.ToArray());
}
public async Task ListAvailablePorts()
{
// 1. Discover all device COM device IDs.
// 2. Create a new SerialDevice
// 3. Iterate over found COM IDs
// 4. Look for SerialDevice based on COM ID.
// 5. When found, check if it is already in the dictionary.
// 6. If not in dictionary, add COM ID to dictionary and
// add SerialDevice to dictionary, keyed to portName.
// 7. When each device is found, callback to UI with the update.
try
{
string aqs = SerialDevice.GetDeviceSelector();
dis = await DeviceInformation.FindAllAsync(SerialDevice.GetDeviceSelectorFromUsbVidPid(0x0000, 0xFFFF));
//SerialDevice newSerialDevice
serialPortStatus = serialPortStatuses.didNotFindDevices;
for (int i = 0; i < dis.Count; i++)
{
if (!listOfDevices.ContainsKey(dis[i].Id))
{
var newSerialDevice = await SerialDevice.FromIdAsync(dis[i].Id);
listOfDevices.Add(dis[i].Id, dis[i]);
listOfPorts.Add(newSerialDevice.PortName, newSerialDevice);
}
if (listOfPorts.Count > 0)
{
serialPortStatus = serialPortStatuses.foundDevices;
}
}
}
catch (Exception ex)
{
Debug.WriteLine("List ports caught: " + ex.Message);
}
Callback(this, serialPortStatus);
}
public static async Task <AdaLightController> Create()
{
var deviceSelector = SerialDevice.GetDeviceSelectorFromUsbVidPid(0x1A86, 0x7523);
var deviceInformations = await DeviceInformation.FindAllAsync(deviceSelector);
if (deviceInformations.Count == 0)
{
return(null);
}
var deviceInformation = deviceInformations.FirstOrDefault();
var serialDevice = await SerialDevice.FromIdAsync(deviceInformation.Id);
serialDevice.BaudRate = 1000000;
var dataWriter = new DataWriter(serialDevice.OutputStream);
return(new AdaLightController(dataWriter));
}
private async Task <string> GetDeviceIdFromUsbVidPid()
{
DeviceInformationCollection deviceInfos = null;
string selector;
// go through all valid Vid/Pid pair and try GetDeviceSelectorFromUsbVidPid()
foreach (var vidPidPair in m_validVidPidList)
{
selector = SerialDevice.GetDeviceSelectorFromUsbVidPid(vidPidPair.vid, vidPidPair.pid);
deviceInfos = await DeviceInformation.FindAllAsync(selector);
if (deviceInfos.Count > 0)
{
return(deviceInfos[0].Id);
}
}
// Enumerate all devices and find VID and PID in device IDs
// e.g. "\\\\?\\FTDIBUS#VID_0403+PID_6001+A603GDNAA#0000#{86e0d1e0-8089-11d0-9ce4-08003e301f73}"
selector = SerialDevice.GetDeviceSelector();
deviceInfos = await DeviceInformation.FindAllAsync(selector);
if (deviceInfos.Count > 0)
{
// go through all valid Vid/Pid pair
foreach (var vidPidPair in m_validVidPidList)
{
string vidString = "VID_" + vidPidPair.vid.ToString("X4");
string pidString = "PID_" + vidPidPair.pid.ToString("X4");
foreach (var deviceInfo in deviceInfos)
{
if (deviceInfo.Id.Contains(vidString) && deviceInfo.Id.Contains(pidString))
{
return(deviceInfo.Id);
}
}
}
}
// can't find any matching Vid/Pid
return(null);
}
private async void ListAvailablePorts(ComboBox myComboBox)
{
try
{
string aqs = SerialDevice.GetDeviceSelector();
var dis = await DeviceInformation.FindAllAsync(SerialDevice.GetDeviceSelectorFromUsbVidPid(0x04D8, 0x000A));
serialPort = await SerialDevice.FromIdAsync(dis[0].Id);
for (int i = 0; i < dis.Count; i++)
{
listOfDevices.Add(dis[i]);
myComboBox.Items.Add(new Item(dis[i].ToString(), i));
}
}
catch
{
;
}
}
private async void FetchArduinoData()
{
// ID"S HAVE TO BE CHANGED ACCORDING TO YOUR DEVICES
UInt16 vid = 0x045E;
UInt16 pid = 0x078F;
string aqs = SerialDevice.GetDeviceSelectorFromUsbVidPid(vid, pid);
var myDevices = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(aqs, null);
if (myDevices.Count == 0)
{
var Err2Msg = new MessageDialog("Device not found!", "Error");
await Err2Msg.ShowAsync();
return;
}
SerialDevice device = await SerialDevice.FromIdAsync(myDevices[0].Id);
//FindAllAsync(aqs);
}
public SpikePortControlViewModel()
{
sendOrPostCb = TriggerRefresh;
context = SynchronizationContext.Current !;
var deviceClass = BluetoothDevice.GetDeviceSelectorFromClassOfDevice(BluetoothClassOfDevice.FromParts(BluetoothMajorClass.Toy, BluetoothMinorClass.ToyRobot, BluetoothServiceCapabilities.None));
deviceWatcherBluetooth = DeviceInformation.CreateWatcher(deviceClass);
deviceWatcherSerial = DeviceInformation.CreateWatcher(SerialDevice.GetDeviceSelectorFromUsbVidPid(0x0694, 0x0010), new string[] { "System.DeviceInterface.Serial.PortName" });
deviceWatcherSerial.Added += DeviceWatcher_Added;
deviceWatcherSerial.Removed += DeviceWatcher_Removed;
deviceWatcherSerial.Updated += DeviceWatcher_Updated;
deviceWatcherSerial.Stopped += DeviceWatcher_Stopped;
deviceWatcherSerial.EnumerationCompleted += DeviceWatcher_EnumerationCompleted;
deviceWatcherBluetooth.Added += DeviceWatcher_Added;
deviceWatcherBluetooth.Removed += DeviceWatcher_Removed;
deviceWatcherBluetooth.Updated += DeviceWatcher_Updated;
deviceWatcherBluetooth.Stopped += DeviceWatcher_Stopped;
deviceWatcherBluetooth.EnumerationCompleted += DeviceWatcher_EnumerationCompleted;
deviceWatcherSerial.Start();
deviceWatcherBluetooth.Start();
}
public static async Task <DeviceInformationCollection> GetDeviceInformationsFromUsbVidPidAsync(ushort[] vidPid)
{
string aqs = SerialDevice.GetDeviceSelectorFromUsbVidPid(vidPid[0], vidPid[1]);
return(await DeviceInformation.FindAllAsync(aqs));
}
///------------------------------------------ Arduino Uno PIXY Initialization FUNCTION -----------------------------------------
public async Task Serial_InitializeConnection()
{
try
{
LineGraph content = Frame.Content as LineGraph;
var aqs_uno = SerialDevice.GetDeviceSelectorFromUsbVidPid(0x2341, 0x0043); //0x2A03, 0x0057 (Uno On Table = 0x2341, 0x0043) (Due Programming: 0x2341, 0x003D) (Due Native USB: 0x2341, 0x003E)
var info_uno = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(aqs_uno);
var aqs_due = SerialDevice.GetDeviceSelectorFromUsbVidPid(0x2341, 0x003D); //0x2A03, 0x0057 (Uno On Table = 0x2341, 0x0043) (Due Programming: 0x2341, 0x003D) (Due Native USB: 0x2341, 0x003E UWP UNSUPPORTED)
var info_due = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(aqs_due);
// Get connection data FOR aRDUINO uNO
for (int i = 0; i != info_uno.Count; i++)
{
if (info_uno[i].Name.Contains("COM12")) //Reading
{
serialPortUnoPixy = await SerialDevice.FromIdAsync(info_uno[i].Id);
// Configure serial settings
serialPortUnoPixy.DataBits = 8;
serialPortUnoPixy.BaudRate = 115200;
serialPortUnoPixy.Parity = SerialParity.None;
serialPortUnoPixy.Handshake = SerialHandshake.None;
serialPortUnoPixy.StopBits = SerialStopBitCount.One;
serialPortUnoPixy.ReadTimeout = TimeSpan.FromMilliseconds(1000);
serialPortUnoPixy.WriteTimeout = TimeSpan.FromMilliseconds(1000);
UnoPixydataReader = new DataReader(serialPortUnoPixy.InputStream);
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
content.program_log.Text = "Connected to Arduino Uno COM12 PIXY \r\n" + content.program_log.Text;
});
}
if (info_uno[i].Name.Contains("COM5")) //Writing to
{
//
}
func_serial_init_success = true;
}
// Get connection data FOR aRDUINO Due
serialPortDueReward_Write = await SerialDevice.FromIdAsync(info_due[0].Id);
// Configure serial settings
serialPortDueReward_Write.DataBits = 8;
serialPortDueReward_Write.BaudRate = 115200;
serialPortDueReward_Write.Parity = SerialParity.None;
serialPortDueReward_Write.Handshake = SerialHandshake.None;
serialPortDueReward_Write.StopBits = SerialStopBitCount.One;
serialPortDueReward_Write.ReadTimeout = TimeSpan.FromMilliseconds(10);
serialPortDueReward_Write.WriteTimeout = TimeSpan.FromMilliseconds(10);
serialPortDueReward_Write.IsDataTerminalReadyEnabled = true;
DueRewarddataWriter = new DataWriter(serialPortDueReward_Write.OutputStream);
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
content.program_log.Text = "Connected to Arduino DUE REWARD Write \r\n" + content.program_log.Text;
});
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Serial Init error" + ex.Message);
}
}
/// <inheritdoc/>
public override Task <IEnumerable <Serial.DeviceInfo> > FindAllAsync(ushort vendorId, ushort productId)
{
var aqs = SerialDevice.GetDeviceSelectorFromUsbVidPid(vendorId, productId);
return(FindAllAsync(aqs));
}
private async void ConnectToSerialPort()
{
DeviceInformationCollection serialDevices;
while ((serialDevices = await DeviceInformation.FindAllAsync(SerialDevice.GetDeviceSelectorFromUsbVidPid(0x04D8, 0x000A))).Count < 1)
{
Debug.WriteLine("Unable to locate...");
}
ReceiverConnected.IsChecked = true;
SerialDevice serialPort;
while ((serialPort = await SerialDevice.FromIdAsync(serialDevices[0].Id)) == null)
{
Debug.WriteLine("Failed to open serial port...");
}
SerialPortOpen.IsChecked = true;
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;
var dataReader = new DataReader(serialPort.InputStream);
var buffer = new byte[1024];
while (true)
{
var bytesRead = await dataReader.LoadAsync((uint)buffer.Length);
if (bytesRead > 0)
{
try
{
dataReader.ReadBytes(buffer);
Bytes.AddRange(buffer.Take((int)bytesRead));
byte[] slipPacket;
while ((slipPacket = Slip.ExtractSlipPacket(Bytes)) != null)
{
var waxPacket = WaxPacketConverter.FromBinary(slipPacket, DateTime.Now);
if (waxPacket != null)
{
if (!Devices.Contains(waxPacket.DeviceId.ToString()))
{
Devices.Add(waxPacket.DeviceId.ToString());
}
foreach (var sample in waxPacket.Samples)
{
_waxSendRepository.Send(new Wax3Data
{
DeviceId = waxPacket.DeviceId,
Timestamp = sample.Timestamp,
AccX = sample.X,
AccY = sample.Y,
AccZ = sample.Z
});
}
}
}
}
catch (Exception e)
{
Debug.WriteLine(e);
}
}
}
}
static async Task Main(string[] args)
{
var deviceSelector = SerialDevice.GetDeviceSelectorFromUsbVidPid(0x1A86, 0x7523);
var deviceInformations = await DeviceInformation.FindAllAsync(deviceSelector);
if (deviceInformations.Count == 0)
{
return;
}
var deviceInformation = deviceInformations.FirstOrDefault();
var serialDevice = await SerialDevice.FromIdAsync(deviceInformation.Id);
serialDevice.BaudRate = 1000000;
var dataWriter = new DataWriter(serialDevice.OutputStream);
var watch = new Stopwatch();
var frame = 0;
while (true)
{
watch.Start();
ushort count = 156;
//ushort count = 50;
var messageLength = 6 + count * 3;
var stream = new MemoryStream(messageLength);
stream.WriteByte(0x41);
stream.WriteByte(0x64);
stream.WriteByte(0x61);
var hi = (byte)((count - 1) >> 8);
var lo = (byte)((count - 1) & 0xff);
var checksum = (byte)(hi ^ lo ^ 0x55);
stream.WriteByte(hi);
stream.WriteByte(lo);
stream.WriteByte(checksum);
for (var i = 0; i < count; i++)
{
//var p = Math.Sin(Math.PI * ((i + frame / 100.0) % (count - 1)) / (count - 1)) * 255;
//var s = ((double)(i + frame / 25.0) % (count - 1)) / (count - 1);
var s = ((double)(i * 8 + frame) % (count - 1)) / (count - 1);
//var color = HSLToRGB(s, 1, (frame % 2 > 0) ? 0.5 : 0, 1);
var color = HSLToRGB(s, 1, 0.20, 1);
//var p = ((count - 1 - i) / (count - 1.0)) * 255;
//var q = ToneMap(p);
//var x = (byte)(q);
//Console.WriteLine(x);
//var color = new RGBA(100, 100, 100, 0);
//var y = (frame % 100) / 100.0 > 0.5 ? 0 : 1;
//var x = (byte)(i % 2 == y ? 64 : 255);
stream.WriteByte(ToneMap(color.R));
//stream.WriteByte((byte)(frame % 255));
//stream.WriteByte(1);
stream.WriteByte(ToneMap(color.G));
stream.WriteByte(ToneMap(color.B));
}
dataWriter.WriteBytes(stream.ToArray());
await dataWriter.StoreAsync();
Thread.Sleep(6);
watch.Stop();
var time = watch.Elapsed;
watch.Reset();
frame++;
if (frame % 10 == 0)
{
Console.WriteLine(1 / time.TotalSeconds);
}
}
var dataReader = new DataReader(serialDevice.InputStream);
await dataReader.LoadAsync(3);
var text = dataReader.ReadString(3);
}
