API Reference

Prerequisites

Before you can use the Cambrionix Hub API, there are a few steps and checks that need to be completed.

macOS Installation

For macOS an installer is provided that will set up CambrionixApiService to run as a daemon process.

The installation can also perform all necessary steps to install and configure Python for the supplied example scripts.

Windows Installation

For Windows a self extracting installer is provided that will set up CambrionixApiService to run as a Windows service.

The installation can also perform all necessary steps to install and configure Python for the supplied example scripts.

Linux Installation

The Linux package comes as a Debian package which you can install either via the GUI or from the command line using apt:

$ sudo apt install ~/Downloads/cambrionix-api-setup-?????????.deb

There is also an armhf version that has been tested on oDroid and Raspberry Pi.

# -–version: Return the version of CambrionixApiService and then exit:
# Example:
$ CambrionixApiService -–version

CambrionixApiService 2.21.11
Copyright 2021 Cambrionix Ltd
http://www.cambrionix.com/

Minimal Example

Here is a minimal example of using the synchronous Hub API package, the code is written in Python 3.6:

# Import the cbrxapi library.
import sys
from cbrxapi import cbrxapi

print("Querying Hub API Version...")
try:
    result = cbrxapi.cbrx_apiversion()
except Exception as e:
    print(f"Could not communicate with API : {e}")
    result = None

if result:
    print(f"Hub API Version {result[0]}.{result[1]}")


# Call cbrx_discover with "local" to find any locally attached Cambrionix units.
# This will return a list of local Cambrionix units.
print("Discovering local devices..")
result = cbrxapi.cbrx_discover("local")
if not result or len(result) == 0:
    print("No Cambrionix unit found.")
    sys.exit(0)

print(f"Discovered {len(result)} units")

for unit_id in result:
    serial_port = cbrxapi.cbrx_discover_id_to_os_reference(unit_id)

    try:
        # Open a connection to the Cambrionix unit, which will return a handle for
        # the connection.
        handle = cbrxapi.cbrx_connection_open(unit_id)
    except Exception as e:
        print(f"Could not open connection to {unit_id} : {e}")
        handle = None

    if handle:
        # Using the handle, get the "Hardware" and "nrOfPorts" properties
        hardware = cbrxapi.cbrx_connection_get(handle, "Hardware")
        n_ports = cbrxapi.cbrx_connection_get(handle, "nrOfPorts")

        # Done using the Cambrionix unit, close the handle.
        cbrxapi.cbrx_connection_close(handle)

        # Finally, print out the information retrieved from the Cambrionix unit.
        print(f"* {hardware} on {serial_port} has {n_ports} ports")

JavaScript Example

And another example demonstrating access from a React application. Note that the socket connection address is prefixed with ws. This allows the Hub API to upgrade the connection to a Web-socket and be natively used by web technologies such as this. The same methods can be used from Node.js and other similar platforms.

import React from 'react';
import Websocket from 'react-websocket';

class MyApiInterface extends React.Component {
  lastId = 0;

  render() {
    return (
      <Websocket ref={r => this.websocket = r} reconnect
                 url="ws://localhost:43424" protocol="jsonrpc"
                 onMessage={this.onDataReceived.bind(this)}
                 onOpen={this.onApiConnection.bind(this)}
                 onClose={this.onApiDisconnection.bind(this)} />
    );
  }

  requests = {};

  onDataReceived(json) {
    const data = JSON.parse(json);
    const id = data.id;
    if (id) {
      const request = this.requests[id];
      if (request && request.callback) {
        request.callback(data);
      }
      delete this.requests[id];
    }
    else
    {
      //Could get a notification here if you enable them on active connection
      //Notifications have no id and can arrive at any time
    }
  }

  makeRequest(method, params, callback) {
    var packet = {
      jsonrpc: "2.0",
      id:      ++this.lastId,
      method:  method,
      params:  params,
    };

    this.requests[packet.id] = {packet: packet, callback: callback};

    this.websocket.sendMessage(JSON.stringify(packet));
  }

  onApiConnection() {
    console.log("Connected");
    this.makeRequest("cbrx_discover", ["local"], console.log);
  }

  onApiDisconnection() {
    console.log("Disconnected");
    this.requests = {}
  }
}

HTTP GET Example

Connections can be made directly to an http prefixed URI, in which case the json is extracted from either the address itself, or the body content of the GET request. Try this example in your browser now: {“method”:“cbrx_discover”,“params”:[“all”],“jsonrpc”:“2.0”,“id”:1}.

Or from the command line, using curl, you can do:

curl -get http://localhost:43424/?{\"id\":0,\"jsonrpc\":\"2.0\",\"method\":\"cbrx_discover\",\"params\":[\"all\"]}

Error Handling

A JSON-RPC error will return an error member containing the following members:

• code (mandatory) – an integer indicating either a pre-defined JSON-RPC error code in the range -32768 to -32000 or a Hub API error code as documented in the section CBRXAPI specific errors section.
• message (optional) – a message string explaining the error code
• data (optional) – extra information about the error like debug messages or handles.

The Python JSON-RPC used causes an exception for an error response with the following mapping:

• member code is returned in e.error_code
• member message is returned in e.error_message
• member data is returned in e.error_data.

In step 3 you could catch an error response with:

try:
    handle = cbrxapi.cbrx_connection_open(id)
except jsonrpc.RPCFault as e:
    gotException = True
    errorCode = e.error_code
    errorMessage = e.error_message
    errorData = e.error_data

Depending on the errorCode returned different actions can be taken, i.e. the user could be prompted to check whether the device is plugged in before retrying.

Environment

The Cambrionix Hub API is implemented in CambrionixApiService, which sits between the application and the Cambrionix units. It maps the properties of the Cambrionix units into Hub API commands.

In its simplest form, it accepts socket connections on localhost:43424 and subsequent JSON-RPC request packets to which it will respond. These socket connections may also be WebSockets.

JSON-RPC Requests

The JSON-RPC implementation should hide these details.

The Python request cbrxapi.cbrx_connection_get(7654, "nrOfPorts") translates into a JSONRPC request containing the method name:

"cbrx_connection_get"

and a JSON representation of the parameters (params), which is often a JSON array of values, unless otherwise specified:

[ 7654, "nrOfPorts" ]

Two further key-value pairs need to be passed to complete the JSON-request; One indicating the version of jsonrpc being used, in this case 2.0 and an id identifying this request:

The id is mandatory but only relevant if multiple requests can be outstanding simultaneously over the same connection. It helps to match responses to (asynchronous) requests. The response for a request will be given the matching id by CambrionixApiService. The Hub API Service runs on many threads and there is no guarantee, nor requirement by the specification, that the replies will arrive in any particular order. If strict ordering is required, you can batch multiple request packets in an array which will be ordered the same as it arrived.

