BrainBit SDK2

https://sdk.brainbit.com/sdk2_
Admin
BrainBit SDK2 is a cross-platform software development kit for connecting to and receiving data from...
Tokens:25,335
Snippets:193
Trust Score:8.4
Update:9 months ago
Show doc for...
Tokens:
Raw
### Install libneurosdk2.deb on Linux

Source: https://sdk.brainbit.com/sdk2_/python_install

Installs the libneurosdk2.deb package on Linux distributions. This involves downloading the package and then installing it using apt.

```bash
sudo apt install ./libneurosdk2.deb
```

--------------------------------

### Install pyneurosdk2 using pip

Source: https://sdk.brainbit.com/sdk2_/python_install

Installs the pyneurosdk2 library using pip, a package installer for Python. This is the primary method for Python installations on supported platforms.

```bash
pip install pyneurosdk2
```

--------------------------------

### macOS Manual Library Installation

Source: https://sdk.brainbit.com/sdk2_/ios_install

Instructions for manually installing the neurosdk2 library on macOS. This involves downloading the .dylib file, adding it to your project, including headers, and configuring Library search paths.

```bash
# 1. Download libneurosdk.dylib from GitHub (macos folder)
# 2. Add to Xcode project: Frameworks, Libraries, and Embedded Content
# 3. Add headers from GitHub (macos folder)
# 4. Add path to library to 'Library search paths'
```

--------------------------------

### iOS Manual Framework Installation

Source: https://sdk.brainbit.com/sdk2_/ios_install

Steps for manually installing the neurosdk2 framework on iOS. This includes downloading the xcframework, adding it to your project's Frameworks, Libraries, and Embedded Content section, setting 'Embed & Sign', and configuring Framework search paths.

```bash
# 1. Download neurosdk2.xcframework from GitHub (iOS folder)
# 2. Add to Xcode project: Frameworks, Libraries, and Embedded Content
# 3. Set 'Embedded' to 'Embed & Sign'
# 4. Add path to framework to 'Framework search paths'
```

--------------------------------

### Install SDK2 on macOS using CocoaPods

Source: https://sdk.brainbit.com/sdk2_/macos_install

Instructions for installing the neurosdk2 framework on macOS using CocoaPods. This method requires adding the SDK to your Podspec file and running 'pod install'.

```bash
pod 'neurosdk2', '1.0.19'
```

--------------------------------

### Install libneurosdk2.deb on Linux using apt

Source: https://sdk.brainbit.com/sdk2_/linux_install

This snippet shows how to install the libneurosdk2.deb package on Linux distributions that use the apt package manager. Ensure you have downloaded the correct .deb file for your system.

```bash
sudo apt install ./libneurosdk2.deb

```

--------------------------------

### Accessing SensorFamily in Dart

Source: https://sdk.brainbit.com/sdk2_/par_desc

Illustrates retrieving the SensorFamily in Dart. This example uses `await` to get the value, suggesting an asynchronous operation for accessing the sensor family.

```dart
FSensorFamily sensFamily = await sensor.sensFamily.value;
            

```

--------------------------------

### Get Sensor Parameters (Kotlin)

Source: https://sdk.brainbit.com/sdk2_/deviceinfo

Retrieves supported sensor parameters and logs their names and access rights. This Kotlin snippet demonstrates how to access and display device configuration options, similar to the Java example. It uses a `forEach` loop for iteration.

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

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

--------------------------------

### iOS Installation with Cocoapods

Source: https://sdk.brainbit.com/sdk2_/ios_install

Instructions for installing the neurosdk2 library on iOS using Cocoapods. This involves adding the pod to your Podspec file and running 'pod install'. Ensure your OS version is 12.0 or higher.

```ruby
pod 'neurosdk2', '1.0.23'
```

--------------------------------

### Install ReactNative SDK

Source: https://sdk.brainbit.com/sdk2_/rn_install

Installs the react-native-neurosdk2 package using npm. This is the primary step for integrating the SDK into a React Native project.

```bash
$ npm install react-native-neurosdk2 --save
```

--------------------------------

### Get Sensor Parameters (Python)

Source: https://sdk.brainbit.com/sdk2_/deviceinfo

Prints the parameters supported by a sensor, including their names and access modes. This Python snippet iterates through a list of ParameterInfo objects and displays them. It shows an example output with specific parameter types and their access rights.

```python
print(sensor.parameters)

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

--------------------------------

### Accessing SensorFamily in C#

Source: https://sdk.brainbit.com/sdk2_/par_desc

Provides an example of how to obtain the SensorFamily in C#. This involves accessing the `SensFamily` property of the sensor object.

```csharp
SensorFamily sensFamily = sensor.SensFamily;
            

```

```csharp
NTSensorFamily sensFamily = sensor.SensFamily;
            

```

--------------------------------

### Receive BrainBit Resistance Data (C#)

Source: https://sdk.brainbit.com/sdk2_/bb

This C# code illustrates how to subscribe to the `EventBrainBitResistDataRecived` event to receive resistance data and use `ExecCommand` to start and stop the data stream. Unsubscribing from the event stops the data reception.

```csharp
private void onBrainBitResistDataRecived(ISensor sensor, BrainBitResistData data)
{
    Console.WriteLine("Data: " + data);
}
...
sensor.EventBrainBitResistDataRecived += onBrainBitResistDataRecived;
sensor.ExecCommand(SensorCommand.CommandStartResist);
...
sensor.EventBrainBitResistDataRecived -= onBrainBitResistDataRecived;
sensor.ExecCommand(SensorCommand.CommandStopResist);
```

--------------------------------

### Accessing SensorFamily in Python

Source: https://sdk.brainbit.com/sdk2_/par_desc

Shows how to access the SensorFamily in Python. Python typically uses snake_case for attribute names, as shown in the example.

```python
sensFamily = sensor.sens_family
            

