Sensor

Creating

You need to create a device using a scanner. All manipulations with the device will be performed without errors only if the device is connected.

OpStatus outStatus;
SensorInfo sensorInfo;
Sensor* sensor = createSensor(scanner, sensorInfo, &outStatus);

BrainBit sensor = (BrainBit)scanner.createSensor(sensorInfo);

var sensor: Sensor? = scanner.createSensor(deviceInfo) as BrainBit

BrainBitSensor sensor = scanner.CreateSensor(sensorInfo) as BrainBitSensor;

BrainBit sensor = scanner.CreateSensor(sensorInfo) as BrainBit;

sensor = scanner.create_sensor(sensInfo)

var sensor = scanner.createSensor(deviceInfo) as? NTBrainBit

NTBrainBit* sensor = (NTBrainBit*)[scanner createSensor:deviceInfo];

Device creation is a blocking method, so it must be called from separate thread.

For all types of devices, you can use the same methods to control the device's connection status, invoke commands, and check for functionality.

Manage connection state

Connection status can be obtained in two ways.

The first one is using the sensor property `State`.

The second way is in real time using a callback:

void onConnectionStateCallback(Sensor* sensor, SensorState State, void* userInfo)
{

}

OpStatus outStatus;
SensorStateListenerHandle lhandle = nullptr;
addConnectionStateCallback(sensor, onConnectionStateCallback, &lhandle, nullptr, &outStatus);

sensor.sensorStateChanged = state -> {
    Log.i("TAG", state.toString());
};
...
sensor.sensorStateChanged = null;

sensor.sensorStateChanged = Sensor.SensorStateChanged { state ->
    Log.i("TAG", state.toString())
}
...
sensor.sensorStateChanged = null

private void EventSensorStateChanged(ISensor sensor, SensorState sensorState)
{
    Console.WriteLine(sensorState);
}
...
sensor.EventSensorStateChanged += EventSensorStateChanged;
...
sensor.EventSensorStateChanged -= EventSensorStateChanged;

sensor.AddConnectionChanged((state)=>{           
    console.log(SensorState(state))
})
...
sensor.RemoveConnectionChanged()

def on_sensor_state_changed(sensor, state):
    print('Sensor {0} is {1}'.format(sensor.Name, state))

sensor.sensorStateChanged = on_sensor_state_changed
...
sensor.sensorStateChanged = None

sensor.setConnectionStateCallback(sensorStateCallback)
...
sensor.setConnectionStateCallback(nil)

[scanner setConnectionStateCallback:sensorStateCallback];
...
[scanner setConnectionStateCallback:nil];

A connection can be in two states: connected (InRange) and disconnected (OutOfRange).

Important! The state change callback will not come after the device is created, only after disconnecting (device lost from the scope or using a method) and then connected. The device does not automatically reconnect.

You can connect and disconnect from device manually by methods `Connect()` and `Disconnect()`. To receive connection state in real time you need to subscribe to `stateChanged` event. Also you can get connection state by sensor's parameter.

OpStatus outStatus;
connectSensor(sensor, &outStatus);

disconnectSensor(sensor, &outStatus);

sensor.disconnect();
...
sensor.connect();

sensor.disconnect()
...
sensor.connect()

sensor.Disconnect();
...
sensor.Connect();

sensor.Disconnect()
...
sensor.Connect()

sensor.disconnect()
...
sensor.connect()

sensor.disconnect()
...
sensor.connect()

[sensor Disconnect];
...
[sensor Connect];

Method `Connect` is blocking too, so it need to be call from separate thread.

Manage device parameters

Battery

Also, you can get power value from each device by sensor property `BattPower` or by callback in real time:

void onBatteryCallback(Sensor* sensor, int32_t battery, void* userData)
{

}

OpStatus outStatus;
BattPowerListenerHandle lhandle = nullptr;
addBatteryCallback(sensor, onBatteryCallback, &lhandle, nullptr, &outStatus);