Grouping this all together will give the complete JSON-RPC request:

{
    "jsonrpc": "2.0",
    "method": "cbrx_connection_get",
    "params": [
        7654,
        "nrOfPorts"
    ],
    "id": 0
}

There are 3 groups of calls in the API:

• Version
• Discovery
• Connection

cbrx_apiversion

Return the interface version of the local Hub API running.

Input:

• none

or

• [true] to instead return the result of cbrx_apidetails. Since true will be ignored by older APIs, its a simple way to get the extended version if its available.

Returns:

• On success
  • Returns a pair of integers (major, minor) indicating the Hub API version.
  • The current version is major 2, minor 0.
• On failure:
  • a JSON-error object will be returned.

Example Python call:

cbrxapi.cbrx_apiversion()

Example JSONRPC request:

{
    "jsonrpc": "2.0",
    "method": "cbrx_apiversion",
    "id": 0
}

Example successful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "result": [2, 0]
}

cbrx_apidetails

Returns an enhanced version of the details of the API. This information can also be gained by passing an optional true parameter to cbrx_apiversion.

Input:

• none

Returns:

• Returns an object containing version and other information.

Example Python call:

cbrxapi.cbrx_apidetails()

Example JSONRPC request:

{
    "jsonrpc": "2.0",
    "method": "cbrx_apidetails",
    "id": 0
}

Example successful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "result": {
        "branch": "release",
        "capability": [
            "protobuf",
            "crash-report",
            "notification"
        ],
        "bundled": true, // Only if run via LiveViewer bundling
        "commitid": 3298696760,
        "documentation": "/Library/Cambrionix/ApiService/doc/Cambrionix API Reference.html",
        "install": "/Library/Cambrionix/ApiService",
        "logging": "/Library/Log/Cambrionix",
        "settings": "/Library/Cambrionix/ApiService",
        "notifications": [
            "usb-changed",
            "usb-device-attached",
            "usb-device-detached",
            "discover-changed",
            "dead-hub-changed",
            "firmware-progress",
            "rfid-received",
            "rfid-removed",
            "over-temperature",
            "over-voltage",
            "under-voltage",
        ],
        "semver": "3.1.15+123",
        "version": [3, 1, 15, 123]
    }
}

This information is made available so that future versions of LiveViewer and API can detect the available features without intimate knowledge of version numbers.

The notification capability indicates that the cbrx_notifications method is supported.

The crash-report capability is internal and should not be used.

The protobuf capability is currently internal to the Hub API and is used to communicate to the Recorder service. The protobuf message format may be made available at a later date.

cbrx_discover

Discover Cambrionix units.

Input:

• “local” for Cambrionix units attached to the local machine

• “docks” for units that contain more than one Cambrionix charger
• “all” discover all units and return detailed information about the hubs and their connected devices. Note that only devices that show up in a USB scan will be included. Unlike the other discovery methods, instead of an array of serial numbers, it will be an object of serial numbers with contents.

Returns:

• On success: the unit IDs for the discovered Cambrionix units will be returned as an array of strings. Each unit ID is guaranteed to be unique. The unit ID is based on the serial number of the Cambrionix unit.
• On failure: a JSON-error object will be returned.

Example Python call:

cbrxapi.cbrx_discover("local")

Example JSONRPC request:

{
    "jsonrpc": "2.0",
    "method": "cbrx_discover",
    "params": ["local"],
    "id": 0
}

Example successful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "result": ["DB0074F5"]
}

Example unsuccessful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "error": {
       "code": -32602,
       "message": "Invalid params"
    }
}

cbrx_discover_id_to_os_reference

Map a unit ID for a discovered Cambrionix unit to a device name as used by the OS.

Input:

• Unit ID as returned by cbrx_discover.

Returns:

• On success: The device name as used by the OS for the connection that the Cambrionix unit identified by the unit ID is connected to.
• On failure: a JSON-error object will be returned.

Note: This only makes sense for locally attached Cambrionix units.

Example Python call:

cbrxapi.cbrx_discover_id_to_os_reference(unitId)

Example JSONRPC request:

{
    "jsonrpc": "2.0",
    "method": "cbrx_discover_id_to_os_reference",
    "params": ["DB0074F5"],
    "id": 0
}

Example successful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "result": ["/dev/ttyUSB0"]
}

Example unsuccessful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "error": {
        "code": -32602,
        "message": "Invalid params"
    }
}

cbrx_find

Search for devices attached to local Cambrionix units.

Input:

• VID to search for and devices matching the vendor ID.
• VID & PID to search for devices exactly matching the vendor and product IDs.
• NAME to search for anything that matches the provided regex. The regex is run against a string made up of the manufacturer, product name, USB serial number and DevicePath (For an iPhone this is the UDID). "<manufacturer-name>\x1D<product-name>\x1D<serial-number>". So for a iPhone, it would be something like "Apple\x1DiPhone\x1Dfa3c8762e87f068ce16e8c6fa\x1DDevicePath". \x1D was chosen because it is the ASCII standard character for a field delimiter and so should be sufficient to avoid false matches crossing string boundaries. The regex is performed as a search, rather than a match, so you do not need to do things like ".*iPhone.*" to match substrings; "iPhone" is sufficient. You can of course be as strict as you like. Additionally, if the phone’s identity or internal serial number have been detected, then these will also be matched.

The regex syntax used is Modified ECMAScript.

Returns:

• On success: An object containing details of all matched units.
• On failure: a JSON-error object will be returned.

The returned data is keyed on the serial number of any devices matching the search criteria. The value of each node holds details of the location and the exact device details.

Also note that the entire USB tree is searched for the specified items, and if found anywhere beneath a Cambrionix hub, then the connection details will be returned. This would be especially useful for devices that are plugged into an intermediate hub device rather than being directly connected to the Cambrionix hub, such as a phone with battery extended and extra USB slots.

This new call (as of API 2.1) can save a lot of programmatic work because you no longer need to open each Cambrionix unit individually and check for attached devices. Although, you would of course still need to do that to monitor current draw.

Example Python call:

# Python call to search for all iPhones
cbrxapi.cbrx_find("iPhone")

# Regex can be used too
cbrxapi.cbrx_find("i(Phone|Pad)")

# Find everything connected to any Cambrionix device
cbrxapi.cbrx_find(".")

# JSON-RPC call
{
    "jsonrpc": "2.0",
    "method": "cbrx_find",
    "params": ["i(Phone|Pad)"],
    "id": 1234
}

Example successful response of cbrx_find(‘Super’):

