/// <summary>
/// Stops all device watchers.
/// </summary>
private void StopDeviceWatchersInternal()
{
if (_deviceWatcher.Status == DeviceWatcherStatus.Started)
{
_deviceWatcher.Stop();
while (_deviceWatcher.Status != DeviceWatcherStatus.Stopped)
{
Thread.Sleep(100);
}
}
// Clear the list of devices so we don't have potentially disconnected devices around
ClearDeviceEntries();
// also clear nanoFramework devices list
var devicesToRemove = _networkNanoFrameworkDevices.Select(nanoDevice => nanoDevice.DeviceId).ToList();
foreach (var deviceId in devicesToRemove)
{
// get device...
var device = FindNanoFrameworkDevice(deviceId);
// ... and remove it from collection
NanoFrameworkDevices.Remove(device);
device?.DebugEngine?.StopProcessing();
device?.DebugEngine?.Stop(true);
}
_watchersStarted = false;
}
/// <summary>
/// Creates a DeviceListEntry for a device and adds it to the list of devices
/// </summary>
/// <param name="deviceInformation">DeviceInformation on the device to be added to the list</param>
/// <param name="deviceSelector">The AQS used to find this device</param>
private async void AddDeviceToList(DeviceInformation deviceInformation, String deviceSelector)
{
// search the device list for a device with a matching interface ID
var usbMatch = FindDevice(deviceInformation.Id);
OnLogMessageAvailable(NanoDevicesEventSource.Log.CandidateDevice(deviceInformation.Id));
// Add the device if it's new
if (usbMatch == null)
{
UsbDevices.Add(new UsbDeviceInformation(deviceInformation, deviceSelector));
// search the NanoFramework device list for a device with a matching interface ID
var nanoFrameworkDeviceMatch = FindNanoFrameworkDevice(deviceInformation.Id);
if (nanoFrameworkDeviceMatch == null)
{
// Create a new element for this device interface, and queue up the query of its
// device information
var newNanoFrameworkDevice = new NanoDevice <NanoUsbDevice>();
//newMFDevice.DeviceInformation = new UsbDeviceInformation(deviceInformation, deviceSelector);
newNanoFrameworkDevice.Device.DeviceInformation = new UsbDeviceInformation(deviceInformation, deviceSelector);
newNanoFrameworkDevice.Parent = this;
newNanoFrameworkDevice.Transport = TransportType.Usb;
// Add the new element to the end of the list of devices
NanoFrameworkDevices.Add(newNanoFrameworkDevice as NanoDeviceBase);
// now fill in the description
// try opening the device to read the descriptor
if (await ConnectUsbDeviceAsync(newNanoFrameworkDevice.Device.DeviceInformation))
{
// the device description format is kept to maintain backwards compatibility
newNanoFrameworkDevice.Description = EventHandlerForUsbDevice.Current.DeviceInformation.Name + "_" + await GetDeviceDescriptor(5);
NanoDevicesEventSource.Log.ValidDevice(newNanoFrameworkDevice.Description + " @ " + newNanoFrameworkDevice.Device.DeviceInformation.DeviceSelector);
// done here, close device
EventHandlerForUsbDevice.Current.CloseDevice();
}
else
{
// couldn't open device, better remove it from the lists
NanoFrameworkDevices.Remove(newNanoFrameworkDevice as NanoDeviceBase);
UsbDevices.Remove(newNanoFrameworkDevice.Device.DeviceInformation);
NanoDevicesEventSource.Log.QuitDevice(deviceInformation.Id);
// can't do anything with this one, better dispose it
newNanoFrameworkDevice.Dispose();
}
}
else
{
// this NanoFramework device is already on the list
}
}
}
private NanoDeviceBase FindNanoFrameworkDevice(string deviceId)
{
if (deviceId != null)
{
// SerialMatch.Device.DeviceInformation
return(NanoFrameworkDevices.FirstOrDefault(d => ((d as NanoDevice <NanoSerialDevice>).DeviceId) == deviceId));
}
return(null);
}
private NanoDeviceBase FindNanoFrameworkDevice(string deviceId)
{
if (deviceId != null)
{
// usbMatch.Device.DeviceInformation
return(NanoFrameworkDevices.FirstOrDefault(d => ((d as NanoDevice <NanoUsbDevice>).Device.DeviceInformation as UsbDeviceInformation).DeviceInformation.Id == deviceId));
}
return(null);
}
private void OnDeviceEnumerationComplete(DeviceWatcher sender, object args)
{
// add another device watcher completed
deviceWatchersCompletedCount++;
if (deviceWatchersCompletedCount == mapDeviceWatchersToDeviceSelector.Count)
{
// prepare a list of devices that are to be removed if they are deemed as not valid nanoFramework devices
var devicesToRemove = new List <NanoDeviceBase>();
foreach (NanoDeviceBase device in NanoFrameworkDevices)
{
// connect to the device (as Task to get rid of the await)
var connectTask = ConnectDeviceAsync(device);
if (connectTask.Result)
{
var checkValidNFDeviceTask = CheckValidNanoFrameworkSerialDeviceAsync();
if (!checkValidNFDeviceTask.Result)
{
// mark this device for removal
devicesToRemove.Add(device);
device.StartCountdownForDispose();
}
else
{
Debug.WriteLine($"New Serial device: {device.Description} {(((NanoDevice<NanoSerialDevice>)device).Device.DeviceInformation.DeviceInformation.Id)}");
}
// done here, disconnect from the device now
((NanoDevice <NanoSerialDevice>)device).Disconnect();
}
else
{
// couldn't open device
// mark this device for removal
devicesToRemove.Add(device);
}
}
// remove device form nanoFramework device collection (force Linq to execute with call to Count())
devicesToRemove.Select(d => NanoFrameworkDevices.Remove(d)).Count();
// all watchers have completed enumeration
isAllDevicesEnumerated = true;
Debug.WriteLine($"Serial device enumeration completed. Found {NanoFrameworkDevices.Count} devices");
// fire event that Serial enumeration is complete
OnDeviceEnumerationCompleted();
}
}
public override void DisposeDevice(string instanceId)
{
var deviceToDispose = NanoFrameworkDevices.FirstOrDefault(nanoDevice => ((NanoDevice <NanoSerialDevice>)nanoDevice).DeviceId == instanceId);
if (deviceToDispose != null)
{
Task.Run(() =>
{
((NanoDevice <NanoSerialDevice>)deviceToDispose).Dispose();
});
}
}
private void RemoveDeviceFromList(string deviceId)
{
// Removes the device entry from the internal list; therefore the UI
var deviceEntry = FindDevice(deviceId);
NanoDevicesEventSource.Log.DeviceDeparture(deviceId);
UsbDevices.Remove(deviceEntry);
// get device
var device = FindNanoFrameworkDevice(deviceId);
// yes, remove it from collection
NanoFrameworkDevices.Remove(device);
device = null;
}
private void OnPortNanoFrameworkDevicesOnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Reset:
NanoFrameworkDevices.Clear();
break;
case NotifyCollectionChangedAction.Add:
e.NewItems.Cast <NanoDeviceBase>().ToList().ForEach(d => NanoFrameworkDevices.Add(d));
break;
case NotifyCollectionChangedAction.Remove:
e.OldItems.Cast <NanoDeviceBase>().ToList().ForEach(d => NanoFrameworkDevices.Remove(d));
break;
}
}
private void RemoveDeviceFromList(NetworkDeviceInformation networkDevice)
{
// Removes the device entry from the internal list; therefore the UI
var deviceEntry = FindDevice(networkDevice.DeviceId);
OnLogMessageAvailable(NanoDevicesEventSource.Log.DeviceDeparture(networkDevice.DeviceId));
_networkDevices.Remove(deviceEntry);
// get device...
var device = FindNanoFrameworkDevice(networkDevice.DeviceId);
// ... and remove it from collection
NanoFrameworkDevices.Remove(device);
device?.DebugEngine?.StopProcessing();
device?.DebugEngine?.Dispose();
}
private NanoDeviceBase FindNanoFrameworkDevice(string deviceId)
{
if (deviceId != null)
{
// SerialMatch.Device.DeviceInformation
var device = NanoFrameworkDevices.FirstOrDefault(d => ((d as NanoDevice <NanoSerialDevice>).Device.DeviceInformation as SerialDeviceInformation).DeviceInformation.Id == deviceId);
if (device == null)
{
// try now in tentative list
return(_tentativeNanoFrameworkDevices.FirstOrDefault(d => ((d as NanoDevice <NanoSerialDevice>).Device.DeviceInformation as SerialDeviceInformation).DeviceInformation.Id == deviceId));
}
else
{
return(device);
}
}
return(null);
}
private void OnDeviceEnumerationComplete(DeviceWatcher sender, object args)
{
// add another device watcher completed
_deviceWatchersCompletedCount++;
if (_deviceWatchersCompletedCount == _mapDeviceWatchersToDeviceSelector.Count)
{
Task.Factory.StartNew(async() =>
{
// prepare a list of devices that are to be removed if they are deemed as not valid nanoFramework devices
var devicesToRemove = new List <NanoDeviceBase>();
foreach (NanoDeviceBase device in _tentativeNanoFrameworkDevices)
{
var nFDeviceIsValid = await CheckValidNanoFrameworkSerialDeviceAsync(((NanoDevice <NanoSerialDevice>)device).Device.DeviceInformation).ConfigureAwait(true);
if (nFDeviceIsValid)
{
OnLogMessageAvailable(NanoDevicesEventSource.Log.ValidDevice($"{device.Description} {(((NanoDevice<NanoSerialDevice>)device).Device.DeviceInformation.DeviceInformation.Id)}"));
NanoFrameworkDevices.Add(device);
}
else
{
OnLogMessageAvailable(NanoDevicesEventSource.Log.QuitDevice(((NanoDevice <NanoSerialDevice>)device).Device.DeviceInformation.DeviceInformation.Id));
}
}
// all watchers have completed enumeration
IsDevicesEnumerationComplete = true;
// clean list of tentative nanoFramework Devices
_tentativeNanoFrameworkDevices.Clear();
OnLogMessageAvailable(NanoDevicesEventSource.Log.SerialDeviceEnumerationCompleted(NanoFrameworkDevices.Count));
// fire event that Serial enumeration is complete
OnDeviceEnumerationCompleted();
}).FireAndForget();
}
}
private void RemoveDeviceFromList(string deviceId)
{
// Removes the device entry from the internal list; therefore the UI
var deviceEntry = FindDevice(deviceId);
Debug.WriteLine("USB device removed: " + deviceId);
UsbDevices.Remove(deviceEntry);
// start thread to dispose and remove device from collection if it doesn't enumerate again in 2 seconds
Task.Factory.StartNew(() =>
{
// get device
var device = FindNanoFrameworkDevice(deviceId);
if (device != null)
{
// set device to dispose if it doesn't come back in 2 seconds
device.StartCountdownForDispose();
// hold here for the same time as the default timer of the dispose timer
new ManualResetEvent(false).WaitOne(TimeSpan.FromSeconds(2.5));
// check is object was disposed
if ((device as NanoDevice <NanoUsbDevice>).KillFlag)
{
// yes, remove it from collection
NanoFrameworkDevices.Remove(device);
Debug.WriteLine("Removing device " + device.Description);
device = null;
}
}
});
}
/// <summary>
/// Creates a DeviceListEntry for a device and adds it to the list of devices
/// </summary>
/// <param name="deviceInformation">DeviceInformation on the device to be added to the list</param>
/// <param name="deviceSelector">The AQS used to find this device</param>
private async void AddDeviceToList(DeviceInformation deviceInformation, String deviceSelector)
{
// search the device list for a device with a matching interface ID
var usbMatch = FindDevice(deviceInformation.Id);
Debug.WriteLine("New USB device: " + deviceInformation.Id);
// Add the device if it's new
if (usbMatch == null)
{
UsbDevices.Add(new UsbDeviceInformation(deviceInformation, deviceSelector));
// search the NanoFramework device list for a device with a matching interface ID
var nanoFrameworkDeviceMatch = FindNanoFrameworkDevice(deviceInformation.Id);
if (nanoFrameworkDeviceMatch == null)
{
// Create a new element for this device interface, and queue up the query of its
// device information
var newNanoFrameworkDevice = new NanoDevice <NanoUsbDevice>();
//newMFDevice.DeviceInformation = new UsbDeviceInformation(deviceInformation, deviceSelector);
newNanoFrameworkDevice.Device.DeviceInformation = new UsbDeviceInformation(deviceInformation, deviceSelector);
newNanoFrameworkDevice.Parent = this;
newNanoFrameworkDevice.DebugEngine = new Engine(this, newNanoFrameworkDevice);
newNanoFrameworkDevice.Transport = TransportType.Usb;
// Add the new element to the end of the list of devices
NanoFrameworkDevices.Add(newNanoFrameworkDevice as NanoDeviceBase);
// now fill in the description
// try opening the device to read the descriptor
if (await ConnectUsbDeviceAsync(newNanoFrameworkDevice.Device.DeviceInformation).ConfigureAwait(false))
{
// the device description format is kept to maintain backwards compatibility
newNanoFrameworkDevice.Description = EventHandlerForUsbDevice.Current.DeviceInformation.Name + "_" + await GetDeviceDescriptor(5).ConfigureAwait(false);
Debug.WriteLine("Add new nanoFramework device to list: " + newNanoFrameworkDevice.Description + " @ " + newNanoFrameworkDevice.Device.DeviceInformation.DeviceSelector);
// done here, close device
EventHandlerForUsbDevice.Current.CloseDevice();
}
else
{
// couldn't open device, better remove it from the lists
NanoFrameworkDevices.Remove(newNanoFrameworkDevice as NanoDeviceBase);
UsbDevices.Remove(newNanoFrameworkDevice.Device.DeviceInformation);
}
}
else
{
// this NanoFramework device is already on the list
// stop the dispose countdown!
nanoFrameworkDeviceMatch.StopCountdownForDispose();
// set port parent
//(mfDeviceMatch as MFDevice<MFUsbDevice>).Device.Parent = this;
//// instantiate a debug engine
//(mfDeviceMatch as MFDevice<MFUsbDevice>).Device.DebugEngine = new Engine(this, (mfDeviceMatch as MFDevice<MFUsbDevice>));
}
}
}
/// <summary>
/// Creates a DeviceListEntry for a device and adds it to the list of devices
/// </summary>
/// <param name="deviceInformation">DeviceInformation on the device to be added to the list</param>
/// <param name="deviceSelector">The AQS used to find this device</param>
private async void AddDeviceToList(DeviceInformation deviceInformation, String deviceSelector)
{
// search the device list for a device with a matching interface ID
var serialMatch = FindDevice(deviceInformation.Id);
// Add the device if it's new
if (serialMatch == null)
{
SerialDevices.Add(new SerialDeviceInformation(deviceInformation, deviceSelector));
// search the NanoFramework device list for a device with a matching interface ID
var nanoFrameworkDeviceMatch = FindNanoFrameworkDevice(deviceInformation.Id);
if (nanoFrameworkDeviceMatch == null)
{
// Create a new element for this device interface, and queue up the query of its
// device information
var newNanoFrameworkDevice = new NanoDevice <NanoSerialDevice>();
newNanoFrameworkDevice.Device.DeviceInformation = new SerialDeviceInformation(deviceInformation, deviceSelector);
newNanoFrameworkDevice.Parent = this;
newNanoFrameworkDevice.DebugEngine = new Engine(this, newNanoFrameworkDevice);
newNanoFrameworkDevice.Transport = TransportType.Serial;
// Add the new element to the end of the list of devices
NanoFrameworkDevices.Add(newNanoFrameworkDevice as NanoDeviceBase);
// perform check for valid nanoFramework device is this is not the initial enumeration
if (isAllDevicesEnumerated)
{
// try opening the device to check for a valid nanoFramework device
if (await ConnectSerialDeviceAsync(newNanoFrameworkDevice.Device.DeviceInformation).ConfigureAwait(false))
{
Debug.WriteLine("New Serial device: " + deviceInformation.Id);
var name = EventHandlerForSerialDevice.Current.DeviceInformation?.Properties["System.ItemNameDisplay"] as string;
// acceptable names
if (name == "STM32 STLink")
{
// now fill in the description
newNanoFrameworkDevice.Description = name + " @ " + EventHandlerForSerialDevice.Current.Device.PortName;
Debug.WriteLine("Add new nanoFramework device to list: " + newNanoFrameworkDevice.Description + " @ " + newNanoFrameworkDevice.Device.DeviceInformation.DeviceSelector);
}
// done here, close the device
EventHandlerForSerialDevice.Current.CloseDevice();
return;
}
// couldn't open device better remove it from the collection right away
NanoFrameworkDevices.Remove(newNanoFrameworkDevice as NanoDeviceBase);
}
}
else
{
// this NanoFramework device is already on the list
// stop the dispose countdown!
nanoFrameworkDeviceMatch.StopCountdownForDispose();
}
}
}
/// <summary>
/// Creates a DeviceListEntry for a device and adds it to the list of devices
/// </summary>
private void AddDeviceToListAsync(NetworkDeviceInformation networkDevice)
{
// search the device list for a device with a matching interface ID
var networkMatch = FindDevice(networkDevice.DeviceId);
// Add the device if it's new
if (networkMatch != null)
{
return;
}
OnLogMessageAvailable(NanoDevicesEventSource.Log.CandidateDevice(networkDevice.DeviceId));
// search the nanoFramework device list for a device with a matching interface ID
var nanoFrameworkDeviceMatch = FindNanoFrameworkDevice(networkDevice.DeviceId);
if (nanoFrameworkDeviceMatch != null)
{
return;
}
// Create a new element for this device and...
var newNanoFrameworkDevice = new NanoDevice <NanoNetworkDevice>();
newNanoFrameworkDevice.DeviceId = networkDevice.DeviceId;
newNanoFrameworkDevice.ConnectionPort = new PortTcpIp(this, newNanoFrameworkDevice, networkDevice);
newNanoFrameworkDevice.Transport = TransportType.TcpIp;
var connectResult = newNanoFrameworkDevice.ConnectionPort.ConnectDevice();
if (connectResult == ConnectPortResult.Unauthorized)
{
OnLogMessageAvailable(
NanoDevicesEventSource.Log.UnauthorizedAccessToDevice(networkDevice.DeviceId));
}
else if (connectResult == ConnectPortResult.Connected)
{
if (CheckValidNanoFrameworkNetworkDevice(newNanoFrameworkDevice))
{
//add device to the collection
NanoFrameworkDevices.Add(newNanoFrameworkDevice);
_networkDevices.Add(networkDevice);
OnLogMessageAvailable(
NanoDevicesEventSource.Log.ValidDevice($"{newNanoFrameworkDevice.Description}"));
}
else
{
// disconnect
newNanoFrameworkDevice.Disconnect();
}
}
else
{
OnLogMessageAvailable(NanoDevicesEventSource.Log.QuitDevice(networkDevice.DeviceId));
}
// subtract devices count
_newDevicesCount--;
// check if we are done processing arriving devices
if (_newDevicesCount == 0)
{
ProcessDeviceEnumerationComplete();
}
}
/// <summary>
/// Creates a DeviceListEntry for a device and adds it to the list of devices
/// </summary>
/// <param name="deviceInformation">DeviceInformation on the device to be added to the list</param>
/// <param name="deviceSelector">The AQS used to find this device</param>
private async void AddDeviceToList(DeviceInformation deviceInformation, String deviceSelector)
{
// device black listed
// discard known system and unusable devices
//
if (
deviceInformation.Id.StartsWith(@"\\?\ACPI") ||
// reported in https://github.com/nanoframework/Home/issues/332
// COM ports from Broadcom 20702 Bluetooth adapter
deviceInformation.Id.Contains(@"VID_0A5C+PID_21E1") ||
// reported in https://nanoframework.slack.com/archives/C4MGGBH1P/p1531660736000055?thread_ts=1531659631.000021&cid=C4MGGBH1P
// COM ports from Broadcom 20702 Bluetooth adapter
deviceInformation.Id.Contains(@"VID&00010057_PID&0023")
)
{
OnLogMessageAvailable(NanoDevicesEventSource.Log.DroppingBlackListedDevice(deviceInformation.Id));
// don't even bother with these
return;
}
OnLogMessageAvailable(NanoDevicesEventSource.Log.DeviceArrival(deviceInformation.Id));
// search the device list for a device with a matching interface ID
var serialMatch = FindDevice(deviceInformation.Id);
// Add the device if it's new
if (serialMatch == null)
{
var serialDevice = new SerialDeviceInformation(deviceInformation, deviceSelector);
_serialDevices.Add(serialDevice);
OnLogMessageAvailable(NanoDevicesEventSource.Log.CandidateDevice(deviceInformation.Id));
// search the nanoFramework device list for a device with a matching interface ID
var nanoFrameworkDeviceMatch = FindNanoFrameworkDevice(deviceInformation.Id);
if (nanoFrameworkDeviceMatch == null)
{
// Create a new element for this device and...
var newNanoFrameworkDevice = new NanoDevice <NanoSerialDevice>();
newNanoFrameworkDevice.Device.DeviceInformation = new SerialDeviceInformation(deviceInformation, deviceSelector);
newNanoFrameworkDevice.Parent = this;
newNanoFrameworkDevice.Transport = TransportType.Serial;
// ... add it to the collection of tentative devices
_tentativeNanoFrameworkDevices.Add(newNanoFrameworkDevice as NanoDeviceBase);
// perform check for valid nanoFramework device is this is not the initial enumeration
if (IsDevicesEnumerationComplete)
{
if (await CheckValidNanoFrameworkSerialDeviceAsync(newNanoFrameworkDevice.Device.DeviceInformation))
{
// the device info was updated above, need to get it from the tentative devices collection
//add device to the collection
NanoFrameworkDevices.Add(FindNanoFrameworkDevice(newNanoFrameworkDevice.Device.DeviceInformation.DeviceInformation.Id));
OnLogMessageAvailable(NanoDevicesEventSource.Log.ValidDevice($"{newNanoFrameworkDevice.Description} {newNanoFrameworkDevice.Device.DeviceInformation.DeviceInformation.Id}"));
// done here, clear tentative list
_tentativeNanoFrameworkDevices.Clear();
// done here
return;
}
// clear tentative list
_tentativeNanoFrameworkDevices.Clear();
OnLogMessageAvailable(NanoDevicesEventSource.Log.QuitDevice(deviceInformation.Id));
_serialDevices.Remove(serialDevice);
}
}
}
}
/// <summary>
/// Creates a DeviceListEntry for a device and adds it to the list of devices
/// </summary>
/// <param name="deviceInformation">DeviceInformation on the device to be added to the list</param>
/// <param name="deviceId">The AQS used to find this device</param>
private void AddDeviceToListAsync(String deviceId)
{
// search the device list for a device with a matching interface ID
var serialMatch = FindDevice(deviceId);
// Add the device if it's new
if (serialMatch == null)
{
var serialDevice = new SerialDeviceInformation(deviceId);
OnLogMessageAvailable(NanoDevicesEventSource.Log.CandidateDevice(deviceId));
// search the nanoFramework device list for a device with a matching interface ID
var nanoFrameworkDeviceMatch = FindNanoFrameworkDevice(deviceId);
if (nanoFrameworkDeviceMatch == null)
{
// Create a new element for this device and...
var newNanoFrameworkDevice = new NanoDevice <NanoSerialDevice>();
newNanoFrameworkDevice.DeviceId = deviceId;
newNanoFrameworkDevice.ConnectionPort = new PortSerial(this, newNanoFrameworkDevice);
newNanoFrameworkDevice.Transport = TransportType.Serial;
var connectResult = newNanoFrameworkDevice.ConnectionPort.ConnectDevice();
if (connectResult == ConnectPortResult.Unauthorized)
{
OnLogMessageAvailable(NanoDevicesEventSource.Log.UnauthorizedAccessToDevice(deviceId));
}
else if (connectResult == ConnectPortResult.Connected)
{
if (CheckValidNanoFrameworkSerialDevice(newNanoFrameworkDevice))
{
//add device to the collection
NanoFrameworkDevices.Add(newNanoFrameworkDevice);
_serialDevices.Add(serialDevice);
OnLogMessageAvailable(NanoDevicesEventSource.Log.ValidDevice($"{newNanoFrameworkDevice.Description}"));
}
else
{
// disconnect
newNanoFrameworkDevice.Disconnect();
// devices powered by the USB cable and that feature a serial converter (like an FTDI chip)
// are still booting when the USB enumeration event raises
// so need to give them enough time for the boot sequence to complete before trying to communicate with them
// Failing to connect to debugger engine on first attempt occurs frequently on dual USB devices like ESP32 WROVER KIT.
// Seems to be something related with both devices using the same USB endpoint
// Another reason is that an ESP32 takes around 3 seconds to complete the boot sequence and launch the CLR.
// Until then the device will look non responsive or invalid to the detection mechanism that we're using.
// A nice workaround for this seems to be adding an extra random wait so the comms are not simultaneous.
int delay;
lock (_delay)
{
delay = _delay.Next(200, 600);
}
Thread.Sleep(BootTime + delay);
OnLogMessageAvailable(NanoDevicesEventSource.Log.CheckingValidDevice($" {newNanoFrameworkDevice.DeviceId} *** 2nd attempt ***"));
connectResult = newNanoFrameworkDevice.ConnectionPort.ConnectDevice();
if (connectResult == ConnectPortResult.Unauthorized)
{
OnLogMessageAvailable(NanoDevicesEventSource.Log.UnauthorizedAccessToDevice(deviceId));
}
else if (connectResult == ConnectPortResult.Connected)
{
if (CheckValidNanoFrameworkSerialDevice(newNanoFrameworkDevice, true))
{
//add device to the collection
NanoFrameworkDevices.Add(newNanoFrameworkDevice);
_serialDevices.Add(serialDevice);
OnLogMessageAvailable(NanoDevicesEventSource.Log.ValidDevice($"{newNanoFrameworkDevice.Description}"));
}
else
{
OnLogMessageAvailable(NanoDevicesEventSource.Log.QuitDevice(deviceId));
}
}
else
{
OnLogMessageAvailable(NanoDevicesEventSource.Log.QuitDevice(deviceId));
}
}
}
else
{
OnLogMessageAvailable(NanoDevicesEventSource.Log.QuitDevice(deviceId));
}
// subtract devices count
lock (_newDevicesCountLock)
{
_newDevicesCount--;
}
// check if we are done processing arriving devices
if (_newDevicesCount == 0)
{
ProcessDeviceEnumerationComplete();
}
}
}
}
/// <summary>
/// Creates a DeviceListEntry for a device and adds it to the list of devices
/// </summary>
/// <param name="deviceInformation">DeviceInformation on the device to be added to the list</param>
/// <param name="deviceSelector">The AQS used to find this device</param>
private async void AddDeviceToList(DeviceInformation deviceInformation, String deviceSelector)
{
// search the device list for a device with a matching interface ID
var serialMatch = FindDevice(deviceInformation.Id);
// Add the device if it's new
if (serialMatch == null)
{
SerialDevices.Add(new SerialDeviceInformation(deviceInformation, deviceSelector));
// search the NanoFramework device list for a device with a matching interface ID
var nanoFrameworkDeviceMatch = FindNanoFrameworkDevice(deviceInformation.Id);
if (nanoFrameworkDeviceMatch == null)
{
// Create a new element for this device interface, and queue up the query of its
// device information
var newNanoFrameworkDevice = new NanoDevice <NanoSerialDevice>();
newNanoFrameworkDevice.Device.DeviceInformation = new SerialDeviceInformation(deviceInformation, deviceSelector);
newNanoFrameworkDevice.Parent = this;
newNanoFrameworkDevice.DebugEngine = new Engine(this, newNanoFrameworkDevice);
newNanoFrameworkDevice.Transport = TransportType.Serial;
// Add the new element to the end of the list of devices
NanoFrameworkDevices.Add(newNanoFrameworkDevice as NanoDeviceBase);
// perform check for valid nanoFramework device is this is not the initial enumeration
if (isAllDevicesEnumerated)
{
// try opening the device to check for a valid nanoFramework device
if (await ConnectSerialDeviceAsync(newNanoFrameworkDevice.Device.DeviceInformation))
{
Debug.WriteLine("New Serial device: " + deviceInformation.Id);
if (await CheckValidNanoFrameworkSerialDeviceAsync())
{
// done here, close the device
EventHandlerForSerialDevice.Current.CloseDevice();
// remove it from collection...
NanoFrameworkDevices.Remove(newNanoFrameworkDevice as NanoDeviceBase);
//... and add it again, otherwise the bindings might fail
NanoFrameworkDevices.Add(newNanoFrameworkDevice as NanoDeviceBase);
Debug.WriteLine("Add new nanoFramework device to list: " + newNanoFrameworkDevice.Description + " @ " + newNanoFrameworkDevice.Device.DeviceInformation.DeviceSelector);
return;
}
}
Debug.WriteLine($"Removing { deviceInformation.Id } from collection...");
// couldn't open device better remove it from the collection right away
NanoFrameworkDevices.Remove(newNanoFrameworkDevice as NanoDeviceBase);
// can't do anything with this one, better dispose it
newNanoFrameworkDevice.Dispose();
}
}
else
{
// this NanoFramework device is already on the list
// stop the dispose countdown!
nanoFrameworkDeviceMatch.StopCountdownForDispose();
}
}
}