```

--------------------------------

### Get Sensor Parameters (TypeScript)

Source: https://sdk.brainbit.com/sdk2_/deviceinfo

Retrieves sensor parameters and formats their names and access levels for display in the console. This TypeScript example maps over the parameters array and uses string interpolation for output. It relies on `SensorParameter` and `SensorParamAccess` enums.

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

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

--------------------------------

### MAUI Initialization for Android

Source: https://sdk.brainbit.com/sdk2_/maui_install

Initializes the NeuroSDK2 library for MAUI applications on Android. This code snippet demonstrates how to conditionally include the SDK initialization based on the target platform, ensuring proper setup for Android devices.

```csharp
public static MauiApp CreateMauiApp()
{
var builder = MauiApp.CreateBuilder();
#if ANDROID
builder.UseNeurosdk2();
#endif
return builder.Build();
}
```

--------------------------------

### Start Device Scan

Source: https://sdk.brainbit.com/sdk2_/scanner

Initiates the search for available BrainBit devices. This function typically starts a background process that discovers nearby sensors. Ensure the scanner object is properly initialized before calling this method.

```cpp
OpStatus outStatus;

startScanner(scanner, &outStatus);
```

```java
scanner.start();
```

```kotlin
scanner.start();
```

```csharp
scanner.Start();
```

```typescript
scanner.Start()
```

```python
scanner.start()
```

```swift
scanner?.startScan()
```

```objectivec
[scanner startScan];
```

```dart
await scanner.start();
```

--------------------------------

### Receive BrainBit Resistance Data (Swift)

Source: https://sdk.brainbit.com/sdk2_/bb

This Swift code snippet demonstrates setting a resistance data callback using `setResistCallbackBrainBit`, starting resistance measurement with `execCommand`, and clearing the callback by setting it to nil.

```swift
sensor.setResistCallbackBrainBit( { data in
    print(data)
})
sensor.execCommand(.startResist)
...
sensor.setResistCallbackBrainBit(nil);
sensor.execCommand(.stopResist)
```

--------------------------------

### Initializing XNeuroSDK in Xamarin (Android Main Activity)

Source: https://sdk.brainbit.com/sdk2_/xamarin_install

This C# code snippet shows how to initialize the XNeuroSDK by calling `NeuroSDK.NeuroSDKSetup.Initialize()` within the `OnCreate` method of your Android `MainActivity`. This should be done before `LoadApplication`.

```csharp
protected override void OnCreate(Bundle savedInstanceState)
{
    base.OnCreate(savedInstanceState);
	...
    NeuroSDK.NeuroSDKSetup.Initialize();

    LoadApplication(new App());
}
```

--------------------------------

### Receive BrainBit Resistance Data (Kotlin)

Source: https://sdk.brainbit.com/sdk2_/bb

This Kotlin code demonstrates setting a callback for BrainBit resistance data and executing commands to start and stop data reception. The callback is assigned to `sensor.brainBitResistDataReceived` and set to null to cease listening.

```kotlin
sensor.brainBitResistDataReceived = BrainBitResistDataReceived { data ->
    Log.i("TAG", data.toString())
}
sensor.ExecCommand(SensorCommand.StartResist)
...
sensor.brainBitResistDataReceived = null
sensor.ExecCommand(SensorCommand.StopResist)
```

--------------------------------

### Receive BrainBit Resistance Data (Objective-C)

Source: https://sdk.brainbit.com/sdk2_/bb

This Objective-C code shows how to set a resistance data callback using `setResistCallbackBrainBit`, start resistance measurement with `ExecCommand`, and remove the callback by setting it to nil. Note the use of `NTBrainBitResistData` and `NTSensorCommand`.

```objectivec
[sensor setResistCallbackBrainBit:^(NTBrainBitResistData * _Nonnull data) {
                      
}];
[sensor ExecCommand:NTSensorCommandStartResist];
...
[sensor setResistCallbackBrainBit:nil];
[sensor ExecCommand:NTSensorCommandStopResist];
```

--------------------------------

### Receive BrainBit Resistance Data (C++)

Source: https://sdk.brainbit.com/sdk2_/bb

This C++ code demonstrates how to add a callback for receiving BrainBit resistance data, start receiving the data, and then stop and remove the callback. It utilizes the `addResistCallbackBrainBit`, `execCommandSensor`, and `removeResistCallbackBrainBit` functions.

```cpp
void onBrainBitBlackResistDataReceived(Sensor *pSensor, BrainBitResistData data, void *pVoid)
{

}
OpStatus outStatus;
BrainBitResistDataListenerHandle lHandle = nullptr;
addResistCallbackBrainBit(_sensor, onBrainBitBlackResistDataReceived, &lHandle, nullptr, &outStatus);
execCommandSensor(_sensor, SensorCommand::CommandStartResist, &outStatus);
...
execCommandSensor(_sensor, SensorCommand::CommandStopResist, &outStatus);
removeResistCallbackBrainBit(lHandle);
```

--------------------------------

### Receive BrainBit Resistance Data (Java)

Source: https://sdk.brainbit.com/sdk2_/bb

This Java code shows how to set a listener for BrainBit resistance data and execute commands to start and stop receiving this data. The listener is assigned to `sensor.brainBitResistDataReceived` and set to null to stop listening.

```java
sensor.brainBitResistDataReceived = data -> {
    Log.i("TAG", Arrays.toString(data));
};
sensor.ExecCommand(SensorCommand.StartResist);
...
sensor.brainBitResistDataReceived = null
sensor.ExecCommand(SensorCommand.StopResist);
```

--------------------------------

### Receive BrainBit Resistance Data (TypeScript)

Source: https://sdk.brainbit.com/sdk2_/bb

This TypeScript code shows how to add a callback for resistance changes using `AddBrainBitResistanceChanged`, start resistance measurement with `ExecuteCommand`, and remove the callback with `RemoveBrainBitResistanceChanged`.

```typescript
sensor.AddBrainBitResistanceChanged((data)=>{
    console.log(data)
}); 
sensor.ExecuteCommand(SensorCommand.StartResist)
...
sensor.RemoveBrainBitResistanceChanged();
sensor.ExecuteCommand(SensorCommand.StopResist)
```

--------------------------------

### Install neurosdk2 Package for Flutter

Source: https://sdk.brainbit.com/sdk2_/flutter_install

This snippet shows how to add the neurosdk2 package to your Flutter project using the Flutter CLI or by manually editing the pubspec.yaml file. It's the recommended way to integrate the SDK into your Flutter application.

```bash
$ flutter pub add neurosdk2
```

```yaml
dependencies:
  neurosdk2: ^1.0.13