{
    "jsonrpc": "2.0",
    "id": 1234,
    "result": {
        "a7cfd7345fad329819cfad3781632ac8a65c": {
            "HostDescription": "ThunderSync3-16",
            "HostDevice": "0000034CCC2AA16",
            "HostPort": 9,
            "HostSerial": "COM31",
            "Device": {
                "VID": 1234
                "PID": 5678,
                "Manufacturer": "SuperPhone Makers Inc.",
                "Description": "SuperPhone6",
                "LocationID": 07100000,
                "DevicePath": "\\\\?\\usb#vid_1234&pid_5678#08070960a76757#{a5dcbf10-6530-11d2-901f-00c04fb951ed}",
                "SerialNumber": "08070960a76757",
                "USBVersion": 3,
                  "USBPower": {
                  "State": "D0",
                  "Description": "On"
                },
                "USBSpeed": {
                  "Speed": "480Mbps",
                  "Description": "High"
                },
                "Endpoints": {
                  "Active": 4,
                  "Memory": 16384
                }
            }
        }
    }
}

From these results, you could check the status of, for example, the iPad by running cbrx_connection_open('0000034CCC2AA16') and then check the status of HostPort by querying cbrx_connection_get(handle, 'PortInfo.9'). But if you’re only interested in the presence of devices, then you may find that you do not need this extra information.

For any search results that do not have their own device serial number, there will be an additional entry of NoSerial that is an array of such results.

For the curious, it may look like unneeded repetition with the serial numbers, but this is merely because the data here comes from the same place as the data produced by cbrx_connection_get(handle, 'PortsInfo') or cbrx_get_usbtree, and we’re simply showing everything from the point of connection upwards.

cbrx_get_usbtree

This method is deprecated in favour of cbrx_get_usb('tree'). It will never be removed.

cbrx_config_set

This function allows setting various persistent configuration options. params should be an object with key value pairs. Multiple options may be set at once.

Possible configuration values are:

• battery-update-enabled - Whether battery update queries are performed. This must be a boolean value (true or false).
• battery-update-concurrency - How many concurrent battery updates will be run simultaneously. The default for this is two less than the number of processor threads your device has. This must be an integer value greater than zero.
• battery-update-frequency-seconds - How many seconds between battery updates. The default is 60 seconds. This must be an integer value greater than zero.

{
    "jsonrpc": "2.0",
    "method": "cbrx_config_set",
    "params": {
        "battery-update-enabled": true,
        "battery-update-concurrency": 2,
        "battery-update-frequency-seconds": 60
    },
    "id": 0
}

cbrx_config_get

This function allows retrieving the configuration options set with cbrx_config_set.

{
    "jsonrpc": "2.0",
    "method": "cbrx_config_get",
    "params": ["key"],
    "id": 0
}

The return value will be as it was set via cbrx_config_set.

cbrx_connection_open

Open a connection to the Cambrionix unit specified. A successful open results in a connection handle that can be used for further calls to query information about the hub. This handle should be closed with a call to cbrx_connection_close when it is no longer required. An unsuccessful open does not need a corresponding call to cbrx_connection_close.

Open handles will automatically expire after 30 seconds of inactivity. If this occurs, further queries will return an CBRXAPI_ERRORCODE_INVALIDHANDLE error.

Input:

• A unit ID as returned by a previous call to cbrx_discover.
• The second parameter is optional but will default to “local” when absent.
• For “remote” or “docks”, these values must be specified.
• For “remote” connections an additional parameter for the password must be supplied.

Returns:

• On success: a connection handle will be returned as an integer.
• On failure: a JSON-error object will be returned.

Example Python call:

# Connect to local device
connectionHandle = cbrxapi.cbrx_connection_open("DB0074F5")

<!--
# Connect to remote device
connectionHandle = cbrxapi.cbrx_connection_open("EtherSync1d94a0.local.", "remote", "password")

–>

Example JSONRPC request:

{
    "jsonrpc": "2.0",
    "method": "cbrx_connection_open",
    "params": ["DB0074F5"],
    "id": 0
}

Example successful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "result": 7654
}

Example unsuccessful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "error": {
        "code": -10001,
        "message": "ID not found"
    }
}

cbrx_connection_close

Close a connection to a Cambrionix unit previously opened, as specified by the connection handle.

Input parameter:

• Connection handle as returned by a previous call to cbrx_connection_open.

Returns:

• On success: the boolean value true will be returned.
• On failure: a JSON-error object will be returned.

Note: It is important to receive the response before closing the socket to ensure the operation has time to be actioned.

Example Python call:

result = cbrxapi.cbrx_connection_close(connectionHandle)

Example JSONRPC request:

{
    "jsonrpc": "2.0",
    "method": "cbrx_connection_close",
    "params": [7654],
    "id": 123
}

Example successful response:

{
    "jsonrpc": "2.0",
    "id": 123,
    "result": true
}

Example unsuccessful response:

{
    "jsonrpc": "2.0",
    "id": 123,
    "error": {
        "code": -10005,
        "message": "Invalid handle"
    }
}

cbrx_connection_getdictionary

List all tags that can return information on the Cambrionix unit specified by connectionHandle.

Input parameter:

• A connection handle as returned by a previous call to cbrx_connection_open.

Returns:

• On success: an array of strings containing the names of the readable tags for the Cambrionix unit.
• On failure: a JSON-error object will be returned.

Example Python call:

cbrxapi.cbrx_connection_getdictionary(connectionHandle)

Example JSONRPC request:

{
    "jsonrpc": "2.0",
    "method": "cbrx_connection_getdictionary",
    "params": [7654],
    "id": 0
}

Example successful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "result": [
        "SystemTitle",
        "Hardware",
        "Firmware",
        ...
    ]
}

cbrx_connection_get

From the Cambrionix unit specified by the connection handle, get the value of the tag.

Input parameters:

• connectionHandle as returned by a previous call to cbrx_connection_open. Or the hub’s serial number as returned by cbrx_discover.
• propertyName string. See Get Dictionary table.

Returns:

• On success: the value of the tag specified.
• On failure: a JSON-error object will be returned.

Example Python call:

value = cbrxapi.cbrx_connection_get(connectionHandle, "nrOfPorts")

Example JSONRPC request:

{
    "jsonrpc": "2.0",
    "method": "cbrx_connection_get",
    "params": [
        7654,
        "nrOfPorts"
    ],
    "id": 0
}

Example successful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "result": 8
}

Example unsuccessful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "error": {
        "code": -10003,
        "message": "Key not found"
    }
}

cbrx_hub_get

Like cbrx_connection_get, but instead of a handle takes the hub’s serial number as the initial argument.

Note that this is a convenience function and will almost certainly be slower if you need to do multiple operations on the same hub.

cbrx_device_get

Like cbrx_connection_get, but instead of a handle takes a USB device’s serial number as the initial argument. Only get values that are relevant to ports are accepted.

Note that this is a convenience function and will almost certainly be slower if you need to do multiple operations on the same device.

For example, instead of:

