Skip to end of metadata
Go to start of metadata

You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 4 Next »

The VictoR Windows Software Development Kit (SDK) allows developers to communicate with a VictoR device over Bluetooth Low Energy (BLE) in C#. The following documentation will walk users through the workflow of connecting to a device, reading and writing data to the services of the VictoR device, and how to register for notifications should the state of the device or its services change while connected. Currently, only the Device Configuration and Device Information services are directly supported by the SDK.

Supported ICD Rev: G
Supported VictoR Firmware Revision:

  • Application Firmware Rev: 03.054

  • Co-Processor Firmware Rev: 01.001

  • Kernel Module Firmware Rev: 01.001

  • BLE Firmware Rev: 03.017

SDK:

  • Minimum UWP: 10.0.10240.0

  • NetStandard 2.0.3

Nuget Packages:

  • NLog: 4.7.15

  • Microsoft.Windows.SDK.Contracts: 10.0.22000.196

Introduction

The Victor SDK is made up of two C# libraries, VictoRCore and VictoRCommunications. Both are essential in working with a VictoR device. It is important users add both libraries as dependencies for a C# project dealing with VictoR devices. If working in Visual Studio, the libraries can be added to the project by first navigating to the Project menu from the toolbar and selecting Add Project Reference.

Once the Add Project Reference window opens, users can add dependencies to the C# libraries.

Device Manager

Instantiation

The act of connecting and disconnecting to a device, as well as maintaining a record of connected devices, is handled by the device manager. Before any work can be done on reading, writing, and subscribing to services, users must first create and work with the device manager.

VictorBleDeviceManager m_deviceManager = new VictorBleDeviceManager();

Scanning for Devices

Once a VictorBleDeviceManager has been instantiated, a scan must be performed to identify any active VictoR devices accepting connections over bluetooth. By default, scanning for devices is set to take 10 seconds, with a query for any devices with the term “victor” in its name, with case sensitivity not taken into account. Once the scan has completed, a Set of VictorDeviceInfo objects is returned, which each contain the name and address of a VictoR device.

var scannedDevices = await m_deviceManager.ScanForDevices();

Setting Scan Parameters

Users have a means to also specify VictorDeviceScanParameters when scanning for VictoR devices. Options include specifying the scan time, the string query for victor device names, and whether the case of the device name is important. 

VictorDeviceScanParameters scanParameters = new VictorDeviceScanParameters();
scanParameters.ScanTime = scan;
scanParameters.DeviceName = "victor";
scanParameters.CaseSensitive = false;

var scannedDevices = await m_deviceManager.ScanForDevices(scanParameters);

Device Callbacks

Additionally, users can choose to receive a callback during the act of scanning for devices, rather than having to wait for the scan to complete. Callbacks can be set by passing a Action<VictorDeviceInfo>.

List<string> m_discoveredDevices = new List<string>();

public async Task Connect()
{
    var result = await m_deviceManager.ScanForDevices(OnDeviceAdded);
}

public async void OnDeviceAdded(VictorDeviceInfo deviceInfo)
{
    m_discoveredDevices.Add(deviceInfo.Address);
}

Connecting To A Device

Once a powered on VictoR device has been found by scanning for devices with the VictorBleDeviceManager, the resulting VictorDeviceInfo can be used to connect to the device along with the VictorBleDeviceManager that found the device.

List<string> m_discoveredDevices = new List<string>();

public async Task Connect()
{
    var result = await m_deviceManager.ScanForDevices(OnDeviceAdded);
}

public async void OnDeviceAdded(VictorDeviceInfo deviceInfo)
{
    m_discoveredDevices.Add(deviceInfo.Address);
    bool result = await m_deviceManager.Connect(deviceInfo.Address);
}

Subscribing to Connection State Changes

It is also possible to subscribe to the connection state of a VictoR device. This results in callbacks being triggered whenever the device is connected to or disconnected from.

public bool SubscribeConnectionState()
{
  bool subscriptionStatus = m_deviceManager.SubscribeConnectionStateChange(m_deviceName, ConnectionStateUpdated);

  return subscriptionStatus;
}

public void ConnectionStateUpdated(object sender, VictorConnectionStateChangedEventArgs args)
{
  onConnectionStateChanged.Invoke(args.Info.Address, args.Connected);
}

Disconnecting From A Device

A VictoR device can be disconnected by using the device manager that originally connected to the device, along with the device’s address.

await m_deviceManager.Disconnect(deviceID);

Reading From A VictoR Device

In order to read from a VictoR device, once a connection has been established through a device manager, a service object the attribute in question is associated with must first be created. Once the service object has been created, calls to read data from the connected device can be made, given the device manager containing the device has been passed to the service object on creation.

DeviceConfigurationService m_deviceConfigurationService = new DeviceConfigurationService(ref m_deviceManager);
DeviceInformationService m_deviceInformationService = new DeviceInformationService(ref m_deviceManager);

Deserialization of the data from the VictoR device is handled by the service objects, resulting in either a primitive data type or a custom made class defined in the SDK where appropriate. For example, when reading the serial number for the device through the DeviceInformationService class, the Task returns a string.

public async Task<string> GetSerialNumber()
{
  return await m_deviceInformationService.GetSerialNumber(m_deviceName);
}

However, when reading the General System Parameters for the device through the DeviceConfigurationService class, the Task returns a GeneralSystemParameters object (defined in the SDK) that provides accessors for the various pieces of data inside of the General System Parameters attribute.

var generalSystemParameters = await m_deviceConfigurationService.GetGeneralSystemParameters(m_deviceName);
bool bluetoothEnabled = generalSystemParameters.isBluetoothLinkEnabled();
PowerProfileOption powerProfileOption = generalSystemParameters.getPowerProfile();
ushort minimumInactivityInterval = generalSystemParameters.getMinimumInactivityInterval();

NOTE: When reading from a device, please reference the supported ICD document specified above to ensure the attribute itself, as well as reading from the attribute, is supported.

Writing To A VictoR Device

Similar to reading from a VictoR device, writing to a VictoR device requires an established connection with a powered on device through a device manager and a service object that contains the data to be written. Serialization of data when writing to the VictoR device is handled by the service objects, converting the data into a byte array before being sent to the device.

VictorCore.Services.VideoParameters videoParameters = new VictorCore.Services.VideoParameters();

VictorCore.Services.FrameSize frameSize = new VictorCore.Services.FrameSize();
frameSize.Rows = (ushort)128;
frameSize.Columns = (ushort)64;

videoParameters.FrameSize = frameSize;
videoParameters.FrameRate = (ushort)24;
videoParameters.OpticalPath = videoParameters.OpticalPath = VictorCore.Services.VideoParameters.OpticalPathOptions.AutoRange;

await m_VictorController.SetVideoParameters(videoParameters);

NOTE: When writing to a device, please reference the supported ICD document specified above to ensure the attribute itself, as well as writing to the attribute, is supported.

Subscribing To Attribute Changes

Attributes on the VictoR device, when supported, can be subscribed to through the usage of the EventHandler<VictorConnectionStateChangedEventArgs> and the service containing the data to be subscribed to.

await deviceInformationService.SubscribeToCurrentBatteryLevel(OnBatteryValueChanged);

private async void OnBatteryValueChanged(DeviceInformationEventArgs args)
{
  string batteryLevel = args.CurrentBatteryLevel.ToString();
}

  • No labels