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.
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.
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];
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]){
...
}