deviceSerialNumber = "123123123123"
allDevices = cbrxapi.cbrx_find("iPhone")
myDevice = allDevices[deviceSerialNumber]
if myDevice:
    handle = cbrxapi.cbrx_connection_open(myDevice["HostDevice"])
    deviceStatus = cbrxapi.cbrx_connection_get(handle, "PortInfo." + myDevice["HostPort"])
    cbrxapi.cbrx_connection_close(handle)

You can use:

deviceSerialNumber = "123123123123"
deviceStatus = cbrxapi.cbrx_device_get(deviceSerialNumber, "PortInfo")

cbrx_connection_setdictionary

List all writeable value tags and command tags for the Cambrionix unit specified by connectionHandle.

Input parameter:

• A connection handle as returned by a previous call to cbrx_connection_open.

Returns:

• On success: an array of strings containing the names of the writeable tags and command tags for the device.
• On failure: a JSON-error object will be returned.

Example Python call:

cbrxapi.cbrx_connection_setdictionary(connectionHandle)

Example JSONRPC request:

{
    "jsonrpc": "2.0",
    "method": "cbrx_connection_setdictionary",
    "params": [7654],
    "id": 0
}

Example successful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "result": [
        "Port.1.mode",
        "Port.2.mode",
        ...
        "ClearRebootFlag ",
        "Reboot",
        ...
    ]
}

cbrx_connection_set

On the Cambrionix unit specified by the connection handle, set the tag to the value specified.

Input:

• connectionHandle as returned by a previous call to cbrx_connection_open.
• Tag as returned by a call to cbrx_connection_setdictionary.
• Value, the value to set the tag to.

Returns:

• On success: the Boolean value true.
• On failure: a JSON-error object will be returned.

Note: It is important to receive the response before closing the socket to ensure the operation has time to be actioned.

Example Python call:

cbrxapi.cbrx_connection_set(connectionHandle, "Reboot", True)

Example JSONRPC request:

{
    "jsonrpc": "2.0",
    "method": "cbrx_connection_set",
    "params": [
        7654,
        "TwelveVoltRail.OverVoltage",
        true
    ],
    "id": 0
}

Example successful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "result": true
}

Example unsuccessful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "error": {
        "code": -10004,
        "message": "Error setting value"
    }
}

cbrx_hub_set

Like cbrx_connection_set, but instead of a handle takes the hub’s serial number as the initial argument.

Note that this is a convenience function and will almost certainly be slower if you need to do multiple operations on the same hub.

cbrx_device_set

Like cbrx_connection_set, but instead of a handle takes the devices’s serial number as the initial argument.

Also, instead of specifying (for example) Port.N.led1, you just specify led1 because the rest is already known from the context of the device.

For example, instead of:

deviceSerialNumber = "123123123123"
allDevices = cbrxapi.cbrx_find("iPhone")
myDevice = allDevices[deviceSerialNumber]
if myDevice:
    handle = cbrxapi.cbrx_connection_open(myDevice["HostDevice"])
    if handle:
        deviceStatus = cbrxapi.cbrx_connection_set(handle, "Port." + myDevice["HostPort"] ".led1", 255)
        cbrxapi.cbrx_connection_close(handle)

You can use:

deviceSerialNumber = "123123123123"
deviceStatus = cbrxapi.cbrx_device_set(deviceSerialNumber, "led1", 255)

Note that this is a convenience function and will almost certainly be slower if you need to do multiple operations on the same hub that are separated by more than a few seconds.

cbrx_notifications

The Hub API supports sending of notifications for certain events.

• discover-changed - The Hub API detected a change in the available hubs. You should re-run cbrx_discover at this point.
• dead-hub-changed - The Hub API detected that a hub has either become unresponsive or cannot be connected to, for example because another program has it’s serial port opened.
• usb-changed - The Hub API detected a change in the USB Tree.
• usb-device-attached - More detailed that usb-changed, this will tell you of specific devices that have arrived.
• usb-device-detached - … or detached.
• firmware-progress - Request updates on firmware update progress.
• rfid-received - Receive notification when a RFID card is presented to the sensor on a ModIT Boss.
• rfid-removed - Receive notification when an RFID card is removed from the sensor on a ModIT Boss.
• all - Request all notifications.

For example, to enable four separate notifications:

{
    "jsonrpc": "2.0",
    "id": 0,
    "method": "cbrx_notifications",
    "params": [
        "discover-changed",
        "usb-device-attached",
        "usb-device-detached",
        "rfid-received"
    ]
}

Notification packets are the same as other JSON-RPC packets, except that they do not have an "id" field. Most of these notifications do not supply anything in the "params" field, except for the following examples, and the "firmware-update" one shown here.

Example of usb-device-attached notification (The same information comes with the "usb-device-detached" notification.):

{
    "jsonrpc": "2.0",
    "method": "usb-device-attached",
    "params": {
        "HostDevice": "1212343456567878",
        "HostSerial": "/dev/tty.usbmodem1421502",
        "HostPort": 7,
        "HostDescription": "PS15-USB3"
        "USB2": {
            "Description": "iPhone",
            "LocationID": 573710336,
            "Manufacturer": "Apple Inc.",
            "PID": 4776,
            "SerialNumber": "012a37d1fa07617ad7ef0430ba49f479ab9fb6b8",
            "USBVersion": 2,
            "VID": 1452,
        },
    }
}

Or when an RFID card is scanned on a ModIT Boss.

{
    "jsonrpc": "2.0",
    "method": "rfid-received",
    "params": "1278634123461283764"
}

In this example we show that the device was connected as USB2 only. A USB3 device would have a similar entry. It is presented this way because it is entirely possible to connect (for example) a USB3 device that has its own hub, and USB2 devices. These would be individually shown because they can’t reliably be mixed; you can have hardware entities with the same VID/PID/Serial in sibling trees.

Note: Notifications are only sent to active socket connections that have requested them. Closing a socket and opening another one will mean you need to re-request notifications. See the examples/nodejs folder (installed with the API) for ideas about handling notifications in your code

cbrx_firmware

The firmware functions can control all aspects of updating the firmware on Cambrionix hubs.

There are several sub-commands here that allow you to add or remove firmware files from the API’s local storage, list the currently available firmware files, update firmware from provided files and check the status of existing firmware updates.

# Example of adding new firmware
# This merely provides it to the Hub API as an available update source
# It does not affect any connected hubs

rawBytes = myReadFileFunction("SomeCambrionixFirmwareFile.enfir")
encodedBytes = base64.b64encode(zip(rawBytes))
cbrxapi.cbrx_firmware("add", "SomeCambrionixFirmwareFile.enfir", encodedBytes)

# Example of removing firmware from Hub API storage
cbrxapi.cbrx_firmware("remove", "CambrionixFirmware-un")