```

--------------------------------

### Accessing SensorFamily in Java

Source: https://sdk.brainbit.com/sdk2_/par_desc

Shows how to get the SensorFamily from a sensor object in Java. This typically uses a getter method provided by the sensor class.

```java
SensorFamily sensFamily = sensor.getSensFamily();
            

```

--------------------------------

### Receive BrainBit Signal Data Across Languages

Source: https://sdk.brainbit.com/sdk2_/bb

This snippet demonstrates how to subscribe to signal data, start and stop data transmission, and unsubscribe from data callbacks for the BrainBit SDK. It covers multiple programming languages, including C++, Java, Kotlin, C#, TypeScript, Python, Swift, Objective-C, and Dart. Ensure the sensor object is properly initialized before use. Signal data is received in volts.

```C++
void onBrainBitSignalDataReceived(Sensor *pSensor, BrainBitSignalData *pData, int32_t size, void *userData)
{

}
OpStatus outStatus;
BrainBitSignalDataListenerHandle lHandle = nullptr;
addSignalDataCallbackBrainBit(_sensor, onBrainBitSignalDataReceived, &lHandle, nullptr, &outStatus);
execCommandSensor(_sensor, SensorCommand::CommandStartSignal, &outStatus);
...
execCommandSensor(_sensor, SensorCommand::CommandStopSignal, &outStatus);
removeSignalDataCallbackBrainBit(lHandle);
```

```Java
sensor.brainBitSignalDataReceived = data -> {
    Log.i("TAG", Arrays.toString(data));
};
sensor.execCommand(SensorCommand.StartSignal);
...
sensor.brainBitSignalDataReceived = null
sensor.execCommand(SensorCommand.StopSignal);
```

```Kotlin
sensor.brainBitSignalDataReceived = BrainBitSignalDataReceived { data ->
    Log.i("TAG", data.toString())
}
sensor.execCommand(SensorCommand.StartSignal)
...
sensor.brainBitSignalDataReceived = null
sensor.execCommand(SensorCommand.StopSignal)
```

```C#
private void onBrainBitSignalDataRecived(ISensor sensor, BrainBitSignalData[] data)
{
    Console.WriteLine("Data: " + data);
}
...
sensor.EventBrainBitSignalDataRecived += onBrainBitSignalDataRecived;
sensor.ExecCommand(SensorCommand.CommandStartSignal);
...
sensor.EventBrainBitSignalDataRecived -= onBrainBitSignalDataRecived;
sensor.ExecCommand(SensorCommand.CommandStopSignal);
```

```TypeScript
sensor.AddBrainBitSignalChanged((data)=>{
    console.log(data)
}); 
sensor.ExecuteCommand(SensorCommand.StartSignal)
...
sensor.RemoveBrainBitSignalChanged();
sensor.ExecuteCommand(SensorCommand.StopSignal)
```

```Python
def on_brain_bit_signal_data_received(sensor, data):
    print(data)
...
sensor.signalDataReceived = on_brain_bit_signal_data_received
sensor.exec_command(SensorCommand.CommandStartSignal)
...
sensor.signalDataReceived = None
sensor.exec_command(SensorCommand.CommandStopSignal)
```

```Swift
sensor.setSignalDataCallbackBrainBit( { data in
    print(data)
})
sensor.execCommand(.startSignal)
...
sensor.setSignalDataCallbackBrainBit(nil);
sensor.execCommand(.stopSignal)
```

```Objective-C
[sensor setSignalDataCallbackBrainBit:^(NSArray<NTBrainBitSignalData *> * _Nonnull data) {
                      
}];
[sensor ExecCommand:NTSensorCommandStartSignal];
...
[sensor setSignalDataCallbackBrainBit:nil];
[sensor ExecCommand:NTSensorCommandStopSignal];
```

```Dart
StreamSubscription<List<BrainBitSignalData>>? signalSubscription = sensor.signalDataStream.listen((data) => print("Signal values: $data"));
await sensor.execute(FSensorCommand.startSignal);
...
signalSubscription.cancel();
await sensor.execute(FSensorCommand.stopSignal);
```

--------------------------------

### Get Sensor Parameters (Java)

Source: https://sdk.brainbit.com/sdk2_/deviceinfo

Fetches the list of supported parameters for a sensor and logs each parameter's name and access level. This is useful for understanding device configuration capabilities. It iterates through a List<ParameterInfo> and prints relevant details.

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

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

--------------------------------

### Get Discovered Devices

Source: https://sdk.brainbit.com/sdk2_/scanner

This API allows you to retrieve a list of all currently discoverable BrainBit devices. The method is available across multiple programming languages.

```APIDOC
## Get Discovered Devices

### Description
Retrieves a list of all discoverable BrainBit devices.

### Method
Not applicable (this is a method call within the SDK).

### Endpoint
Not applicable (this is a method call within the SDK).

### Parameters
None

### Request Example
```c++
int32_t szSensorsInOut = 32;
SensorInfo* sensors = new SensorInfo[szSensorsInOut];
OpStatus outStatus;
sensorsScanner(scanner, sensors, &szSensorsInOut, &outStatus);
```

```java
List<SensorInfo> sensors = scanner.getSensors();
```

```kotlin
var sensors: List<SensorInfo>?  = scanner.sensors
```

```csharp
IReadOnlyList<SensorInfo> sensors = scanner.Sensors;
```

```typescript
var sensors = await scanner.Sensors()
```

```python
sensors = scanner.sensors()
```

```swift
var sensors = scanner?.sensors
```

