private async Task CheckDeviceAsync() { while (!_close) { Thread.Sleep(10000); var aqs = UsbDevice.GetDeviceSelector(VendorId, ProductId); var myDevices = await DeviceInformation.FindAllAsync(aqs); if (myDevices.Count == 0) { IsAttached = false; continue; } else { if (IsAttached) { continue; } IsAttached = true; _targetDevice = await UsbDevice.FromIdAsync(myDevices[0].Id); if (_targetDevice != null) { GetInterfaces(); } NotifyDeviceAvailabilityObservers(); } } }
//Having got access to Hid device can access it: //HidDevice hidDevice; //private async Task GetNumericInputReportAsync() //{ // var inputReport = await DeviceList.Current.CurrentDevice.GetInputReportAsync(hidDevice.ReadWriteBuffer.ReportId); // var inputReportControl = inputReport.GetNumericControl(hidDevice..ReadWriteBuffer.NumericUsagePage, hidDevice.ReadWriteBuffer.NumericUsageId); // var data = inputReportControl.Value; // this.NotifyUser("Value read: " + data.ToString("X2", NumberFormatInfo.InvariantInfo), NotifyType.StatusMessage); //} //////////////////////////////////////////////////////////////////////////////// /// These direct USB calls don't work??? : /// <summary> /// Use VID PID and class GUID /// </summary> /// <param name="deviceVid"></param> /// <param name="devicePid"></param> /// <param name="deviceInterfaceClassGuid"></param> /// <returns></returns> public async Task SearchForUSBDevice(ushort deviceVid, ushort devicePid, Guid deviceInterfaceClassGuid) { string aqs = UsbDevice.GetDeviceSelector(deviceVid, devicePid, deviceInterfaceClassGuid); var myDevices = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(aqs, null); if (myDevices.Count == 0) { NotifyUser("USB Device not found!"); return; } UsbDevice device = null; foreach (var mydevice in myDevices) { device = await UsbDevice.FromIdAsync(mydevice.Id); if (device != null) { break; } } if (device != null) { NotifyUser("USB Device found."); } else { NotifyUser("USB Device not found!"); } }
/// <summary> /// This method opens the device using the WinRT USB API. After the device is opened, save the device /// so that it can be used across scenarios. /// /// It is important that the FromIdAsync call is made on the UI thread because the consent prompt can only be displayed /// on the UI thread. /// /// This method is used to reopen the device after the device reconnects to the computer and when the app resumes. /// </summary> /// <param name="deviceInfo">Device information of the device to be opened</param> /// <param name="deviceSelector">The AQS used to find this device</param> /// <returns>True if the device was successfully opened, false if the device could not be opened for well known reasons. /// An exception may be thrown if the device could not be opened for extraordinary reasons.</returns> public async Task <bool> OpenDeviceAsync(DeviceInformation deviceInfo, String deviceSelector) { Device = await UsbDevice.FromIdAsync(deviceInfo.Id); Boolean successfullyOpenedDevice = false; MainPage.NotifyType notificationStatus; String notificationMessage = null; // Device could have been blocked by user or the device has already been opened by another app. if (Device != null) { successfullyOpenedDevice = true; DeviceInformation = deviceInfo; this.DeviceSelector = deviceSelector; notificationStatus = MainPage.NotifyType.StatusMessage; notificationMessage = "Device Opened"; // Notify registered callback handle that the device has been opened if (OnDeviceConnected != null) { OnDeviceConnected(this, DeviceInformation); } } else { successfullyOpenedDevice = false; notificationStatus = MainPage.NotifyType.ErrorMessage; DeviceAccessInformation dai = DeviceAccessInformation.CreateFromId(deviceInfo.Id); var deviceAccessStatus = dai.CurrentStatus; if (deviceAccessStatus == DeviceAccessStatus.DeniedByUser) { notificationMessage = "Access to the device was blocked by the user."; } else if (deviceAccessStatus == DeviceAccessStatus.DeniedBySystem) { // This status is most likely caused by app permissions (did not declare the device in the app's package.appxmanifest) // This status does not cover the case where the device is already opened by another app. notificationMessage = "Access to the device was blocked by the system."; } else { // The only time I made it to this error I forgot to add Fadecandy to package.appxmanifest // Most likely the device is opened by another app, but cannot be sure notificationMessage = "Unknown error, possibly opened by another app."; } } MainPage.Current.NotifyUser(notificationMessage, deviceInfo.Id, notificationStatus); return(successfullyOpenedDevice); }
private async void OnDeviceAdded(DeviceWatcher watcher, DeviceInformation deviceInformation) { if (deviceInformation.Name.StartsWith("ClearShot") && deviceInformation.IsEnabled) { _targetDevice = await UsbDevice.FromIdAsync(deviceInformation.Id); OnConnected(EventArgs.Empty); } }
private void OpenDevice() { var deviceTask = UsbDevice.FromIdAsync(deviceSyncDetails.DeviceId).AsTask(cancellationTokenSource.Token); deviceTask.Wait(); device = deviceTask.Result; // We opened the device, so notify the app that we've completed a bit of the background task backgroundTaskInstance.Progress = 10; }
private async void Watcher_Added(Windows.Devices.Enumeration.DeviceWatcher sender, DeviceInformation args) { // FIXME: async void - need to log error or something var device = await UsbDevice.FromIdAsync(args.Id); if (device == null) { // we probably don't have permission to use it return; } subject.OnNext(new Device(args, device)); }
public async Task Reset() { var aqs = UsbDevice.GetDeviceSelector(VendorId, ProductId); var myDevices = await DeviceInformation.FindAllAsync(aqs); if (myDevices.Count > 0) { _targetDevice = await UsbDevice.FromIdAsync(myDevices[0].Id); if (_targetDevice != null) { GetInterfaces(); } } }
/// <summary> /// Finds the first enumerated device, attempts to open it, and starts updating the firmare. /// /// The device must be opened and closed before starting the background task because we must get permission from /// the user (the consent prompt) in the UI or else the background task will not be able to open the device. /// </summary> /// <returns></returns> private async Task UpdateFirmwareForFirstEnumeratedDeviceAsync() { DeviceInformation deviceToDoFirmwareUpdate = await FindFirstSuperMuttDeviceAsync(); String firmwareStatusMessage = null; if (deviceToDoFirmwareUpdate != null) { // Open device here and get permission from the user var usbDevice = await UsbDevice.FromIdAsync(deviceToDoFirmwareUpdate.Id); if (usbDevice != null) { // Firmware version before update (for the SuperMutt, the device revision is the firmware version) var oldFirmwareVersion = "0x" + usbDevice.DeviceDescriptor.BcdDeviceRevision.ToString("X4", NumberFormatInfo.InvariantInfo); UpdateOldFirmwareVersionInUI(oldFirmwareVersion); // After getting permission, we need to close the device so that the background task can open // the device. See comment for the function StartFirmwareForDeviceAsync(). usbDevice.Dispose(); usbDevice = null; // Create a background task for the firmware update RegisterForFirmwareUpdateBackgroundTask(); // Triggers the background task to update. firmwareStatusMessage = await StartFirmwareForDeviceAsync(deviceToDoFirmwareUpdate); } else { firmwareStatusMessage = "Could not open the device"; } } else { firmwareStatusMessage = "No supported devices found"; } // The firmware should be updating now, if not something went wrong if (isUpdatingFirmware) { rootPage.NotifyUser("Updating firmware...", NotifyType.StatusMessage); } else { rootPage.NotifyUser("Unable to update firmware: " + firmwareStatusMessage, NotifyType.ErrorMessage); } }
private async void OnDeviceAdded(DeviceWatcher watcher, DeviceInformation deviceInformation) { if (deviceInformation.Name.StartsWith("acA1920-40um") && deviceInformation.IsEnabled) { _targetDevice = await UsbDevice.FromIdAsync(deviceInformation.Id); foreach (var interf in _targetDevice.Configuration.UsbInterfaces) { if (interf.InterfaceNumber == 0) { _controlInPipe = interf.BulkInPipes[0]; _controlOutPipe = interf.BulkOutPipes[0]; } else if (interf.InterfaceNumber == 2) _streamInPipe = interf.BulkInPipes[0]; } OnConnected(EventArgs.Empty); } }
private void buttonDeviceSelect_Click(object sender, RoutedEventArgs e) { // No device selected. if (this.comboBoxDevices.SelectedIndex == -1) { return; } var dispatcher = this.Dispatcher; var deviceId = (this.comboBoxDevices.SelectedItem as UsbDeviceComboBoxItem).Id; var deviceName = (this.comboBoxDevices.SelectedItem as UsbDeviceComboBoxItem).Content as String; UsbDevice.FromIdAsync(deviceId).Completed = new AsyncOperationCompletedHandler <UsbDevice>(async(op, status) => { var usbDevice = op.GetResults(); var serialport = await UsbCdcControlAccess.UsbSerialPort.CreateAsync(usbDevice); if (serialport == null) { await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, new Windows.UI.Core.DispatchedHandler(() => { SDKTemplate.MainPage.Current.NotifyUser(deviceName + " is not compatible with CDC ACM.", SDKTemplate.NotifyType.ErrorMessage); })); if (usbDevice != null) { usbDevice.Dispose(); } return; } UsbCdcControl.UsbDeviceList.Singleton.Add(new UsbCdcControl.UsbSerialPortInfo(serialport, deviceId, deviceName)); await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, new Windows.UI.Core.DispatchedHandler(() => { this.comboBoxDevices.IsEnabled = false; this.buttonDeviceSelect.IsEnabled = false; this.buttonInitialize.IsEnabled = true; this.buttonDeviceDeselect.IsEnabled = true; SDKTemplate.MainPage.Current.NotifyUser("", SDKTemplate.NotifyType.ErrorMessage); })); }); }
public async Task <bool> OpenAsync() { if (IsOpen) { return(true); // we're already open } // Calling this will "open" the device, blocking any other app from using it. // This will return null if another program already has the device open. usbDevice = await UsbDevice.FromIdAsync(DevicePath); if (usbDevice == null) { return(false); } cts = new CancellationTokenSource(); // https://msdn.microsoft.com/en-us/library/windows/hardware/dn303346(v=vs.85).aspx Version = (ushort)usbDevice.DeviceDescriptor.BcdDeviceRevision; pinConfigPipe = usbDevice.DefaultInterface.BulkOutPipes[0]; peripheralOutPipe = usbDevice.DefaultInterface.BulkOutPipes[1]; pinConfigWriter = new DataWriter(pinConfigPipe.OutputStream); peripheralWriter = new DataWriter(peripheralOutPipe.OutputStream); pinEventPipe = usbDevice.DefaultInterface.BulkInPipes[0]; pinEventReader = new DataReader(pinEventPipe.InputStream); peripheralInPipe = usbDevice.DefaultInterface.BulkInPipes[1]; peripheralReader = new DataReader(peripheralInPipe.InputStream); IsOpen = true; pinEventListerner(cts.Token); Debug.WriteLine("Connection opened"); return(true); }
/// <summary> /// This method opens the device using the WinRT Usb API. After the device is opened, save the device /// so that it can be used across scenarios. /// /// It is important that the FromIdAsync call is made on the UI thread because the consent prompt can only be displayed /// on the UI thread. /// /// This method is used to reopen the device after the device reconnects to the computer and when the app resumes. /// </summary> /// <param name="deviceInfo">Device information of the device to be opened</param> /// <param name="deviceSelector">The AQS used to find this device</param> /// <returns>True if the device was successfully opened, false if the device could not be opened for well known reasons. /// An exception may be thrown if the device could not be opened for extraordinary reasons.</returns> public async Task <Boolean> OpenDeviceAsync(DeviceInformation deviceInfo, String deviceSelector) { device = await UsbDevice.FromIdAsync(deviceInfo.Id); Boolean successfullyOpenedDevice = false; NotifyType notificationStatus; String notificationMessage = null; // Device could have been blocked by user or the device has already been opened by another app. if (device != null) { successfullyOpenedDevice = true; deviceInformation = deviceInfo; this.deviceSelector = deviceSelector; notificationStatus = NotifyType.StatusMessage; notificationMessage = "Device " + deviceInformation.Id + " opened"; // Notify registered callback handle that the device has been opened if (deviceConnectedCallback != null) { deviceConnectedCallback(this, deviceInformation); } // Background tasks are not part of the app, so app events will not have an affect on the device if (!isBackgroundTask && (appSuspendEventHandler == null || appResumeEventHandler == null)) { RegisterForAppEvents(); } // User can block the device after it has been opened in the Settings charm. We can detect this by registering for the // DeviceAccessInformation.AccessChanged event if (deviceAccessEventHandler == null) { RegisterForDeviceAccessStatusChange(); } // Create and register device watcher events for the device to be opened unless we're reopening the device if (deviceWatcher == null) { deviceWatcher = DeviceInformation.CreateWatcher(deviceSelector); RegisterForDeviceWatcherEvents(); } if (!watcherStarted) { // Start the device watcher after we made sure that the device is opened. StartDeviceWatcher(); } } else { successfullyOpenedDevice = false; notificationStatus = NotifyType.ErrorMessage; var deviceAccessStatus = DeviceAccessInformation.CreateFromId(deviceInfo.Id).CurrentStatus; switch (deviceAccessStatus) { case DeviceAccessStatus.DeniedByUser: notificationMessage = "Access to the device was blocked by the user : "******"Access to the device was blocked by the system : " + deviceInfo.Id; break; default: // Most likely the device is opened by another app, but cannot be sure notificationMessage = "Unknown error, possibly opened by another app : " + deviceInfo.Id; break; } } MainPage.Current.NotifyUser(notificationMessage, notificationStatus); return(successfullyOpenedDevice); }
/// <summary> /// Opens device and assigns member variable to the newly opened device /// </summary> /// <returns></returns> private async Task OpenDeviceAsync() { device = await UsbDevice.FromIdAsync(deviceServicingDetails.DeviceId).AsTask(cancellationTokenSource.Token); }
private void buttonInitialize_Click(object sender, RoutedEventArgs e) { if (this.comboBoxDevices1.SelectedIndex == -1 || this.comboBoxDevices2.SelectedIndex == -1) { return; } var dispatcher = this.Dispatcher; var deviceId1 = (this.comboBoxDevices1.SelectedItem as UsbDeviceComboBoxItem).DeviceId; var deviceId2 = (this.comboBoxDevices2.SelectedItem as UsbDeviceComboBoxItem).DeviceId; var deviceName1 = (this.comboBoxDevices1.SelectedItem as UsbDeviceComboBoxItem).DeviceName; var deviceName2 = (this.comboBoxDevices2.SelectedItem as UsbDeviceComboBoxItem).DeviceName; var dteRate = uint.Parse(this.textBoxDTERate.Text); var parity = (Parity)this.comboBoxParityType.SelectedIndex; var dataBits = int.Parse((this.comboBoxDataBits.SelectedItem as ComboBoxItem).Content.ToString()); var charFormat = (StopBits)this.comboBoxCharFormat.SelectedIndex; var dtr = this.comboBoxDTR.SelectedIndex != 0; var rts = this.comboBoxRTS.SelectedIndex != 0; var createSerialPortTasks = new List <System.Threading.Tasks.Task>(); UsbDeviceInfo[] deviceInfos = { new UsbDeviceInfo(deviceId1, deviceName1), new UsbDeviceInfo(deviceId2, deviceName2) }; foreach (var deviceInfo in deviceInfos) { var fromIdAsyncOp = UsbDevice.FromIdAsync(deviceInfo.Id); createSerialPortTasks.Add(System.Threading.Tasks.TaskExtensions.Unwrap(System.Threading.Tasks.Task.Run(async() => { var usbDevice = await fromIdAsyncOp; var port = await UsbCdcControlAccess.UsbSerialPort.CreateAsync(usbDevice); if (port == null) { if (usbDevice != null) { usbDevice.Dispose(); } // Return a dummy task. return(System.Threading.Tasks.Task.Delay(0)); } var addToListTask = dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, new Windows.UI.Core.DispatchedHandler(() => { UsbCdcControl.UsbDeviceList.Singleton.Add(new UsbCdcControl.UsbSerialPortInfo(port, deviceInfo.Id, deviceInfo.Name)); })); await port.Open(dteRate, parity, dataBits, charFormat); // DtrEnable await port.DtrEnable_set(dtr); // RtsEnable await port.RtsEnable_set(rts); return(addToListTask.AsTask()); }))); } var uiSyncContext = System.Threading.Tasks.TaskScheduler.FromCurrentSynchronizationContext(); System.Threading.Tasks.Task.WhenAll(createSerialPortTasks).ContinueWith((task) => { if (task.Exception != null) { // Close all devices because some devices failed to be opened. UsbCdcControl.UsbDeviceList.Singleton.DisposeAll(); // Throw the exception. System.Threading.SynchronizationContext.Current.Post((state) => { throw state as Exception; } , task.Exception.GetBaseException()); } else if (this.SerialPortInfo1 != null && this.SerialPortInfo2 != null) { this.buttonLoopbackTest.IsEnabled = true; this.buttonInitialize.IsEnabled = false; SDKTemplate.MainPage.Current.NotifyUser("Initialized.", SDKTemplate.NotifyType.StatusMessage); } else { String deviceNumber; if (this.SerialPortInfo1 == null) { if (this.SerialPortInfo2 == null) { deviceNumber = "Both devices"; } else { deviceNumber = "Device 1"; } } else { deviceNumber = "Device 2"; } SDKTemplate.MainPage.Current.NotifyUser(deviceNumber + " failed to be initialized.", SDKTemplate.NotifyType.ErrorMessage); // Close all devices because some devices failed to be opened. UsbCdcControl.UsbDeviceList.Singleton.DisposeAll(); } } , uiSyncContext); }
private async void Main_Loaded(object sender, RoutedEventArgs e) { try { AvailableCameras.Clear(); var cameras = await PhotoHelper.GetAvailableCameras(true); foreach (var c in cameras) { AvailableCameras.Add(c); } await ConfigureCamera(); ushort vendorId = 0x19AB; ushort productId = 0x2000; //ushort vendorId = 0x203A; //ushort productId = 0xFFF9; // var aqs = UsbDevice.GetDeviceSelector(vendorId, productId, Guid.Parse("{ca3e7ab9-b4c3-4ae6-8251-579ef933890f}")); //var selector = "System.Devices.InterfaceClassGuid:=\"" + "{ca3e7ab9-b4c3-4ae6-8251-579ef933890f}"+ "\""; // + " AND System.Devices.InterfaceEnabled:=System.StructuredQueryType.Boolean#True"; // var myDevices = await DeviceInformation.FindAllAsync(aqs,null); //UsbDevice device = await UsbDevice.FromIdAsync(myDevices[0].Id); //var dev = interfaces.Where(x => x.Name.Contains("scope")).FirstOrDefault(); var devices = await DeviceInformation.FindAllAsync(DeviceClass.VideoCapture); var device = devices[1]; //var mydevice = await UsbDevice.FromIdAsync(device); var mydevice = await UsbDevice.FromIdAsync(device.Id); ////If this is a scope screen, enable the button click event from the scope // //Bodelin Scope - HID // ushort vendorId = 0x19AB; // var productIdList = new List<ushort> { 0x1000, 0x1020, 0x2000 }; // ushort usageId = 1; // ushort usagePage = 65440; // foreach (ushort productId in productIdList) // { // string selector = HidDevice.GetDeviceSelector(usagePage, usageId, vendorId, productId); // var myDevices = await DeviceInformation.FindAllAsync(selector); // if (myDevices.Any()) // { // _proscopeHidDevice = await HidDevice.FromIdAsync(myDevices[0].Id, FileAccessMode.Read); // var status = DeviceAccessInformation.CreateFromId(myDevices[0].Id).CurrentStatus; // if (_proscopeHidDevice != null) // { // _proscopeHidDevice.InputReportReceived += ProScopeClicked; // break; // } // } // } } catch { throw; } }