# Example of listing available firmware files
list = cbrxapi.cbrx_firmware("list")
print(list)
# Would give something like:
# [
#   {filename: "CambrionixFirmware-un", version: "1.79"},
#   {filename: "AnotherFirmwareFile-un", version: "1.78"}
# ]

# Example of starting firmware update (in this case the charger firmware)
# Other types of firmware can be available for different products,
# such as "display" for hubs with more complex LED arrangements.

# Firmware updates can either be specified with a single file,
# or an object of files keyed on the type of firmware update.

handle = cbrxapi.cbrx_connection_open("1212343456567878")

# For example, update all firmware for selected device from the firmware files provided.
cbrxapi.cbrx_firmware("update", handle, {"un": "CambrionixFirmware-un", "mc": "MotorControlFirmware-mc"})

# Initiate firmware update for hub by serial number
cbrxapi.cbrx_firmware("update", "1212343456567878", {"un": "CambrionixFirmware-un", "mc": "MotorControlFirmware-mc"})

# Example of getting status of firmware update
cbrxapi.cbrx_firmware("status", handle)

{
  "Version": "1.88.0",              // Only present after initialising stage
  "PreviousVersion": "1.79",        // Only present after initialising stage
  "Type": "charger",
  "Progress": 60,                   // Percent progress
  "Stage": "updating",
  "HostDevice": "COM3",
  "HostSerial": "1212343456567878",
  "HostDescription": "SuperSync15",
  "Started": 123123123123,          // UTC time of start
  "Ended": 123123123123             // UTC time of end time (only when status is complete)
}

# Example of getting status of firmware update
cbrxapi.cbrx_firmware("history", handle)

# Could give:
# {
#   "un": {
#     Version: "1.79",
#     Type: "display",
#     Progress: 60,
#     Stage: "flashing"
#   }
# }

{
  "jsonrpc": "2.0",
  "method": "firmware-progress",
  "params": {
    "Progress": 60,
    "Stage": "flashing",
    "Type": "charger",
    "HostDevice": "1212343456567878",
    "HostSerial": "/dev/tty.usbmodem1421502",
    "HostDescription": "PS15-USB3"
  }
}

cbrx_connection_closeandlock

Forcibly close all connections to a Cambrionix unit and lock it against further use until released by cbrx_connection_unlock. Other processes that were using these connections will receive a CBRXAPI_ERRORCODE_LOCKED error if trying to access this Cambrionix unit. Locking a Cambrionix unit that was not previously opened does no harm and will succeed.

Input parameter:

• A unit ID as returned by a previous call to discover.
• Or “all” to lock all discovered hubs.

Returns:

• On success: the boolean value true will be returned
• On failure: a JSON-error object will be returned.

Note: It is important to receive the response before closing the socket to ensure the operation has time to be actioned.

Example Python call:

cbrxapi.cbrx_connection_closeandlock("DB0074F5")

Example JSONRPC request:

{
    "jsonrpc": "2.0",
    "method": "cbrx_connection_closeandlock",
    "params": ["DB0074F5"],
    "id": 0
}

Example successful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "result": true
}

Example unsuccessful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "error": {
        "code": -10001,
        "message": "ID not found"
    }
}

cbrx_connection_unlock

Unlock a Cambrionix unit that was previously locked with cbrx_connection_closeandlock. Unlocking a Cambrionix unit that was not previously locked does no harm and will succeed.

Input parameter:

• A unit ID as returned by a previous call to discover
• Or “all” to unlock all discovered hubs.

Returns:

• On success: the boolean value true will be returned
• On failure: a JSON-error object will be returned.

Note: It is important to receive the response before closing the socket to ensure the operation has time to be actioned.

Example Python call:

cbrxapi.cbrx_connection_unlock("DB0074F5")

Example JSONRPC request

{
    "jsonrpc": "2.0",
    "method": "cbrx_connection_unlock",
    "params": ["DB0074F5"],
    "id": 0
}

Example successful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "result": true
}

Example unsuccessful response:

{
    "jsonrpc": "2.0",
    "id": 0,
    "error": {
        "code": -10001,
        "message": "ID not found"
    }
}

cbrx_connection_cli

Perform command line interface operation on the connected hub and return the complete result. This allows you to run commands directly on the hub’s command line without stopping the Hub API service, connecting to the serial port and so on.

The return is an array of strings containing all the lines of output returned from the command.

cbrxapi.cbrx_connection_cli(7654, "id")

Example JSONRPC request

{
    "jsonrpc": "2.0",
    "method": "cbrx_connection_cli",
    "params": [7654, "id"],
    "id": 1337
}

Example successful response:

{
    "jsonrpc": "2.0",
    "id": 1337,
    "result": [
        "mfr:cambrionix,mode:main,hw:PP15S,hwid:0x13,fw:1.83,bl:0.12,sn:000000,group:-,fc:un"
    ]
}

cbrx_pair_device

Initiate pairing of an iOS device. This is not usually necessary as it will occur automatically when the Hub API attempts to query battery information.

In both examples here, "UDID" is the phone’s USB serial number.

cbrxapi.cbrx_pair_device("UDID")

Example JSONRPC request

{
    "jsonrpc": "2.0",
    "method": "cbrx_pair_device",
    "params": ["UDID"],
    "id": 1337
}

cbrx_certificate

Supply (or remove) a certificate and private key to the Hub API to allow SSL connections from outside of localhost (the machine the Hub API is running on). Without this certificate, the Hub API will only listen for connections on localhost:43424. Once a valid certificate and private key are provided, this will change to 0.0.0.0:43424. External connections (not from localhost) will only be allowed if they are SSL connections (HTTPS or Secure WebSockets).

It is up to the user to supply a certificate that is suitable for their usage. For example, if it is not signed by a certificate authority, then you will need to deal with this in the usual way, such as signing your certificate with your own certificate autority and adding that to your application or browser. With Google Chrome you can use this guide. There are similar guides for other browsers.

Only a single certificate configuration is supported.

If a password is supplied, it is obfuscated to avoid prying eyes.

To add a certificate and private key to the API:

{
    "id": 1234,
    "jsonrpc": "2.0",
    "method": "cbrx_certificate",
    "params": [
        "set",
        {
            "private-key": <private key filename>,
            "certificate": <certificate filename>,
            "password": <optional password if required by private key>
        }
    ]
}

Remove the certificate and private from the API:

{
    "id": 1234,
    "jsonrpc": "2.0",
    "method": "cbrx_certificate",
    "params": [
        "remove"
    ]
}

cbrx_get_usb

First parameter describes the information to fetch. * tree - Psynonym for cbrx_get_usbtree. * descriptors - Get all USB descriptor information from a single USB node.