```objective-c
NSArray<NTSensorInfo*>* sensors = scanner.sensors;
```

```dart
List<FSensorInfo?> sensors = await scanner.getSensors();
```

### Response
#### Success Response (200)
- **sensors** (Array of SensorInfo) - A list containing information about each discovered device.

#### Response Example
```json
{
  "sensors": [
    {
      "Name": "BrainBit Device 1",
      "Address": "XX:XX:XX:XX:XX:XX",
      "SerialNumber": "SN12345",
      "SensFamily": "SensorFamilyTypeA",
      "SensModel": 1,
      "PairingRequired": 0,
      "RSSI": -75
    },
    {
      "Name": "BrainBit Device 2",
      "Address": "YY:YY:YY:YY:YY:YY",
      "SerialNumber": "SN67890",
      "SensFamily": "SensorFamilyTypeB",
      "SensModel": 2,
      "PairingRequired": 1,
      "RSSI": -80
    }
  ]
}
```
```

--------------------------------

### Add JitPack Repository to settings.gradle (Groovy/Kotlin)

Source: https://sdk.brainbit.com/sdk2_/android_install

This snippet shows how to add the JitPack repository to your project's settings.gradle file to enable dependency resolution for the BrainBit SDK. This is a one-time setup for the project.

```groovy
dependencyResolutionManagement {
		repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
		repositories {
			...
			maven { url 'https://jitpack.io' }
		}
	}
            
```

```kotlin
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        ...
        maven { setUrl("https://jitpack.io") }
    }
}
            
```

--------------------------------

### Get Device Firmware Version (C#)

Source: https://sdk.brainbit.com/sdk2_/par_desc

Retrieves the firmware version of the sensor. The firmware version is stored in the 'version' parameter. It handles sensor communication and provides version details.

```csharp
SensorVersion version = sensor.Version;

**SensorVersion:**

| Field | Type | Description |
|--|--|--|
|FwMajor|uint|firmware major|
|FwMinor|uint|firmware minor|
|FwPatch|uint|firmware patch|
|HwMajor|uint|hardware major|
|HwMinor|uint|hardware minor|
|HwPatch|uint|hardware patch|
|ExtMajor|uint|extension major|
```

--------------------------------

### Get Supported Sensor Commands

Source: https://sdk.brainbit.com/sdk2_/deviceinfo

Retrieves a list of commands that the sensor device can execute. This function populates an array with SensorCommand structures, providing details about available operations. Understanding the command set is vital for device interaction.

```C++
auto* sensor = reinterpret_cast<Sensor*>(sensor_ptr);
int32_t szSensorCommandsInOut = getCommandsCountSensor(sensor);
SensorCommand commands[szSensorCommandsInOut];
OpStatus outStatus;
getCommandsSensor(sensor, commands, &szSensorCommandsInOut, &outStatus);
```

```Java
List<SensorCommand> commands = sensor.getSupportedCommand();
commands.forEach(command -> Log.i("TAG", command.toString()));

// Output:
//
// StartSignal
// StopSignal
// StartResist
// StopResist
```

```Kotlin
val commands: List<SensorCommand> = sensor.supportedCommand
commands!!.forEach { command: SensorCommand ->
    Log.i(
        "TAG",
        command.toString()
    )
}

// Output:
//
// StartSignal
// StopSignal
// StartResist
// StopResist
```

```C#
IReadOnlyList<SensorCommand> commands = sensor.Commands;
```

```TypeScript
console.log(sensor.Commands.map(command => SensorCommand[command]))

// Output:
//
// ["StartSignal", "StopSignal", ...]
```

```Python
print(sensor.commands)

# Output:
# 
# [<SensorCommand.CommandStartSignal: 0>,...]
```

```Swift
var commands = sensor.commands
```

```Objective-C
NSArray<NSNumber*>* commands = [sensor Commands];
```

```Dart
Set<FSensorCommand> commands = await sensor.commands.value;
```

--------------------------------

### Get Device Firmware Version (Kotlin)

Source: https://sdk.brainbit.com/sdk2_/par_desc

Retrieves the firmware version of the sensor. The firmware version is stored in the 'version' parameter. It handles sensor communication and provides version details.

```kotlin
var version: SensorVersion = sensor.version;

**SensorVersion:**

| Field | Type | Description |
|--|--|--|
|FwMajor|Int|firmware major|
|FwMinor|Int|firmware minor|
|FwPatch|Int|firmware patch|
|HwMajor|Int|hardware major|
|HwMinor|Int|hardware minor|
|HwPatch|Int|hardware patch|
|ExtMajor|Int|extension major|
```

```kotlin
var version: NSNumber? = sensor?.battPower

**NTSensorVersion:**

| Field | Type | Description |
|--|--|--|
|fwMajor|UInt32?|firmware major|
|fwMinor|UInt32?|firmware minor|
|fwPatch|UInt32?|firmware patch|
|hwMajor|UInt32?|hardware major|
|hwMinor|UInt32?|hardware minor|
|hwPatch|UInt32?|hardware patch|
|extMajor|UInt32?|extension major|
```

--------------------------------

### Get Device Firmware Version (Python)

Source: https://sdk.brainbit.com/sdk2_/par_desc

Retrieves the firmware version of the sensor. The firmware version is stored in the 'version' parameter. It handles sensor communication and provides version details.

```python
version = sensor.version

**SensorVersion:**

