public async Task InitializeVotumAsync()
{
WindowsHidDeviceFactory.Register(Logger, Tracer);
var deviceDefinitions = new List <FilterDeviceDefinition>
{
new FilterDeviceDefinition {
DeviceType = DeviceType.Hid, VendorId = 0x1fc9, ProductId = 0x80a6, Label = "VOTUM RF-HID Receiver"
},
};
var devices = await DeviceManager.Current.GetDevicesAsync(deviceDefinitions);
Device = devices.FirstOrDefault();
await Device.InitializeAsync();
var writeBuffer = new byte[64];
byte[] readBuffer;
while (true)
{
readBuffer = await Device.WriteAndReadAsync(writeBuffer);
if (readBuffer[8] > 0)
{
var record = new PacketRecord(readBuffer);
var resp = new Response(record);
await WriteAsync(resp);
continue;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="USBDeviceConnector"/> class.
/// </summary>
/// <param name="aggregator">Event Aggregator wired in from caliburn micro.</param>
public USBDeviceConnector(IEventAggregator aggregator)
{
this.EventAggregator = aggregator;
this.EventAggregator.SubscribeOnBackgroundThread(this);
WindowsHidDeviceFactory.Register(this.DeviceLogger, this.DeviceTracer);
this.SetupDeviceListener();
}
static async Task Run()
{
WindowsHidDeviceFactory.Register(null, null);
Settings.load("settings.cfg", ref settings);
TimeSpan sleepTime = TimeSpan.FromMilliseconds(3000);
Task <bool> keyboardTask = null, mouseTask = null;
int maxRetryCount = 20;
while (maxRetryCount >= 0)
{
if (keyboardTask == null || keyboardTask.IsCompleted)
{
keyboardTask = RunKeyboard();
}
if (mouseTask == null || mouseTask.IsCompleted)
{
mouseTask = RunMouse();
}
await Task.WhenAny(keyboardTask, mouseTask);
if ((keyboardTask.IsCompleted && !keyboardTask.Result) && (mouseTask.IsCompleted && !mouseTask.Result))
{
--maxRetryCount;
}
if (!mouseTask.IsCompleted || !mouseTask.Result)
{
await Task.Delay(sleepTime);
}
}
}
public static void Init()
{
WindowsHidDeviceFactory.Register(_logger, _tracer);
WindowsUsbDeviceFactory.Register(_logger, _tracer);
SearchDS5Controller();
}
public Keyboard()
{
DebugTracer tracer = new DebugTracer();
DebugLogger logger = new DebugLogger();
WindowsUsbDeviceFactory.Register(logger, tracer);
WindowsHidDeviceFactory.Register(logger, tracer);
}
public Footpedal()
{
WindowsUsbDeviceFactory.Register(_debugLogger, _debugTracer);
WindowsHidDeviceFactory.Register(_debugLogger, _debugTracer);
_deviceListener = new DeviceListener(_DeviceDefinitions, PollMilliseconds)
{
Logger = _debugLogger
};
}
protected override Task <TrezorManager> ConnectAsync()
{
//This only needs to be done once.
//Register the factory for creating Usb devices. Trezor One Firmware 1.7.x / Trezor Model T
WindowsUsbDeviceFactory.Register(new DebugLogger(), new DebugTracer());
//Register the factory for creating Hid devices. Trezor One Firmware 1.6.x
WindowsHidDeviceFactory.Register(new DebugLogger(), new DebugTracer());
return(base.ConnectAsync());
}
public UsbTransport()
{
#if (LIBUSB)
LibUsbUsbDeviceFactory.Register(Logger, Tracer);
#else
WindowsUsbDeviceFactory.Register(Logger, Tracer);
WindowsHidDeviceFactory.Register(Logger, Tracer);
#endif
Devices = new ObservableCollection <UsbDevice>();
UpdateDeviceList();
}
public async void Init()
{
//Register the factory for creating Usb devices. This only needs to be done once.
WindowsUsbDeviceFactory.Register();
WindowsHidDeviceFactory.Register();
//DeviceConnectionExample.StartListening();
DeviceConnectionExample.TrezorInitialized += _DeviceConnectionExample_TrezorInitialized;
DeviceConnectionExample.TrezorDisconnected += _DeviceConnectionExample_TrezorDisconnected;
await DeviceConnectionExample.InitializeTrezorAsync();
}
private static async Task <TrezorManager> ConnectAsync()
{
//This only needs to be done once.
//Register the factory for creating Usb devices. Trezor One Firmware 1.7.x / Trezor Model T
WindowsUsbDeviceFactory.Register(new DebugLogger(), new DebugTracer());
//Register the factory for creating Hid devices. Trezor One Firmware 1.6.x
WindowsHidDeviceFactory.Register(new DebugLogger(), new DebugTracer());
_TrezorManagerBroker = new TrezorManagerBroker(GetPin, GetPassphrase, 2000, new DefaultCoinUtility());
return(await _TrezorManagerBroker.WaitForFirstTrezorAsync());
}
private async static Task Go()
{
try
{
//Register the factory for creating Usb devices. This only needs to be done once.
WindowsUsbDeviceFactory.Register();
WindowsHidDeviceFactory.Register();
//Note: other custom device types could be added here
//Define the types of devices to search for. This particular device can be connected to via USB, or Hid
var deviceDefinitions = new List <DeviceDefinition>
{
new DeviceDefinition {
DeviceType = DeviceType.Hid, VendorId = 0x534C, ProductId = 0x0001, Label = "Trezor One Firmware 1.6.x"
},
new DeviceDefinition {
DeviceType = DeviceType.Usb, VendorId = 0x1209, ProductId = 0x53C1, ReadBufferSize = 64, WriteBufferSize = 64, Label = "Trezor One Firmware 1.7.x"
},
new DeviceDefinition {
DeviceType = DeviceType.Usb, VendorId = 0x1209, ProductId = 0x53C0, ReadBufferSize = 64, WriteBufferSize = 64, Label = "Model T"
}
};
//Get the first available device and connect to it
var devices = await DeviceManager.Current.GetDevices(deviceDefinitions);
using (var trezorDevice = devices.FirstOrDefault())
{
await trezorDevice.InitializeAsync();
//Create a buffer with 3 bytes (initialize)
var buffer = new byte[64];
buffer[0] = 0x3f;
buffer[1] = 0x23;
buffer[2] = 0x23;
//Write the data to the device and get the response
var readBuffer = await trezorDevice.WriteAndReadAsync(buffer);
Console.WriteLine("All good");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
private static async Task <KeepKeyManager> ConnectAsync()
{
//This only needs to be done once.
//Register the factory for creating Usb devices. Trezor One Firmware 1.7.x / Trezor Model T
WindowsUsbDeviceFactory.Register();
//Register the factory for creating Hid devices. Trezor One Firmware 1.6.x
WindowsHidDeviceFactory.Register();
var keepKeyManagerBroker = new KeepKeyManagerBroker(GetPin, GetPassphrase, 2000);
var keepKeyManager = await keepKeyManagerBroker.WaitForFirstTrezorAsync();
var coinTable = await keepKeyManager.GetCoinTable();
keepKeyManager.CoinUtility = new KeepKeyCoinUtility(coinTable);
return(keepKeyManager);
}
private static void Main(string[] args)
{
//Register the factory for creating Usb devices. This only needs to be done once.
#if (LIBUSB)
LibUsbUsbDeviceFactory.Register(Logger);
#else
WindowsUsbDeviceFactory.Register(Logger);
WindowsHidDeviceFactory.Register(Logger);
#endif
_DeviceConnectionExample.TrezorInitialized += _DeviceConnectionExample_TrezorInitialized;
_DeviceConnectionExample.TrezorDisconnected += _DeviceConnectionExample_TrezorDisconnected;
Go();
new ManualResetEvent(false).WaitOne();
}
static void Main(string[] args)
{
//Register the factory for creating Usb devices. This only needs to be done once.
WindowsUsbDeviceFactory.Register(null, null);
//Register the factory for creating Usb devices. This only needs to be done once.
WindowsHidDeviceFactory.Register(null, null);
//Search DualSense Controller
var DeviceSearcherTask = DeviceManager.Current.GetConnectedDeviceDefinitionsAsync(new FilterDeviceDefinition {
DeviceType = DeviceType.Hid, VendorId = 1356, ProductId = 3302
});
DeviceSearcherTask.Wait();
var DualSenseList = DeviceSearcherTask.Result.ToArray();
int DualSenseCount = DualSenseList.Length;
if (DualSenseCount <= 0)
{
throw new Exception("Cannot find DualSense. Check the cable again!");
}
var DualSenseDevice = DeviceManager.Current.GetDevice(DualSenseList[0]);
DualSense_Base dualSense;
if (DualSenseList[0].ReadBufferSize == 64)
{
dualSense = new DualSense_USB(DualSenseDevice);
}
else if (DualSenseList[0].ReadBufferSize == 78)
{
dualSense = new DualSense_Bluetooth(DualSenseDevice);
}
else
{
throw new NotImplementedException("Currently this application supports USB connection only.");
}
//Set Adaptive Trigger as "Normal"
dualSense.SetLeftAdaptiveTrigger(DualSense_Base.NormalTrigger);
dualSense.SetRightAdaptiveTrigger(DualSense_Base.NormalTrigger);
Thread.Sleep(-1);
}
public async Task <IDevice> Initialize()
{
try
{
WindowsHidDeviceFactory.Register(_logger);
var devices = await DeviceManager.Current.GetDevicesAsync(new List <FilterDeviceDefinition> {
ContourNextLink24DeviceDefinition
});
var selectedDevice = devices?.FirstOrDefault();
await selectedDevice.InitializeAsync();
return(selectedDevice);
}
catch (Exception ex)
{
_logger.Log(ex.Message, "CNL24Manager", ex, LogLevel.Error);
}
return(null);
}
public void Initialize()
{
WindowsHidDeviceFactory.Register(new DebugLogger(), new DebugTracer());
WindowsUsbDeviceFactory.Register(new DebugLogger(), new DebugTracer());
StartBroker(null, new LedgerManagerFactory());
}
private Task GetLedger()
{
WindowsHidDeviceFactory.Register();
WindowsUsbDeviceFactory.Register();
return(GetLedgerBase());
}
public static void Register(ILogger?logger, ITracer?tracer) => WindowsHidDeviceFactory.Register(logger, tracer);
static SpaceMouse()
{
WindowsHidDeviceFactory.Register(Logger, Tracer);
}