# Example output from cbrx_usbtree.py example
[{'Description': 'Intel(R) USB 3.20 eXtensible Host Controller - 1.20 (Microsoft)',
  'HostController': {'EndpointMemoryUsed': 0x25000, 'EndpointPeakMemoryUsed': 0x9b000, 'EndpointPeakTotal': 0x007d, 'EndpointTotal': 0x0021, 'Type': 'XHCI'},
  'LocationID': 0x21000000,
  'PID': 0x7ae0,
  'SerialNumber': '3&11583659&0&a0',
  'USBSpeed': {'Description': 'SuperSpeed USB 20Gbps', 'Speed': '20Gbps'},
  'USBVersion': 3.2,
  'VID': 0x8086},
 {'Description': 'TS3-C10',
  'LocationID': 0x23000000,
  'Manufacturer': 'Cambrionix',
  'PID': 0x15d3,
  'SerialNumber': 'a-2aa5366c-0-2',
  'USBSpeed': {'Description': 'SuperSpeed USB 5Gbps', 'Speed': '5Gbps'},
  'USBVersion': 3.0,
  'VID': 0x8086,
  'children': [{'Description': 'Fresco Logic USB 3.0 eXtensible Host Controller - 1.0 (Microsoft)',
                'HostController': {'EndpointMemoryUsed': 0x18000, 'EndpointTotal': 12, 'Type': 'XHCI'},
                'LocationID': 0x23000000,
                'PID': 9,
                'SerialNumber': 'c&2d6c3950&0&0000000800e4',
                'USBSpeed': {'Description': 'SuperSpeed USB 5Gbps', 'Speed': '5Gbps'},
                'USBVersion': 3.0,
                'VID': 0xca3b},
               {'Description': 'Fresco Logic USB 3.0 eXtensible Host Controller - 1.0 (Microsoft)',
                'HostController': {'EndpointMemoryUsed': 0, 'EndpointTotal': 6, 'Type': 'XHCI'},
                'LocationID': 0x24000000,
                'PID': 10,
                'SerialNumber': 'c&2cc681d1&0&0008000800e4',
                'USBSpeed': {'Description': 'SuperSpeed USB 5Gbps', 'Speed': '5Gbps'},
                'USBVersion': 3.0,
                'VID': 0xca3b,
                'children': [{'Description': 'Ultra USB 3.0',
                              'Endpoints': {'Active': 3, 'Memory': 0x6000},
                              'FlashDrive': {'Available': 0x1f2378000, 'Capacity': 0x1fffff000, 'Path': 'D:\'
                              'LocationID': 0x24300000,
                              'Manufacturer': 'SanDisk',
                              'PID': 0x5595,
                              'SerialNumber': '4C530000131105120260',
                              'USBPower': {'Description': 'On', 'State': 'D0'},
                              'USBSpeed': {'Description': 'SuperSpeed USB 5Gbps', 'Speed': '5Gbps'},
                              'USBVersion': 3.0,
                              'VID': 0x0781}]},
               {'Description': 'Fresco Logic USB 3.0 eXtensible Host Controller - 1.0 (Microsoft)',
                'HostController': {'EndpointMemoryUsed': 0, 'EndpointTotal': 3, 'Type': 'XHCI'},
                'LocationID': 0x25000000,
                'PID': 11,
                'SerialNumber': 'c&1601d69&0&0010000800e4',
                'USBSpeed': {'Description': 'SuperSpeed USB 5Gbps', 'Speed': '5Gbps'},
                'USBVersion': 3.0,
                'VID': 0xca3b,
                'children': [{'Description': 'TS3-C10',
                              'Endpoints': {'Active': 3, 'Memory': 0x3000},
                              'LocationID': 0x25200000,
                              'Manufacturer': 'Cambrionix',
                              'PID': 0x6015,
                              'SerialNumber': 'a-2aa5366c-0-2',
                              'USBPower': {'Description': 'On', 'State': 'D0'},
                              'USBSpeed': {'Description': 'Full', 'Speed': '12Mbps'},
                              'USBVersion': 2.0,
                              'VID': 0x0403,
                              'VirtualSerialPort': 'COM25'}]}]}]

{
    "jsonrpc": "2.0",
    "method": "cbrx_get_usb",
    "params": ["descriptors", "123456789abcdef"],
    "id": 1337
}

{
  "jsonrpc": "2.0",
  "id": 0,
  "result": {
    "RawBytes": "120120030000000951092b17010001020301",
    "bLength": 18,
    "bDescriptorType": 1,
    "bNumConfigurations": 1,
    "bcdUSB": 800,
    "bDeviceClass": 0,
    "bDeviceSubClass": 0,
    "bDeviceProtocol": 0,
    "bMaxPacketSize0": 9,
    "idVendor": 2385,
    "idProduct": 5931,
    "bcdDevice": 1,
    "iManufacturer": 1,
    "iProduct": 2,
    "iSerialNumber": 3,
    "Derived": {
      "DescriptorType": "Device",
      "CurrentConfiguration": 1,
      "DeviceClass": "Reserved"
    },
    "Configurations": {
      "1": [
        {
          "RawBytes": "09022c00010100ff8025",
          "bLength": 9,
          "bDescriptorType": 2,
          "wTotalLength": 44,
          "bConfigurationValue": 1,
          "bmAttributes": 128,
          "bNumDescriptors": 1,
          "iConfiguration": 0,
          "reserved1": 0,
          "reserved2": 1,
          "SelfPowered": 0,
          "Derived": {
            "DescriptorType": "Configuration",
            "MaxPower": 37,
            "RemoteWakeUp": 0,
            "BusPowered": 0
          }
        },
        {
          "RawBytes": "090400000208065000",
          "bLength": 9,
          "bDescriptorType": 4,
          "iInterface": 0,
          "bInterfaceNumber": 0,
          "bAlternateSetting": 0,
          "bNumEndpoints": 2,
          "bInterfaceClass": 8,
          "bInterfaceSubClass": 6,
          "bInterfaceProtocol": 80,
          "Derived": {
            "DescriptorType": "Interface"
          }
        },
        {
          "RawBytes": "0705ff8102000400",
          "bLength": 7,
          "bDescriptorType": 5,
          "bInterval": 0,
          "bEndpointAddress": 129,
          "bmAttributes": 2,
          "wMaxPacketSize": 1024,
          "Derived": {
            "DescriptorType": "Endpoint",
            "EndpointAddress": 1,
            "Direction": "In",
            "Type": "Bulk"
          }
        },
        {
          "RawBytes": "06300f000000",
          "bLength": 6,
          "bDescriptorType": 48,
          "wBytesPerInterval": 0,
          "bMaxBurst": 15,
          "bmAttributes": 0,
          "Derived": {
            "DescriptorType": "SuperSpeedEndpointCompanion",
            "MaxStreams": 0,
            "Mult": 0,
            "SspCompanion": 0
          }
        },
        {
          "RawBytes": "07050202000400",
          "bLength": 7,
          "bDescriptorType": 5,
          "bInterval": 0,
          "bEndpointAddress": 2,
          "bmAttributes": 2,
          "wMaxPacketSize": 1024,
          "Derived": {
            "DescriptorType": "Endpoint",
            "EndpointAddress": 2,
            "Direction": "Out",
            "Type": "Bulk"
          }
        },
        {
          "RawBytes": "06300f000000",
          "bLength": 6,
          "bDescriptorType": 48,
          "wBytesPerInterval": 0,
          "bMaxBurst": 15,
          "bmAttributes": 0,
          "Derived": {
            "DescriptorType": "SuperSpeedEndpointCompanion",
            "MaxStreams": 0,
            "Mult": 0,
            "SspCompanion": 0
          }
        }
      ]
    },
    "Strings": {
      "1": "Kingston",
      "2": "DataTraveler 70",
      "3": "1831BFBD3065F551C96001E7"
    },
    "BOS": {
      "RawBytes": "050f160002",
      "bLength": 5,
      "bDescriptorType": 15,
      "Derived": {
        "DescriptorType": "BOS"
      },
      "wTotalLength": 22,
      "bNumDescriptors": 2,
      "Capabilities": [
        {
          "RawBytes": "07100206000000",
          "bLength": 7,
          "bDescriptorType": 16,
          "bDevCapabilityType": 2,
          "bmAttributes": 6,
          "Derived": {
            "DescriptorType": "DeviceCapability",
            "CapabilityType": "USB20Extension",
            "LPMCapable": 1,
            "BESLAndAlternateHIRDSupported": 1,
            "BaselineBESLValid": 0,
            "DeepBESLValid": 0,
            "BaselineBESL": 0,
            "DeepBESL": 0
          }
        },
        {
          "RawBytes": "0a1003000e00020affff07",
          "bLength": 10,
          "bDescriptorType": 16,
          "bDevCapabilityType": 3,
          "wU2DevExitLat": 2047,
          "bmAttributes": 0,
          "wSpeedsSupported": 14,
          "bFunctionalitySupport": 2,
          "bU1DevExitLat": 10,
          "Derived": {
            "DescriptorType": "DeviceCapability",
            "CapabilityType": "SuperSpeedUSB",
            "LTMCapable": 0,
            "SpeedsSupported": [
              "Full",
              "High",
              "SuperSpeed"
            ]
          }
        }
      ]
    }
  }
}

Feature Sets

The following feature sets are available:

All Cambrionix units support the base feature set.

The range of possible values for a tag in the base feature set can be extended if an additional feature set is also available. For example, Port.n.flags can only return a flag S (port is in Sync mode) on a device that also implements the sync feature set.

The Hardware key returns a value for the type of Cambrionix unit.

These are the extra feature sets CambrionixApiService supports for the various types of Cambrionix unit:

¹ It is to be noted that while the chargers with TypeC connections are always in sync mode unless the ports are turned off. This means that there is no need to switch between charge mode and sync mode.

² The ModIT Pro will identify itself as a ThunderSync3-16, but it has additional hardware for gate control.

Get Dictionary

Get Dictionary Variables

7

"Jul 08 2015 10:43:20"

Get EnabledProfiles

List of global profiles currently enabled

Example return value:

"1 2 3 4"

"1.55"

[
    {
        "Bootloader": "0.13",
        "Firmware": "1.83",
        "FormFactor": "un",
        "Group": "-",
        "Hardware": "PP15",
        "Manufacturer": "cambrionix",
        "PanelID": 0,
        "SerialNumber": "DN004ANJ"
    }
]

""

5.58

3.5

5.25

5.25

5.2

{
    "1": "open",
    "2": "closed",
    "3": "closing",
    "4": "opening"
}

"-"

"ThunderSync3-16"

"SLET"

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "ProductName": "ThunderSync3-C10",
    "ProductWebPage": "https://www.cambrionix.com/products/thundersync3-c10",
    "TemperatureRangeC": {
      "Min": 10,
      "Max": 35
    },
    "HumidityRange": {
      "Min": 5,
      "Max": 95
    },
    "DimensionsMillimetres": {
      "Width": 136,
      "Length": 193,
      "Height": 34
    },
    "HostPortType": "Thunderbolt 3",
    "HostPortBandwidth": "40Gbps",
    "HubMaxPowerOutputWatts": 150,
    "Ports": {
      "1": {
        "HardwareInformation": {
          "Type": "USB Type-C",
          "Bandwidth": "5Gbps",
          "VoltageMax": 5.2,
          "MilliampsMax": 3000
        }
      },
      // etc for each port
    }
  }
}