| Field | Type | Description |
|--|--|--|
|FwMajor|int|firmware major|
|FwMinor|int|firmware minor|
|FwPatch|int|firmware patch|
|HwMajor|int|hardware major|
|HwMinor|int|hardware minor|
|HwPatch|int|hardware patch|
|ExtMajor|int|extension major|
```

--------------------------------

### Manage Connection State via Callback

Source: https://sdk.brainbit.com/sdk2_/sensor

Obtain connection status updates in real time using a callback function. This method requires subscribing to connection state changes and provides a way to handle dynamic connection events. The callback is invoked when the sensor's connection state changes after initial setup.

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

}

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

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

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

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

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

```python
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
```

```swift
sensor?.setConnectionStateCallback({ state in
    print(state)
})
...
sensor?.setConnectionStateCallback(nil)
```

```objective-c
[sensor setConnectionStateCallback:^(NTSensorState state) {
    NSLog(@"%@", @(state));
}];
...
[sensor setConnectionStateCallback:nil];
```

```dart
StreamSubscription<FSensorState>? stateSubscription = sensor.sensorStateStream.listen((state) => print("State: $state"));
...
stateSubscription.cancel();
```

--------------------------------

### Get Device Firmware Version (C++)

Source: https://sdk.brainbit.com/sdk2_/par_desc

Retrieves the firmware version of the sensor. The firmware version is stored in the 'version' parameter. It handles sensor communication and provides version details.

```cpp
// get
SensorVersion versionOut;
OpStatus outStatus;
readVersionSensor(sensor, &versionOut, &outStatus);

**SensorVersion:**

| Field | Type | Description |
|--|--|--|
|FwMajor|uint32_t|firmware major|
|FwMinor|uint32_t|firmware minor|
|FwPatch|uint32_t|firmware patch|
|HwMajor|uint32_t|hardware major|
|HwMinor|uint32_t|hardware minor|
|HwPatch|uint32_t|hardware patch|
|ExtMajor|uint32_t|extension major|
```

```cpp
SensorVersion version = sensor.getVersion();

**SensorVersion:**

| Field | Type | Description |
|--|--|--|
|FwMajor|int|firmware major|
|FwMinor|int|firmware minor|
|FwPatch|int|firmware patch|
|HwMajor|int|hardware major|
|HwMinor|int|hardware minor|
|HwPatch|int|hardware patch|
|ExtMajor|int|extension major|
```

```cpp
SensorVersion version = sensor.Version;

**SensorVersion:**

| Field | Type | Description |
|--|--|--|
|FwMajor|uint|firmware major|
|FwMinor|uint|firmware minor|
|FwPatch|uint|firmware patch|
|HwMajor|uint|hardware major|
|HwMinor|uint|hardware minor|
|HwPatch|uint|hardware hardware|
|ExtMajor|uint|extension major|
```

```cpp
NTSensorVersion* version = sensor.Version;

**NTSensorVersion:**

| Field | Type | Description |
|--|--|--|
|FwMajor|UInt32|firmware major|
|FwMinor|UInt32|firmware minor|
|FwPatch|UInt32|firmware patch|
|HwMajor|UInt32|hardware major|
|HwMinor|UInt32|hardware minor|
|HwPatch|UInt32|hardware patch|
|ExtMajor|UInt32|extension major|
```

```cpp
int battery = await sensor.battPower.value;

**FSensorVersion:**

| Field | Type | Description |
|--|--|--|
|fwMajor|int|firmware major|
|fwMinor|int|firmware minor|
|fwPatch|int|firmware patch|
|hwMajor|int|hardware major|
|hwMinor|int|hardware minor|
|hwPatch|int|hardware patch|
|extMajor|int|extension major|
```

--------------------------------

### iOS Info.plist Bluetooth Keys (Unity C#)

Source: https://sdk.brainbit.com/sdk2_/unity_install

This C# script, using Unity's post-build processing, adds necessary Bluetooth usage descriptions to the iOS Info.plist file. This is required by Apple's policies for apps using Bluetooth, ensuring users are informed about why the app needs Bluetooth access.

```csharp
public sealed class BuilderPostProcessor
{
    [PostProcessBuild(1)]
    public static void OnPostProcessBuild(BuildTarget target, string path)
    {
#if UNITY_IOS
        if (target == BuildTarget.iOS)
        {
            var infoPlist = new PlistDocument();
            var infoPlistPath = path + "/Info.plist";
            infoPlist.ReadFromFile(infoPlistPath);

            PlistElementDict dict = infoPlist.root.AsDict();
            dict.SetString("NSBluetoothAlwaysUsageDescription", "App requires access to Bluetooth to allow you connect to device");
            dict.SetString("NSBluetoothPeripheralUsageDescription", "App uses Bluetooth to connect with your Brainbit device");
            infoPlist.WriteToFile(infoPlistPath);
        }
#endif
    }
}
```

--------------------------------

### Receive BrainBit Resistance Data (Dart)

Source: https://sdk.brainbit.com/sdk2_/bb

This Dart code uses Dart Streams to listen for resistance data changes. It starts the resistance measurement using `sensor.execute` and cancels the subscription to stop receiving data.

```dart
StreamSubscription<BrainBitResistData>? resistSubscription = sensor.resistDataStream.listen((data) => print("resist values: $data"));
await sensor.execute(FSensorCommand.startResist);
...
resistSubscription.cancel();
await sensor.execute(FSensorCommand.stopResist);
```

--------------------------------

### Android Manifest Permissions (XML)

Source: https://sdk.brainbit.com/sdk2_/unity_install

This XML snippet defines the necessary permissions for the Android manifest file, enabling background location access and Bluetooth functionalities. These permissions are essential for the SDK to operate correctly on Android devices, especially for background operations and device communication.

```xml
<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
<uses-permission android:name="android.permission.BLUETOOTH_SCAN" tools:targetApi="31" android:usesPermissionFlags="neverForLocation" />
```

--------------------------------

### Request Android Permissions (Unity C#)

Source: https://sdk.brainbit.com/sdk2_/unity_install

This C# code snippet requests Bluetooth and location permissions on Android, differentiating behavior for OS versions 31, 32, and 33 compared to older versions. It's crucial for enabling Bluetooth and location services required by the SDK on Android devices.

```csharp
#if UNITY_ANDROID
            if (SystemInfo.operatingSystem.Contains("31") ||
                SystemInfo.operatingSystem.Contains("32") ||
                SystemInfo.operatingSystem.Contains("33"))
            {
                Permission.RequestUserPermission("android.permission.BLUETOOTH_SCAN");
                Permission.RequestUserPermission("android.permission.BLUETOOTH_CONNECT");
            }
            else
            {
                Permission.RequestUserPermission("android.permission.ACCESS_FINE_LOCATION");
                Permission.RequestUserPermission("android.permission.ACCESS_COARSE_LOCATION");
            }