sensor.batteryChanged = battery -> {
    Log.i("TAG", "Power: " + battery);
};
...
sensor.batteryChanged = null

sensor.batteryChanged = Sensor.BatteryChanged { power ->
    Log.i("TAG", power.toString())
}
...
sensor.batteryChanged = null

private void EventBatteryChanged(ISensor sensor, int battPower)
{
    Console.WriteLine("Power: " + battPower);
}
...
sensor.EventBatteryChanged += EventBatteryChanged;
...
sensor.EventBatteryChanged -= EventBatteryChanged;

sensor.AddBatteryChanged((power)=>{
    console.log(power)
})
...
sensor.RemoveBatteryChanged()

def on_battery_changed(sensor, battery):
    print('Battery: {0}'.format(battery))
...
sensor.batteryChanged = on_battery_changed
...
sensor.batteryChanged = None

sensor.setBatteryCallback(devicePowerCallback)
...
sensor.setBatteryCallback(nil)

[sensor setBatteryCallback:batteryChanged];
...
[sensor setBatteryCallback:nil];

Parameters

Each device has its own settings, and some of them can be configured as you need. Not all settings can be changed and not every device supports all settings.

First you need to find out what parameters the device supports and whether they can be changed:

int32_t szSensorParametersInOut = getParametersCountSensor(sensor);
ParameterInfo sensor_parameter[szSensorParametersInOut];
OpStatus outStatus;
getParametersSensor(sensor, sensor_parameter, &szSensorParametersInOut, &outStatus);

List<ParameterInfo> parameters = sensor.getSupportedParameters();
parameters.forEach(parameter -> Log.i("TAG", parameter.getParam() + ": " + parameter.getParamAccess()));

// Output:
// 
// ParameterGain: ReadWrite  
// ParameterState: ReadNotify

val parameters = sensor.supportedParameters
parameters?.forEach { parameter ->
    Log.i(
        "TAG",
        "${parameter.param}: ${parameter.paramAccess}"
    )
}

// Output:
// 
// ParameterGain: ReadWrite  
// ParameterState: ReadNotify

var parameters = sensor.Parameters;

console.log(sensor.Parameters.map(parameter => SensorParameter[parameter.Param] + ": " + SensorParamAccess[parameter.ParamAccess]))

// Output:
//
// ["Name: Read", 
// "FirmwareMode: Read", 
// "FirmwareVersion: Read", 
// "State: ReadNotify", ... ]

print(sensor.parameters) 

# Output:
# 
# [ParameterInfo(Param=<SensorParameter.ParameterOffset: 8>, ParamAccess=<SensorParamAccess.ParamAccessRead: 0>),  
# ParameterInfo(Param=<SensorParameter.ParameterState: 1>,  ParamAccess=<SensorParamAccess.ParamAccessReadNotify: 2>)
# ...]

var parameters = sensor.Parameters

NSArray<NTParameterInfo*>* parameters = [sensor Parameters];

Info about parameter includes two fields:
- the name of the parameter, represented by an enumeration
- parameter availability for manipulation.

Can be one of three values:
- read - read-only
- read and write - parameter can be changed
- read and notify - parameter is updated over time

You can also check if the parameter is supported, for example `Gain`:

if(isSupportedParameterSensor(sensor, SensorParameter::ParameterGain)){
    ...
}

if(sensor.isSupportedParameter(SensorParameter.ParameterGain)){
...
}

if(sensor.isSupportedParameter(SensorParameter.ParameterGain) == true){
...
}

if(sensor.IsSupportedParameter(SensorParameter.ParameterGain)){
...
}

if(sensor.IsSupportedParameter(SensorParameter.Gain)){
    ...
}

if sensor.is_supported_parameter(SensorParameter.ParameterGain):
    ...

if(sensor.isSupportedParameter(.gain)){
...
}

if([sensor IsSupportedParameter:NTSensorParameterGain]){
...
}