true

"OV UV"

24.7

9.59

24.03

24.14

23.82

0

true

8

"Absent"

{
    "CurrentLevel": 78,
    "CurrentTime": 15234254346,
    "StartLevel": 23,
    "StartTime": 15124151512,
}

0

"SuperPhone6"

0.0

# Windows
{
    "Path:": "H:\\",
    "Capacity": 123123123,
    "Available": 123123,
    "Volumes": [
        {
            "Path:": "H:\\",
            "Capacity": 123123123,
            "Available": 123123,
            "Label": "Volume Label 1",
            "Index": 1,
            "FileSystem": "exFAT"
        },
        {
            "Path:": "I:\\",
            "Capacity": 123123123,
            "Available": 123123,
            "Label": "Volume Label 2",
            "Index": 2,
            "FileSystem": "NTFS"
        }
    ]
}

# macOS
{
    "Path:": "/Volumes/Volume\ Label\ 1",
    "Capacity": 123123123,
    "Available": 123123,
    "Volumes": [
        {
            "Path:": "/Volumes/Volume\ Label\ 1",
            "Capacity": 123123123,
            "Available": 123123,
            "Label": "Volume Label 1",
            "Index": 1,
            "FileSystem": "exFAT"
        },
        {
            "Path:": "/Volumes/Volume\ Label\ 2",
            "Capacity": 123123123,
            "Available": 123123,
            "Label": "Volume Label 2",
            "Index": 2,
            "FileSystem": "NTFS"
        }
    ]
}

# Linux
{
    "Path:": "/media/bob/Volume\ Label\ 1",
    "Capacity": 123123123,
    "Available": 123123,
    "Volumes": [
        {
            "Path:": "/media/bob/Volume\ Label\ 1",
            "Capacity": 123123123,
            "Available": 123123,
            "Label": "Volume Label 1",
            "Index": 1,
            "FileSystem": "exFAT"
        },
        {
            "Path:": "/media/bob/Volume\ Label\ 2",
            "Capacity": 123123123,
            "Available": 123123,
            "Label": "Volume Label 2",
            "Index": 2,
            "FileSystem": "NTFS"
        }
    ]
}

# Bus 21, port 2, port 1
0x21210000

# In this case, the parent hub for the device would be 0x21200000.

"R D S"

"SuperPhone Makers Inc."