#endif
```

--------------------------------

### Get Discovered Devices - C++, Java, Kotlin, C#, TypeScript, Python, Swift, Objective-C, Dart

Source: https://sdk.brainbit.com/sdk2_/scanner

This snippet demonstrates how to retrieve a list of discovered devices using the scanner object. The specific method or property to access the sensor list varies by programming language. Ensure the scanner object is properly initialized before calling these methods.

```cpp
int32_t szSensorsInOut = 32;
SensorInfo* sensors = new SensorInfo[szSensorsInOut];
OpStatus outStatus;
sensorsScanner(scanner, sensors, &szSensorsInOut, &outStatus);
```

```java
List<SensorInfo> sensors = scanner.getSensors();
```

```kotlin
var sensors: List<SensorInfo>?  = scanner.sensors
```

```csharp
IReadOnlyList<SensorInfo> sensors = scanner.Sensors;
```

```typescript
var sensors = await scanner.Sensors()
```

```python
sensors = scanner.sensors()
```

```swift
var sensors = scanner?.sensors
```

```objectivec
NSArray<NTSensorInfo*>* sensors = scanner.sensors;
```

```dart
List<FSensorInfo?> sensors = await scanner.getSensors();
```

--------------------------------

### Get Sensor Parameters (C++)

Source: https://sdk.brainbit.com/sdk2_/deviceinfo

Retrieves the count and details of supported parameters for a given sensor. It populates an array of ParameterInfo structures and returns an OpStatus indicating the operation's success. Ensure 'sensor' is a valid sensor handle.

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

--------------------------------

### Get Device Name (Parameter Description)

Source: https://sdk.brainbit.com/sdk2_/par_desc

This snippet demonstrates how to retrieve the name of a connected sensor device. The `readNameSensor` function is used in C++, while other languages use direct property access or getter methods. Attempting to set the device name after initialization will result in an exception across all demonstrated platforms.

```c++
char name[SENSOR_NAME_LEN];
OpStatus outStatus;
readNameSensor(sensor, name, SENSOR_NAME_LEN, &outStatus);
            
```

```java
String name = sensor.getName();
...
sensor.setName("NewName"); // <- this is throw an exeption, you cannot set device name
            
```

```kotlin
var name: String = sensor.name
...
sensor.name = "NewName" // <- this is throw an exeption, you cannot set device name
            
```

```c#
string name = sensor.Name;
...
sensor.Name = "newName"; // <- this is throw an exeption, you cannot set device name
            
```

```typescript
var name: string = sensor.getName()
...
sensor.setName('new_name') // <- this is throw an exeption, you cannot set device name
            
```

```python
name = sensor.name
...
sensor.name = "new_name" # <- this is throw an exeption, you cannot set device name
            
```

```swift
var name: String? = sensor?.name
...
sensor?.name = "newName"// <- this is throw an exeption, you cannot set device name
            
```

```objective-c
NSString* name = [sensor Name]; // or ... = sensor.Name;
...
[sensor setName:@"newName"]; // or sensor.Name = @"newName"; <- this is throw an exeption, you cannot set device name
            
```

```dart
String name = await sensor.name.value;
...
await sensor.name.set("newName").onError((error, stackTrace) => print(error)); // <- catch an exception
            
```

--------------------------------

### Ping Signal - C++

Source: https://sdk.brainbit.com/sdk2_/bb

Demonstrates how to send a ping signal with a specific marker value (5) using C++. It utilizes an outStatus parameter to capture the operation's result.

```cpp
OpStatus outStatus;
pingNeuroSmart(sensor, 5, &outStatus);
```

--------------------------------

### Get Battery Power (TypeScript)

Source: https://sdk.brainbit.com/sdk2_/par_desc

Gets the battery power of the sensor using a function call, returning a number.

```typescript
var battery: number = sensor.getBattPower()
```

--------------------------------

### Swift Library Import

Source: https://sdk.brainbit.com/sdk2_/ios_install

How to import the neurosdk2 library in Swift projects.

```swift
import neurosdk2
```

--------------------------------

### Checking Parameter Support

Source: https://sdk.brainbit.com/sdk2_/deviceinfo

Demonstrates how to check if a specific sensor parameter is supported.

```APIDOC
## Checking Parameter Support

This section provides examples of how to check if a specific sensor parameter is supported across different programming languages.

### C++ Example
```cpp
if(isSupportedParameterSensor(sensor, SensorParameter::ParameterGain)){
    ...
}
```

### Java Example
```java
if(sensor.isSupportedParameter(SensorParameter.ParameterGain)){
...
}
```

### Kotlin Example
```kotlin
if(sensor.isSupportedParameter(SensorParameter.ParameterGain) == true){
...
}
```

### C# Example
```csharp
if(sensor.IsSupportedParameter(SensorParameter.ParameterGain)){
...
}
```

### TypeScript Example
```typescript
if(sensor.IsSupportedParameter(SensorParameter.Gain)){
    ...
}
```

### Python Example
```python
if sensor.is_supported_parameter(SensorParameter.Gain):
    ...
```

### Swift Example
```swift
if(sensor?.isSupportedParameter(.gain)){
...
}
```

### Objective-C Example
```objectivec
if([sensor IsSupportedParameter:NTSensorParameterGain]){
...
}
```
```

--------------------------------

### Objective-C Library Import

Source: https://sdk.brainbit.com/sdk2_/ios_install

How to import the neurosdk2 library in Objective-C projects.

```objectivec
#import <neurosdk2/neurosdk.h>
```

--------------------------------

### Get Battery Power (Java)

Source: https://sdk.brainbit.com/sdk2_/par_desc

Retrieves the battery power of the sensor as an integer value.

```java
int battery = sensor.getBattPower();
```

--------------------------------

### Get Battery Power (Dart)

Source: https://sdk.brainbit.com/sdk2_/par_desc

Asynchronously retrieves the battery power of the sensor, returning an integer.

```dart
int battery = await sensor.battPower.value;
```

--------------------------------

### Get Battery Power (Objective-C)

Source: https://sdk.brainbit.com/sdk2_/par_desc

Retrieves the battery power of the sensor via a property, returning an NSNumber.

```objectivec
NSNumber* battery = sensor.BattPower;
```

--------------------------------

### Get Battery Power (C#)

Source: https://sdk.brainbit.com/sdk2_/par_desc

Retrieves the battery power of the sensor through a property, returning an integer value.

```csharp
int battery = sensor.BattPower;
```

--------------------------------

### Get Battery Power (Python)

Source: https://sdk.brainbit.com/sdk2_/par_desc

Accesses the battery power of the sensor using snake_case notation, returning an integer.

```python
battery = sensor.batt_power
```

--------------------------------

### Get Battery Power (Kotlin)

Source: https://sdk.brainbit.com/sdk2_/par_desc

Accesses the battery power of the sensor via a property, returning an integer value.

```kotlin
var battery: Int = sensor.battPower
```

--------------------------------

### Get Battery Power (Swift)

Source: https://sdk.brainbit.com/sdk2_/par_desc

Safely retrieves the battery power of the sensor using optional chaining, returning an NSNumber.

```swift
var battery: NSNumber? = sensor?.battPower
```

--------------------------------

### Get Battery Power (C++)

Source: https://sdk.brainbit.com/sdk2_/par_desc

Reads the battery power level of the sensor. This function returns an integer representing the battery percentage and an operation status.

```cpp
int32_t battPowerOut;
OpStatus outStatus;
readBattPowerSensor(sensor, &battPowerOut, &outStatus);
```

--------------------------------

### Create Sensor Object Across Multiple Languages

Source: https://sdk.brainbit.com/sdk2_/sensor

Demonstrates how to retrieve sensor information and create a sensor object using the scanner. This is a common operation across various programming languages supported by the SDK. The retrieved `sensorInfo` is used to instantiate specific sensor types like BrainBit or BrainBit2. Device creation is a blocking operation and should be performed on a separate thread.

```cpp
OpStatus outStatus;

// retrieve information from a list or retrieve stored information from a callback
int32_t szSensorsInOut = 32;
SensorInfo* sensors = new SensorInfo[szSensorsInOut];
sensorsScanner(scanner, sensors, &szSensorsInOut, &outStatus);

// for all devices
SensorInfo sensorInfo = sensors[0];
Sensor* sensor = createSensor(scanner, sensorInfo, &outStatus);
            
```

```java
// retrieve information from a list or retrieve stored information from a callback
List<SensorInfo> sensors = scanner.getSensors();
SensorInfo sensorInfo = sensors.get(0);

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

// BrainBit2 / BrainBit2 Pro / BrainBit Flex4 / BrainBit Flex8
BrainBit2 sensor = (BrainBit2)scanner.createSensor(sensorInfo);
            
```

```kotlin
// retrieve information from a list or retrieve stored information from a callback
val sensors = scanner!!.sensors
val sensorInfo: SensorInfo = sensors[0]

// BrainBit
var sensor: BrainBit? = scanner.createSensor(sensorInfo) as BrainBit

// BrainBit2 / BrainBit2 Pro / BrainBit Flex4 / BrainBit Flex8
var sensor: BrainBit2? = scanner.createSensor(sensorInfo) as BrainBit2
            
```

```csharp
// retrieve information from a list or retrieve stored information from a callback
IReadOnlyList<SensorInfo> sensors = scanner.Sensors;
SensorInfo sensorInfo = sensors[0];

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

// BrainBit2 / BrainBit2 Pro / BrainBit Flex4 / BrainBit Flex8
BrainBit2Sensor sensor = scanner.CreateSensor(sensorInfo) as BrainBit2Sensor;
            
```

```typescript
// retrieve information from a list or retrieve stored information from a callback
var sensors = await scanner.Sensors()
var sensorInfo = sensors[0]

// BrainBit
var sensor: BrainBitSensor = await scanner.CreateSensor(sensorInfo) as BrainBitSensor

// BrainBit2 / BrainBit2 Pro / BrainBit Flex4 / BrainBit Flex8
var sensor: BrainBit2Sensor = await scanner.CreateSensor(sensorInfo) as BrainBit2Sensor;
            
```

```python
# retrieve information from a list or retrieve stored information from a callback
sensors = scanner.sensors()
sensorInfo = sensors[0]

sensor = scanner.create_sensor(sensorInfo)
            
```

```swift
// retrieve information from a list or retrieve stored information from a callback
var sensors = scanner?.sensors
var sensorInfo = sensors[0]

// BrainBit
var sensor: NTBrainBit? = scanner.createSensor(sensorInfo) as? NTBrainBit

// BrainBit2 / BrainBit2 Pro / BrainBit Flex4 / BrainBit Flex8
var sensor: NTBrainBit2? = scanner.createSensor(sensorInfo) as? NTBrainBit2
            
```

```objective-c
// retrieve information from a list or retrieve stored information from a callback
NSArray<NTSensorInfo*>* sensors = scanner.sensors;
NTSensorInfo* sensorInfo = sensors[0];

// BrainBit
NTBrainBit* sensor = (NTBrainBit*)[scanner createSensor:sensorInfo];

// BrainBit2 / BrainBit2 Pro / BrainBit Flex4 / BrainBit Flex8
NTBrainBit2* sensor = (NTBrainBit2*)[scanner createSensor:sensorInfo];
            
```

```dart
// retrieve information from a list or retrieve stored information from a callback
List<FSensorInfo?> sensors = await scanner.getSensors();
FSensorInfo? sensorInfo = sensors[0];

// BrainBit
BrainBit? sensor = await scanner.createSensor(info!) as BrainBit;