0

0

"1 2 3 4"

"1127dfa9037s1a8cb1"

-1

0

{
    "SerialNumber": "23213dfe12e2412",
    "Description": "SuperPhone6",
    "Manufacturer": "SuperPhone Makers Inc."
}

0

520

{
  "id": 5,
  "jsonrpc": "2.0",
  "method": "cbrx_connection_get",
  "params": [
    handle,
    "Port.all.LocationID"
  ]
}

{
  "jsonrpc": "2.0",
  "id": 5,
  "result": {
    "1": {
      "USB2": 591466496,
      "USB3": 3812691968
    },
    "2": {
      "Current": 591470592,
      "USB2": 591470592,
      "USB3": 3812696064
    },
    "3": {
      "USB2": 591597568,
      "USB3": 3812823040
    },
    "4": {
      "Current": 591601664,
      "USB2": 591601664,
      "USB3": 3812827136
    }
  }
}

{
  "id": 5,
  "jsonrpc": "2.0",
  "method": "cbrx_connection_get",
  "params": [
    handle,
    "Port.all.LocationID",
    "USB2"
  ]
}

{
  "jsonrpc": "2.0",
  "id": 5,
  "result": {
    "1": 591466496,
    "2": 591470592,
    "3": 591597568,
    "4": 591601664
  }
}

{
  "Port.1": {
    "Port": 1,
    "Current_mA": 22,
    "Flags": "R A S",
    "LocationID": 591470592,
    "USBVersion": 2.0,
    "VID": 1452,
    "PID": 4779,
    "Manufacturer": "SuperPhone Makers Inc.",
    "Description": "SuperPad",
    "SerialNumber": "c13d62e0c8bef04ff4b48b4748b020be76725d5d",
    "DeviceType": "Apple" | "Android",  // Currently only present for "Apple" and "Android" devices
    "Battery": {
      "DataSource": "imobiledevice",
      "TrustLevel": "paired",
      "PairingSupported": true,
      "HealthPercent": 95,
      "CurrentLevel": 100,
      "CurrentTime": 1613056296,
      "StartingLevel": 100,
      "StartingTime": 1613056293,
      "CapacityNew": 1751,
      "Capacity": 1678,
      "ChargingStatus": "full"
    },
    "USBTree": {
      "LocationID": 591470592,
      "USBVersion": 2.0,
      "USBPower": {
        "State": "D0",
        "Description": "On"
      },
      "USBSpeed": {
        "Speed": "480Mbps",     // Currently any of "1.5Mbps", "12Mbps", "480Mbps", "5Gbps", "10Gbps", "20Gbps", "40Gbps"
        "Description": "High"   // Any of "Low", "Full", "High",
                                // "SuperSpeed USB 5Gbps", "SuperSpeed USB 10Gbps", "SuperSpeed USB 20Gbps",
                                // "SuperSpeed USB 40Gbps", "USB4® 10Gbps", "USB4® 20Gbps", "USB4® 40Gbps"
      },
      "Endpoints": {
        "Active": 6,
        "Maximum": 8,
        "Memory": 32768         // Amount of memory used (in bytes) for this node on the USB tree
      },
      "USBConnectionError": "string", // Only present on Windows if a device error occurs
                                // "DeviceFailedEnumeration" | "DeviceGeneralFailure" |
                                // "DeviceCausedOvercurrent" | // "DeviceNotEnoughPower" |
                                // "DeviceNotEnoughBandwidth" | "DeviceHubNestedTooDeeply" |
                                // "DeviceInLegacyHub" | "DeviceEnumerating" | "DeviceReset",
      "USBErrors": [    // Only present if any errors are detected
        // Errors can be any of the following:
        "No open pipes : USB stack has not loaded the device",
        "Invalid Device Descriptor : bLength was <N> instead of 18",
        "Invalid Device Descriptor : Low speed devices require bMaxPacketSize0 = 8 (<N> was given)",
        "Invalid Device Descriptor : Full Speed devices require bMaxPacketSize0 = 8, 16, 32, or 64 (<N> was given)",
        "Invalid Device Descriptor : High Speed devices require bMaxPacketSize0 = 64 (<N> was given)",
        "Invalid Device Descriptor : SuperSpeed devices require bMaxPacketSize0 = 9 (512) (<N> was given)",
        "Invalid Device Descriptor : SuperSpeed device reporting less than USB 3.0",
        "Invalid Device Qualifier Descriptor : bLength was <N> instead of 10",
        "Invalid Other Speed Configuration Descriptor : bLength was <N> instead of 10",
        "Invalid Configuration Descriptor : bLength was <N> instead of 9",
        "Invalid Interface Descriptor : bLength was <N> instead of 9 or 11",
        "Invalid Endpoint Descriptor : bLength was <N> instead of 7 or 8",
        "Invalid HID Descriptor : bLength was <N> instead of >= 9",
        "Invalid OTG Descriptor : bLength was <N> instead of 3",
        "Invalid InterfaceAssociation Descriptor : bLength was <N> instead of 8",
        "Invalid BOS SuperSpeedUSB Descriptor : bLength was <N> instead of 10",
        "Invalid BOS SuperSpeedPlusUSB Descriptor : bLength was <N> instead of >= 16",
        "Invalid BOS Billboard Descriptor : bLength was <N> instead of >= 48",
        "Invalid BOS ContainerID Descriptor : bLength was <N> instead of 20",
        "Invalid BOS FirmwareStatus Descriptor : bLength was <N> instead of 8",
        "Invalid BOS PDConsumerPort Descriptor : bLength was <N> instead of 24",
        "Invalid BOS Platform Descriptor : bLength was <N> instead of >= 21",
        "Invalid BOS PowerDelivery Descriptor : bLength was <N> instead of 18",
        "Invalid BOS USB20Extension Descriptor : bLength was <N> instead of 7"
      ]

    }
  },
  "Port.2": {
    "Port": 2,
    "Current_mA": 0,
    "Flags": "R D S",
    "LocationID": 591597568
  },
  "Port.3": ...
}

false

100

true

false

"cambrionix U8S-EXT 8 Port USB Charge+Sync"

37.7

""

65.0

39.9

0

3.4

""

14.5

9.59

12.43

12.52

12.31

151304

Set Dictionary

# Example - setting all ports to sync mode
cbrx_connection_set(handle, 'Mode', 's')

{
    "id": 0,
    "jsonrpc": "2.0",
    "method": "cbrx_connection_set",
    "params": [
        handle,
        "Mode",
        "s"
    ]
}

# Example - setting port 1 to charge mode
cbrx_connection_set(handle, 'Port.1.mode', 'c')

{
    "id": 0,
    "jsonrpc": "2.0",
    "method": "cbrx_connection_set",
    "params": [
        handle,
        "Port.1.Mode",
        "c"
    ]
}