// BrainBit2 / BrainBit2 Pro / BrainBit Flex4 / BrainBit Flex8
BrainBit2? sensor = await scanner.createSensor(info!) as BrainBit2;
            
```

--------------------------------

### Import neurosdk2 in Swift for macOS

Source: https://sdk.brainbit.com/sdk2_/macos_install

Steps to integrate the neurosdk2 library into a Swift project on macOS. This requires creating a bridging header file to import the Objective-C headers.

```swift
#ifndef demo_Bridging_Header_h
#define demo_Bridging_Header_h

#import <neurosdk.h>

#endif /* demo_Bridging_Header_h */

```

--------------------------------

### ParameterInfo and SensorParamAccess

Source: https://sdk.brainbit.com/sdk2_/deviceinfo

Details on the structure of ParameterInfo and the SensorParamAccess enum.

```APIDOC
## Parameter Information Structure

### ParameterInfo

| Field       | Type            | Description                                   |
|-------------|-----------------|-----------------------------------------------|
| Param       | SensorParameter | The name of the parameter, enum.              |
| ParamAccess | SensorParamAccess | Parameter availability for manipulation.      |

### SensorParamAccess Enum

| Field             | Value | Description                           |
|-------------------|-------|---------------------------------------|
| ParamAccessRead   | 0     | Read-only                             |
| ParamAccessReadWrite| 1     | Parameter can be changed.             |
| ParamAccessReadNotify| 2  | Parameter is updated over time.       |

*Note: The exact field names and enum values might vary slightly across different language implementations (e.g., `param` vs `Param`, `Read` vs `read`).*

### Objective-C Specifics

#### NTParameterInfo

| Field       | Type              | Description                                   |
|-------------|-------------------|-----------------------------------------------|
| param       | NTSensorParameter?| The name of the parameter, enum.              |
| paramAccess | NTSensorParamAccess?| Parameter availability for manipulation.      |

#### NTSensorParamAccess Enum

| Field             | Value | Description                           |
|-------------------|-------|---------------------------------------|
| read              | 0     | Read-only                             |
| readWrite         | 1     | Parameter can be changed.             |
| readNotify        | 2     | Parameter is updated over time.       |

*Objective-C enum variations:*

#### NTSensorParamAccess Enum (Alternative)

| Field                   | Value | Description                           |
|-------------------------|-------|---------------------------------------|
| NTSensorParamAccessRead | 0     | Read-only                             |
| NTSensorParamAccessReadWrite | 1  | Parameter can be changed.             |
| NTSensorParamAccessReadNotify| 2  | Parameter is updated over time.       |
```

--------------------------------

### Get Device Firmware Version (Dart)

Source: https://sdk.brainbit.com/sdk2_/par_desc

Retrieves the firmware version of the sensor. The firmware version is stored in the 'version' parameter. It handles sensor communication and provides version details.

```dart
FSensorVersion version = await sensor.version.value;

**FSensorVersion:**

| Field | Type | Description |
|--|--|--|
|fwMajor|int|firmware major|
|fwMinor|int|firmware minor|
|fwPatch|int|firmware patch|
|hwMajor|int|hardware major|
|hwMinor|int|hardware minor|
|hwPatch|int|hardware patch|
|extMajor|int|extension major|
```

--------------------------------

### Import neurosdk2 in Objective-C for macOS

Source: https://sdk.brainbit.com/sdk2_/macos_install

How to import the neurosdk2 library in an Objective-C project on macOS. This involves including the 'neurosdk.h' header file.

```objectivec
#import <neurosdk.h>
```

--------------------------------

### Get Device Firmware Version (Objective-C)

Source: https://sdk.brainbit.com/sdk2_/par_desc

Retrieves the firmware version of the sensor. The firmware version is stored in the 'version' parameter. It handles sensor communication and provides version details.

```objectivec
NSNumber* battery = sensor.BattPower;

**NTSensorVersion:**

| Field | Type | Description |
|--|--|--|
|FwMajor|UInt32|firmware major|
|FwMinor|UInt32|firmware minor|
|FwPatch|UInt32|firmware patch|
|HwMajor|UInt32|hardware major|
|HwMinor|UInt32|hardware minor|
|HwPatch|UInt32|hardware patch|
|ExtMajor|UInt32|extension major|
```

--------------------------------

### Ping Signal - Python

Source: https://sdk.brainbit.com/sdk2_/bb

Shows the Python implementation for sending a ping signal. The ping_neuro_smart function is called on the sensor object with the marker value 5.

```python
sensor.ping_neuro_smart(5)
```

--------------------------------

### Get Device Firmware Version (Swift)

Source: https://sdk.brainbit.com/sdk2_/par_desc

Retrieves the firmware version of the sensor. The firmware version is stored in the 'version' parameter. It handles sensor communication and provides version details.

```swift
var version: SensorVersion = sensor.version;

**SensorVersion:**

| Field | Type | Description |
|--|--|--|
|FwMajor|Int|firmware major|
|FwMinor|Int|firmware minor|
|FwPatch|Int|firmware minor|
|HwMajor|Int|hardware major|
|HwMinor|Int|hardware minor|
|HwPatch|Int|hardware patch|
|ExtMajor|Int|extension major|
```

--------------------------------

### Import Sensor module in Python

Source: https://sdk.brainbit.com/sdk2_/python_install

Imports the Sensor module from the neurosdk package, which provides common methods for interacting with devices.

```python
from neurosdk.sensor import Sensor
```

--------------------------------

### Import BrainBitSensor module in Python

Source: https://sdk.brainbit.com/sdk2_/python_install

Imports the BrainBitSensor module from the neurosdk package, specifically for interacting with BrainBit devices.

```python
from neurosdk.brainbit_sensor import BrainBitSensor
```

--------------------------------

### Import Scanner module in Python

Source: https://sdk.brainbit.com/sdk2_/python_install

Imports the Scanner module from the neurosdk package, which is used for searching for devices.

```python
from neurosdk.scanner import Scanner
```
Tokens:
Raw