BrainBit SDK

https://sdk.brainbit.com
Admin
BrainBit SDK is a cross-platform software development kit providing libraries and tools for...
Tokens:112,005
Snippets:879
Trust Score:8.4
Update:9 months ago
Show doc for...
Tokens:
Raw
### Subscribe to BrainBit2 Resistance Events (C#)

Source: https://sdk.brainbit.com/brainbit-2-devices

This C# example shows how to subscribe to the resistance data received event for the BrainBit2 sensor. It includes a static method to handle the event data and commands to start and stop the resistance measurement.

```C#
private static void SensorEventBrainBit2ResistDataRecived(ISensor sensor, ResistRefChannelsData[] data)
{
    if (data.Length < 1) return;
    ResistRefChannelsData lastData = data[data.Length - 1];
    Console.WriteLine($"0: {lastData.Samples[0]} 1: {lastData.Samples[1]} 2: {lastData.Samples[2]} 3: {lastData.Samples[3]}");
}
...
sensor.EventBrainBit2ResistDataRecived += SensorEventBrainBit2ResistDataRecived;
sensor.ExecCommand(SensorCommand.CommandStartResist);
...
sensor.EventBrainBit2ResistDataRecived -= SensorEventBrainBit2ResistDataRecived;
sensor.ExecCommand(SensorCommand.CommandStopResist);
```

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

### Install C++ SDK for Windows

Source: https://sdk.brainbit.com/lib-emotions

Instructions for installing the C++ SDK for Windows. Download all necessary folders from GitHub and integrate the .dll files into your project.

```text
Download from [GitHub](https://github.com/BrainbitLLC/EmotionsStateArtifacts-cpp) all folders and add .dll to your project by your preferred way.
            

```

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

### Install Flutter SDK

Source: https://sdk.brainbit.com/lib-spectrum

Add the `spectrum_lib` package to your Flutter project using `flutter pub add spectrum_lib` or by manually adding it to your `pubspec.yaml` file under dependencies. Remember to run `flutter pub get` afterwards and import the library in your Dart code.

```dart
flutter pub add spectrum_lib

# Or manually:
dependencies:
  spectrum_lib: ^1.0.1

# Then run: flutter pub get

# Usage:
import 'package:spectrum_lib/spectrum_lib.dart';
```

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

### Install Windows (C#) SDK

Source: https://sdk.brainbit.com/lib-spectrum

Install the latest version of the `SpectrumLib` package from the NuGet Gallery using your preferred method. This provides the .NET library for Windows applications.

```csharp
Install latest version `SpectrumLib` package from NuGet Gallery in your preferred way.
```

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

### Install C++ SDK for Linux (Debian Package)

Source: https://sdk.brainbit.com/lib-emotions

Instructions for installing the C++ SDK for Linux using a Debian package. Download the .deb file and install it using the apt package manager.

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

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

### Install C++ SDK for Linux (Raw Files)

Source: https://sdk.brainbit.com/lib-emotions

Instructions for installing the C++ SDK for Linux by manually adding the .so files to your project. This method requires downloading raw library files from GitHub.

```text
Download from [GitHub](https://github.com/BrainbitLLC/linux_em_st_artifacts/tree/main/raw) and add .so to your project by your preferred way.
Library built on Astra Linux CE 2.12.46, kernel 5.15.0-70-generic. Arch: x86_64 GNU/Linux

```
user@astra:~$ ldd --version
ldd (Debian GLIBC 2.28-10+deb10u1) 2.28
Copyright (C) 2018 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
Written by Roland McGrath and Ulrich Drepper.
```

That library depends from others library, for instance:
```
linux-vdso.so.1
libblkid.so.1
libc++.so.1
libc++abi.so.1 
libc.so.6
libdl.so.2
libffi.so.6
libgcc_s.so.1
libgio-2.0.so.0
libglib-2.0.so.0
libgmodule-2.0.so.0
libgobject-2.0.so.0
libm.so.6
libmount.so.1
libpcre.so.3
libpthread.so.0
libresolv.so.2 
librt.so.1
libselinux.so.1
libstdc++.so.6
libudev.so.1
libuuid.so.1
libz.so.1
ld-linux-x86-64.so.2
```

If you are using a OS other than ours, these dependencies will be required for the library. You can download dependencies from [here](https://github.com/BrainbitLLC/linux_neurosdk2/tree/main/dependencies).
            

```

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

### Install iOS SDK

Source: https://sdk.brainbit.com/lib-spectrum

Install the iOS SDK (OS >= 12.0) using CocoaPods by adding the `spectrumlib` pod to your Podspec file and running `pod install`. Alternatively, you can manually add the `spectrumlib.xcframework` to your project's embedded content.

```ruby
pod 'spectrumlib', '1.0.1'

# Then run: pod install
```

```text
Manual installation:
1. Download `spectrumlib.xcframework` from [GitHub](https://github.com/BrainbitLLC/apple_spectrumlib)
2. Add `spectrumlib.xcframework` to `Frameworks, Libraries, and Embedded Content` section of your project
3. Set `Embedded` to `Embed & Sign`

Latest version: `1.0.1`
```

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

### iOS SDK Installation - Manual

Source: https://sdk.brainbit.com/lib-emotions

Manually installs the iOS SDK by downloading the framework from GitHub and embedding it into your Xcode project. Ensure the framework is set to 'Embed & Sign'.

```bash
# 1. Download em-st-artifacts.xcframework from GitHub
# 2. Add em-st-artifacts.xcframework to Frameworks, Libraries, and Embedded Content
# 3. Set 'Embedded' to 'Embed & Sign'
```

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

### Install and Run Web Bluetooth Demo App

Source: https://sdk.brainbit.com/web-quickstart

Instructions for installing and running the BrainBit SDK JavaScript demo application using Web Bluetooth. This requires HTTPS and involves npm installation and webpack compilation.

```bash
npm install
webpack
```

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

### Python SDK Installation - Pip

Source: https://sdk.brainbit.com/lib-emotions

Installs the Python SDK using pip for Windows, MacOS, and Astra Linux. The package `pyem-st-artifacts` can be installed directly.

```bash
pip install pyem-st-artifacts
```

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

### iOS SDK Installation - CocoaPods

Source: https://sdk.brainbit.com/lib-emotions

Installs the iOS SDK using CocoaPods. Add the specified pod to your Podfile and run `pod install`. Requires iOS version 12.0 or higher.

```ruby
pod 'em-st-artifacts', '1.0.2'
```

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

### .NET SDK Installation - NuGet

Source: https://sdk.brainbit.com/lib-emotions

Installs the `EmStArtifacts` package for .NET platforms (iOS, Android, UWP) using NuGet Package Manager. This is the recommended way for common projects.

```powershell
# Install via NuGet Package Manager in your IDE or use the command line:
# Install-Package EmStArtifacts
```

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

### Install C++ Library for Windows

Source: https://sdk.brainbit.com/lib-spectrum

Download the C++ library for Windows from GitHub and add the .dll file to your project. This is the primary method for Windows integration.

```text
Download from [GitHub](https://github.com/BrainbitLLC/spectrum-lib-cpp) all folders and add .dll to your project by your preferred way.
```

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

### Install Python Package for Windows

Source: https://sdk.brainbit.com/lib-spectrum

Install the Python package `pyspectrum_lib` for Windows using pip. The package includes the main `spectrum_lib` module and necessary DLL files in the `libs` folder.

```python
pip install pyspectrum_lib

# Usage:
from spectrum_lib import SpectrumMath
```

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

### Python SDK Usage Example

Source: https://sdk.brainbit.com/lib-emotions

Demonstrates how to import and use the `EmotionalMath` module from the `em_st_artifacts` Python package.

```python
from em_st_artifacts.emotional_math import EmotionalMath
```

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

### Flutter SDK Installation - Pub Add

Source: https://sdk.brainbit.com/lib-emotions

Installs the Flutter SDK package `em_st_artifacts` using the `flutter pub add` command. This integrates the SDK into your Flutter project.

```dart
flutter pub add em_st_artifacts
```

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

### Install BrainBit SDK for Web

Source: https://sdk.brainbit.com/web-quickstart

Provides the command to install the BrainBit SDK for web applications via npm. It also mentions alternative methods for including the SDK, such as using build files from the /dist directory or source files from /src.

```bash
npm install web-neurosdk-brainbit
```

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

### Get Preinstalled Filters C#

Source: https://sdk.brainbit.com/lib_filters

Access the list of pre-installed filters in C# through the PreinstalledFilters.List() method. This provides a convenient way to get available filters.

```csharp
FilterParam[] preinstallFilters = PreinstalledFilters.List();
```

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

### iOS Manual Framework Installation

Source: https://sdk.brainbit.com/sdk2_ios_install

Manually installs the neurosdk2 framework for iOS. Download the 'neurosdk2.xcframework' from GitHub, add it to your project's 'Frameworks, Libraries, and Embedded Content' section, set 'Embed & Sign', and configure 'Framework search paths'. Bluetooth permissions must be added to Info.plist.

```bash
# Download neurosdk2.xcframework from GitHub (iOS folder)
# Add to Frameworks, Libraries, and Embedded Content
# Set to Embed & Sign
# Add to Framework search paths
```

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

### macOS Manual Library Installation

Source: https://sdk.brainbit.com/sdk2_ios_install

Manually installs the neurosdk2 library for macOS. Download 'libneurosdk.dylib' from GitHub, add it to your project's 'Frameworks, Libraries, and Embedded Content' section, and configure 'Library search paths'. You also need to manually add headers from the macOS folder on GitHub.

```bash
# Download libneurosdk.dylib from GitHub (macos folder)
# Add to Frameworks, Libraries, and Embedded Content
# Add headers from GitHub (macos folder)
# Add to Library search paths
```

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

### Get Preinstalled Filter List C++

Source: https://sdk.brainbit.com/lib_filters

Fetch the list of pre-installed filters by allocating a FilterParam array and calling get_preinstalled_filter_list. Ensure you have the count from get_preinstalled_filter_count first.

```cpp
FilterParam* preinstallFilters = new FilterParam[fcount];
get_preinstalled_filter_list(preinstallFilters, &error);
```

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

### Finishing Work with the Library

Source: https://sdk.brainbit.com/lib_filters

Provides examples for releasing resources associated with filters and filter lists when no longer needed. This is crucial for preventing memory leaks and ensuring proper library operation. Examples are provided for C++, C#, and Python.

```cpp
TOpStatus error;
// removing filters
delete_TFilter(filter, &error);

// removing list of filters
delete_TFilterList(flist, &error);
```

```csharp
// removing filters
filter.Dispose();

// removing list of filters
flist.Dispose();
```

```python
# removing filters
del filter

# removing list of filters
del flist
```

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

### Flutter SDK Usage Example

Source: https://sdk.brainbit.com/lib-emotions

Demonstrates how to import and use the `em_st_artifacts` package in your Dart code for Flutter projects.

```dart
import 'package:em_st_artifacts/em_st_artifacts.dart';
```

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

### Get Channels Count

Source: https://sdk.brainbit.com/brainbit-2-devices

Retrieve the total number of channels available on the sensor. Examples provided for multiple programming languages.

```APIDOC
## Get Channels Count

### Description
Returns the total number of channels supported by the sensor.

### Method
GET

### Endpoint
`/sensor/channels/count`

### Query Parameters
- **sensor** (object) - Required - The sensor object to query.

### Request Example
```javascript
let maxChCount = BrainBit2Sensor.getMaxChCount();
let chCount = sensor.getChannelsCount();
```

### Response
#### Success Response (200)
- **chCount** (int32) - The number of channels available on the sensor.

### Response Example
```json
{
  "chCount": 8
}
```
```

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

### Flutter SDK Installation - Dependencies

Source: https://sdk.brainbit.com/lib-emotions

Manually adds the Flutter SDK package `em_st_artifacts` to your `pubspec.yaml` file under the dependencies section. After adding, run `flutter pub get`.

```yaml
dependencies:
  em_st_artifacts: ^1.0.0
```

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

### Register and Remove BrainBit2 Resistance Callback (Objective-C)

Source: https://sdk.brainbit.com/brainbit-2-devices

This Objective-C example shows how to set and remove a resistance data callback for the BrainBit2 sensor using NSArrays. It also includes commands to start and stop the resistance measurement.

```Objective-C
[sensor setResistDataCallback:^(NSArray<NTResistRefChannelsData*>*_Nonnull resists) {
    // process data
}];
[sensor ExecCommand:NTSensorCommandStartResist];
...
[sensor setResistDataCallback:nil];
[sensor ExecCommand:NTSensorCommandStopResist];
```

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

### Install Unity SDK

Source: https://sdk.brainbit.com/lib-spectrum

Add the Unity SDK from GitHub using the Package Manager by providing the Git URL. The latest version is `1.0.0`. Success is indicated by the package appearing in the list; errors will be shown in the Unity Console.

```csharp
1. Open Package Manager
2. Click "Add" menu and choose "Add package from GIT url..."
3. Enter a https://github.com/BrainbitLLC/unity_spectrum.git in the text box and click Add.

Latest version: `1.0.0`
```

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

### Gain API

Source: https://sdk.brainbit.com/sdk2_par_desc

This section covers the gain parameter for ADC signals, explaining its effect on noise and amplitude. It lists the available gain values for BrainBit and provides code examples for setting and getting the gain.

```APIDOC
## GET /websites/sdk_brainbit/Gain

### Description
Retrieves the current gain setting of the ADC signal.

### Method
GET

### Endpoint
/websites/sdk_brainbit/Gain

### Parameters
None

### Request Body
None

### Request Example
```cpp
// C++ example
SensorGain sensorGain;
OpStatus outStatus;
readGainSensor(sensor, &sensorGain, &outStatus);
```
```java
// Java example
SensorGain gain = sensor.getGain();
```
```swift
// Swift example
var gain: SensorGain = sensor.gain
```
```csharp
// C# example
SensorGain gain = sensor.Gain;
```
```typescript
// TypeScript example
var sensorGain: SensorGain = sensor.getGain()
```
```python
# Python example
gain = sensor.gain
```
```objectivec
// Objective-C example
var sensorGain: NTSensorGain? = sensor?.gain;
```
```cpp
// C++ example
NTSensorGain gain = sensor.Gain;
```
```dart
// Dart example
FSensorGain gain = await sensor.gain.value;
```

### Response
#### Success Response (200)
- **sensorGain** (SensorGain) - The current gain setting.

#### Response Example
```json
{
  "sensorGain": "Gain3"
}
```

## POST /websites/sdk_brainbit/Gain

### Description
Sets the gain of the ADC signal. The available values for BrainBit are 1, 2, 3, 4, 6, 8, 12.

### Method
POST

### Endpoint
/websites/sdk_brainbit/Gain

### Parameters
None

### Request Body
- **sensorGain** (SensorGain) - The desired gain setting. Must be one of the available values.

### Request Example
```cpp
// C++ example
auto sensorGain = SensorGain::SensorGain3;
OpStatus outStatus;
writeGainSensor(sensor, sensorGain, &outStatus);
```
```java
// Java example
sensor.setGain(SensorGain.Gain3);
```
```swift
// Swift example
sensor.gain = SensorGain.Gain3
```
```csharp
// C# example
sensor.Gain = SensorGain.SensorGain3;
```
```typescript
// TypeScript example
sensor.setGain(SensorGain.Gain3);
```
```python
# Python example
sensor.gain = SensorGain.Gain3
```
```objectivec
// Objective-C example
sensor?.gain = .gain3;
```
```cpp
// C++ example
sensor.Gain = NTSensorGain3;
```
```dart
// Dart example
await sensor.gain.set(FSensorGain.gain3);
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation message indicating the operation was successful.

#### Response Example
```json
{
  "message": "Gain set successfully."
}
```

#### Error Response (400)
- **error** (string) - Message indicating that an unsupported gain value was provided.

#### Error Response Example
```json
{
  "error": "Unsupported gain value provided."
}
```
```

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

### Configure BrainBit SDK Main Parameters in C#

Source: https://sdk.brainbit.com/lib-emotions

Demonstrates setting up BrainBit SDK parameters using C# object initializers. This covers essential settings like sampling rate, artifact detection parameters, and spectral analysis configurations. It initializes an `EegEmotionalMath` object.

```csharp
int samplingFrequency = 250;
var mls = new MathLibSetting
{
    sampling_rate        = samplingFrequency,
    process_win_freq     = 25,
    n_first_sec_skipped  = 4,
    fft_window           = samplingFrequency * 4,
    bipolar_mode         = true,
    channels_number      = 4,
    channel_for_analysis = 0
};

var ads = new ArtifactDetectSetting
{
    art_bord                  = 110,
    allowed_percent_artpoints = 70,
    raw_betap_limit           = 800_000,
    total_pow_border          = 40 * 1e7,
    global_artwin_sec         = 4,
    spect_art_by_totalp       = true,
    num_wins_for_quality_avg  = 125,
    hanning_win_spectrum      = false,
    hamming_win_spectrum      = true
};

var sads = new ShortArtifactDetectSetting 
{
    ampl_art_detect_win_size = 200, 
    ampl_art_zerod_area = 200, 
    ampl_art_extremum_border = 25 
};

var mss = new MentalAndSpectralSetting 
{
    n_sec_for_averaging = 2, 
    n_sec_for_instant_estimation = 4 
};

var math = new EegEmotionalMath(mls, ads, sads, mss);
```

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

### Configure BrainBit SDK Main Parameters in Swift

Source: https://sdk.brainbit.com/lib-emotions

Provides Swift code examples for initializing BrainBit SDK parameters. It demonstrates setting up `EMMathLibSetting` and `EMArtifactDetectSetting` for use in SDK functionalities. Note: The provided snippet is incomplete.

```swift
let mathLibSetting = EMMathLibSetting(samplingRate: 250,
                                      andProcessWinFreq: 25,
                                      andFftWindow: 1000,
                                      andNFirstSecSkipped: 4,
                                      andBipolarMode: true,
                                      andSquaredSpectrum: true,
                                      andChannelsNumber: 1,
                                      andChannelForAnalysis: 0)

let artifactDetectSetting = EMArtifactDetectSetting(artBord: 110,

```

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

### Get Supported Sensor Commands

Source: https://sdk.brainbit.com/sdk2_deviceinfo

Retrieves a list of all executable commands for a given sensor. The output provides an enumeration of supported commands, such as starting or stopping signal/resistance measurements. Ensure the correct sensor object is passed.

```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()));
```

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

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

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

```Python
print(sensor.commands)
```

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

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

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

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

### iOS Installation using CocoaPods

Source: https://sdk.brainbit.com/sdk2_ios_install

Installs the neurosdk2 library for iOS using CocoaPods. Ensure you have CocoaPods installed and add the specified line to your Podspec file. Run 'pod install' to complete the installation. This SDK requires iOS version 12.0 or later and Bluetooth permissions.

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

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

### Handle Device List Changes with Callback

Source: https://sdk.brainbit.com/windows-tutorial

Shows how to set up a callback function to be notified when the list of found devices changes. It includes subscribing to the event and demonstrates how to unsubscribe when no longer needed, which is crucial for efficient device discovery.

```c
DeviceListListener listListener;
int resultCode = enumerator_set_device_list_changed_callback(enumerator, &on_device_list_changed, &listListener, 0);
// ...
enumerator_unsubscribe_device_list_changed(listListener);
```

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

### Install Python SDK using pip

Source: https://sdk.brainbit.com/sdk2_python_install

Installs the pyneurosdk2 Python package using pip. Ensure Python version >= 3.7 is installed. This is the primary method for installing the SDK on supported platforms.

```bash
pip install pyneurosdk2
```

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

### Start Signal Data Transfer - C/C++

Source: https://sdk.brainbit.com/windows-tutorial

This code snippet demonstrates how to initiate the reception of signal data from the device. It uses the `device_execute` function with the `CommandStartSignal` command. This is necessary for data channels other than the battery channel to begin data transfer.

```c
device_execute(device, CommandStartSignal);
```

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

### Start Calibration (C++, C#, Java, Python, Swift, Objective-C)

Source: https://sdk.brainbit.com/lib-emotions

Initiates the calibration process for the math library. This should be called right after library initialization to ensure accurate data processing and mental level estimation.

```C++
OpStatus opSt;
MathLibStartCalibration(tMathPtr, &opSt);
```

```C#
math.StartCalibration();
```

```Java
math.startCalibration();
```

```Python
math.start_calibration()
```

```Swift
emotionalMath.startCalibration()
```

```Objective-C
[math startCalibration];
```

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

### Install Python SDK on Linux

Source: https://sdk.brainbit.com/sdk2_python_install

Installs the Python SDK on Linux distributions like Astra Linux and Ubuntu. This involves downloading a .deb package and installing it using apt. Requires Python version >= 3.7.

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

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

### 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. Ensure you have Flutter installed and configured. This is the recommended way to install the SDK for Flutter development.

```bash
flutter pub add neurosdk2
```

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

### Initialize SpectrumMath with Additional Settings

Source: https://sdk.brainbit.com/lib-spectrum

Configures optional parameters for spectrum calculation, including the upper frequency bound and normalization by waveband width. These settings allow for fine-tuning the spectrum analysis.

```C++
int bord_frequency = 50; // upper bound of frequencies for spectrum calculation
bool normalize_spect_by_bandwidth = true; // normalization of the EEG spectrum by the width of the wavebands
SpectrumMathInitParams(tSpectMathPtr, bord_frequency, normalize_spect_by_bandwidth);
            
```

```C#
int bordFrequency = 50; // upper bound of frequencies for spectrum calculation
bool normalizeSpectByBandwidth = true; // normalization of the EEG spectrum by the width of the wavebands
math.InitParams(bordFrequency, normalizeSpectByBandwidth);
            
```

```Java
int bordFrequency = 50; // upper bound of frequencies for spectrum calculation
boolean normalizeSpectByBandwidth = true; // normalization of the EEG spectrum by the width of the wavebands
math.initParams(bordFrequency, normalizeSpectByBandwidth);
            
```

```Python
bord_frequency = 50 # upper bound of frequencies for spectrum calculation
normalize_spect_by_bandwidth = True # normalization of the EEG spectrum by the width of the wavebands
pectrum_math.init_params(bord_frequency, normalize_spect_by_bandwidth)
            
```

```Swift
let bordFrequency = 50 // upper bound of frequencies for spectrum calculation
let normalze = true // normalization of the EEG spectrum by the width of the wavebands
math.initParams(withUpBorderFreq: bordFrequency, andNormilize: normalze)
            
```

```Objective-C
int bord_frequency = 50; // upper bound of frequencies for spectrum calculation
bool normalize_spect_by_bandwidth = true; // normalization of the EEG spectrum by the width of the wavebands
[math initParamsWithUpBorderFreq:bord_frequency andNormilize:normalize_spect_by_bandwidth];
            
```

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

### Configure BrainBit SDK Main Parameters in Java

Source: https://sdk.brainbit.com/lib-emotions

Illustrates the initialization of BrainBit SDK parameters in Java using constructor calls. This method configures math library settings, artifact detection, short artifact detection, and mental/spectral settings to create an `EmotionalMath` object.

```java
int samplingFrequency = 250;
MathLibSetting mls = new MathLibSetting(samplingFrequency, 25, samplingFrequency * 4, 4, true, 4, 0);

ArtifactDetectSetting ads = new ArtifactDetectSetting(110, 70, 800000,(int) (40*1e7), 4, true, true,false,125);

ShortArtifactDetectSetting sads = new ShortArtifactDetectSetting(200,200,25);

MentalAndSpectralSetting mss = new MentalAndSpectralSetting(2,4);

EmotionalMath tMathPtr = new EmotionalMath(mls, ads, sads, mss);
```

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

### Install neurosdk2 on MacOS

Source: https://sdk.brainbit.com/sdk2_macos_install

Instructions for installing the neurosdk2 library on macOS using CocoaPods or manual installation. This involves adding the pod to your Podspec file or manually embedding the framework and headers. Bluetooth permissions are also required in Info.plist.

```ruby
pod 'neurosdk2', '1.0.19'
```

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

```swift
#ifndef demo_Bridging_Header_h
#define demo_Bridging_Header_h

#import <neurosdk.h>

#endif /* demo_Bridging_Header_h */

```

```xml
<key>NSBluetoothAlwaysUsageDescription</key>
<string>Explanation to using bluetooth</string>
```

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

### Configure BrainBit SDK Main Parameters in C++

Source: https://sdk.brainbit.com/lib-emotions

Sets up the main parameters for BrainBit SDK using C++ structs. This includes sampling rate, artifact detection thresholds, and mental/spectral analysis settings. It initializes the MathLib object with these configurations.

```cpp
MathLibSetting mathLibSetting;
mathLibSetting.sampling_rate = 250;
mathLibSetting.process_win_freq = 25;
mathLibSetting.n_first_sec_skipped = 4;
mathLibSetting.fft_window = 1000;
mathLibSetting.bipolar_mode = true;
mathLibSetting.channels_number = 4;
mathLibSetting.channel_for_analysis = 0;

ArtifactDetectSetting artifactDetectSetting;
artifactDetectSetting.art_bord = 110;
artifactDetectSetting.allowed_percent_artpoints = 70;
artifactDetectSetting.total_pow_border = 40 * 1e7;
artifactDetectSetting.raw_betap_limit = 800000;
artifactDetectSetting.spect_art_by_totalp = false;
artifactDetectSetting.global_artwin_sec = 4;
artifactDetectSetting.num_wins_for_quality_avg = 125;
artifactDetectSetting.hanning_win_spectrum = true;
artifactDetectSetting.hamming_win_spectrum = false;

ShortArtifactDetectSetting shortArtifactDetectSetting;
shortArtifactDetectSetting.ampl_art_detect_win_size = 200;
shortArtifactDetectSetting.ampl_art_zerod_area = 200;
shortArtifactDetectSetting.ampl_art_extremum_border = 25;

MentalAndSpectralSetting mentalAndSpectralSetting;
mentalAndSpectralSetting.n_sec_for_averaging = 2;
mentalAndSpectralSetting.n_sec_for_instant_estimation = 4;

OpStatus opSt;
MathLib* tMathPtr = createMathLib(mathLibSetting, artifactDetectSetting, shortArtifactDetectSetting, mentalAndSpectralSetting, &opSt);
```

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

### Configure BrainBit SDK Main Parameters in Python

Source: https://sdk.brainbit.com/lib-emotions

Shows how to set up the main parameters for the BrainBit SDK using Python keyword arguments. This includes configuring sampling rate, artifact detection, and spectral analysis settings to instantiate the `EmotionalMath` class.

```python
mls = lib_settings.MathLibSetting(sampling_rate=250,
                                  process_win_freq=25,
																											n_first_sec_skipped=4,
                                  fft_window=1000,
                                  bipolar_mode=True,
                                  squared_spectrum=True,
                                  channels_number=4,
                                  channel_for_analysis=0)

ads = lib_settings.ArtifactDetectSetting(art_bord=110,
                                         allowed_percent_artpoints=70,
                                         raw_betap_limit=800_000,
                                         global_artwin_sec=4,
                                         num_wins_for_quality_avg=125,
                                         hamming_win_spectrum=True,
                                         hanning_win_spectrum=False,
                                         total_pow_border=400_000_000,
                                         spect_art_by_totalp=True)

sads = lib_settings.ShortArtifactDetectSetting(ampl_art_detect_win_size=200,
                                               ampl_art_zerod_area=200,
                                               ampl_art_extremum_border=25)

mss = lib_settings.MentalAndSpectralSetting(n_sec_for_averaging=2,
                                            n_sec_for_instant_estimation=4)

math = EmotionalMath(mls, ads, sads, mss)
```

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

### Install Python Filters Library

Source: https://sdk.brainbit.com/lib_filters

Install the pyfilters-lib package for Python using pip. This package includes the neurosdk, sample, and libs. Requires Python 3.7+.

```bash
pip install pyfilters-lib
```

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

### Install Android SDK (JitPack)

Source: https://sdk.brainbit.com/lib-emotions

Instructions for integrating the Android SDK using JitPack. This involves configuring your project's Gradle files to include the JitPack repository and the SDK dependency.

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

dependencies {
    implementation 'com.github.BrainbitLLC:Emotional-state-artifacts:1.0.1'
}
```

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

dependencies {
    implementation("com.github.BrainbitLLC:Emotional-state-artifacts:1.0.1")
}
To prevent build errors add to build.gradle this settings:

```

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

### Create SpectrumMath Object

Source: https://sdk.brainbit.com/lib-spectrum

Instantiates the SpectrumMath object with essential parameters such as sampling rate, FFT window size, and processing frequency. This is the initial step before performing spectrum analysis.

```C++
int sampling_rate = 250; // raw signal sampling frequency
int fft_window = 1000; // spectrum calculation window length
int process_win_rate = 5; // spectrum calculation frequency
SpectrumMath* tSpectMathPtr = createSpectrumMath(sampling_rate, fft_window, process_win_rate);
            
```

```C#
int samplingRate = 250; // raw signal sampling frequency
int fftWindow = 1000; // spectrum calculation window length
int processWinRate = 5; // spectrum calculation frequency
SpectrumMath math = new SpectrumMath(samplingRate, fftWindow, processWinRate);
            
```

```Java
int samplingRate = 250; // raw signal sampling frequency
int fftWindow = 1000; // spectrum calculation window length
int processWinRate = 5; // spectrum calculation frequency
SpectrumMath math = new SpectrumMath(samplingRate, fftWindow, processWinRate);
            
```

```Python
sampling_rate = 250 # raw signal sampling frequency
fft_window = sampling_rate * 4 # spectrum calculation window length
process_win_rate = 5 # spectrum calculation frequency
spectrum_math = SpectrumMath(sampling_rate, fft_window, process_win_rate)
            
```

```Swift
let samplingRate: Int32 = 250 // raw signal sampling frequency
let fftWindow = samplingRate * 4 // spectrum calculation window length
let processWinRate: Int32 = 10 // spectrum calculation frequency
var math = SMSpectrumMath(sampleRate: samplingRate, andFftWindow: fftWindow, andProcessWinFreq: processWinRate)
            
```

```Objective-C
int sampling_rate = 250; // raw signal sampling frequency
int fft_window = 1000; // spectrum calculation window length
int process_win_rate = 5; // spectrum calculation frequency
SMSpectrumMath* math = [[SMSpectrumMath alloc] initWithSampleRate:sampling_rate andFftWindow:fft_window andProcessWinFreq:process_win_rate];
            
```

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

### Configure Math Library Settings (C++/C#/Java/Python/Swift/Objective-C)

Source: https://sdk.brainbit.com/lib-emotions

Configures various parameters of the math library, including calibration length, mental level estimation mode, skipping windows after artifacts, spectrum wave zeroing, and spectrum normalization by bandwidth. These settings fine-tune the analysis algorithms.

```C++
// setting calibration length
int calibration_length = 6;
MathLibSetCallibrationLength(tMathPtr, calibration_length, &opSt);

// type of evaluation of instant mental levels
bool independent_mental_levels = false;
MathLibSetMentalEstimationMode(tMathPtr, independent_mental_levels, &opSt);

// number of windows after the artifact with the previous actual value
int nwins_skip_after_artifact = 10;
MathLibSetSkipWinsAfterArtifact(tMathPtr, nwins_skip_after_artifact, &opSt);

// calculation of mental levels relative to calibration values
MathLibSetZeroSpectWaves(tMathPtr, true, 0, 1, 1, 1, 0, &opSt);

// spectrum normalization by bandwidth
MathLibSetSpectNormalizationByBandsWidth(tMathPtr, true);
```

```Objective-C
// setting calibration length
int calibrationLength = 6;
math.SetCallibrationLength(calibrationLength);

// type of evaluation of instant mental levels
bool independentMentalLevels = false;
math.SetMentalEstimationMode(independentMentalLevels);
```

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

### Start Scanner Search

Source: https://sdk.brainbit.com/sdk2_scanner

Initiates the device scanning process. This function starts the search for available devices. Ensure the scanner is properly initialized before calling this function.

```cpp
OpStatus outStatus;

startScanner(scanner, &outStatus);
            
```

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

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

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

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

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

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

```objective-c
[scanner startScan];
            
```

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

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

### Connect and Stream Data with Brainbit SDK (JavaScript)

Source: https://sdk.brainbit.com/web-quickstart

This example demonstrates how to initialize the Brainbit client, connect to a device, subscribe to various data streams (connection status, status data, event markers, EEG, and resistance), and handle connection errors.

```javascript
var brainbitClient = new BrainbitClient();

const connect = async () => {
  brainbitClient.connectionStatus.subscribe((status) => {
    console.log(status ? 'Connected!' : 'Disconnected');
  });
  try {
    await brainbitClient.connect();
    brainbitClient.statusData.subscribe((data) => {
      console.log('statusData', data);
    });
    brainbitClient.eventMarkers.subscribe((event) => {
      console.log(event);
    });
    brainbitClient.eegStream.subscribe((data) => {
      console.log(data);
    });
    brainbitClient.resistanceData.subscribe((data) => {
      console.log(data);
    });
  } catch (err) {
    console.error('Connection failed', err);
  }
};

const startEEG = () => {
  const startEEGStatus = await brainbitClient.startEEGStream();
  console.log('current status', startEEGStatus);
};
```

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

### Get Discovered Devices List - C#

Source: https://sdk.brainbit.com/sdk2_scanner

This C# snippet demonstrates how to get a list of discovered sensors. It accesses the 'Sensors' property of the scanner object, which returns an IReadOnlyList of SensorInfo.

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

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

### Install C++ Library for Linux

Source: https://sdk.brainbit.com/lib-spectrum

Download the C++ library for Linux from GitHub, specifically the .so file from the `linux_x86_64` folder, and add it to your project. This library is built on Astra Linux CE 2.12.46 and requires specific dependencies.

```text
Download from [GitHub](https://github.com/BrainbitLLC/spectrum-lib-cpp) and add .so from folder `linux_x86_64` to your project by your preferred way.

Library buit on Astra Linux CE 2.12.46, kernel 5.15.0-70-generic. Arch: x86_64 GNU/Linux
```

```bash
user@astra:~$ ldd --version
ldd (Debian GLIBC 2.28-10+deb10u1) 2.28
Copyright (C) 2018 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
Written by Roland McGrath and Ulrich Drepper.
```

```text
That library depends from others library, for instance:
linux-vdso.so.1
libblkid.so.1
libc++.so.1
libc++abi.so.1 
libc.so.6
libdl.so.2
libffi.so.6
libgcc_s.so.1
libgio-2.0.so.0
libglib-2.0.so.0
libgmodule-2.0.so.0
libgobject-2.0.so.0
libm.so.6
libmount.so.1
libpcre.so.3
libpthread.so.0
libresolv.so.2 
librt.so.1
libselinux.so.1
libstdc++.so.6
libudev.so.1
libuuid.so.1
libz.so.1
ld-linux-x86-64.so.2

If you are using a OS other than ours, these dependencies will be required for the library. You can download dependencies from [here](https://github.com/BrainbitLLC/linux_neurosdk2/tree/main/dependencies).
```

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

### Android: Start and Stop Signal Data Transmission

Source: https://sdk.brainbit.com/sdk-android-tutorial

Execute commands on the device to start or stop the transmission of signal data. This is important for managing battery consumption when data is not actively needed.

```java
device.execute(Command.StartSignal);
// ... later ...
device.execute(Command.StopSignal);
```

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

### Create BrainBit Sensor Object

Source: https://sdk.brainbit.com/brainbit-2-devices

This section provides code examples for creating a sensor object after searching for devices. It shows how to retrieve sensor information and use it to instantiate a sensor object for interaction. The device must be connected for all manipulations to succeed.

```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);

// 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]

// 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];

// 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]

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

```

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

### Add and Process Data using SDK BrainBit

Source: https://sdk.brainbit.com/lib-spectrum

Demonstrates how to add raw data samples and initiate data processing within the SDK BrainBit. This typically involves pushing data to a processing object and then triggering the computation. Ensure that the `SIGNAL_SAMPLES_COUNT` or equivalent is correctly defined.

```cpp
double* raw_data = new double[SIGNAL_SAMPLES_COUNT];
SpectrumMathPushData(tSpectMathPtr, raw_data, SIGNAL_SAMPLES_COUNT);
SpectrumMathProcessData(tSpectMathPtr);
```

```csharp
double[] samples = new double[SIGNAL_SAMPLES_COUNT];
math.PushData(samples);
// data processing into PushData method
```

```java
double[] samples = new double[SIGNAL_SAMPLES_COUNT];
math.pushData(data);
```

```python
samples = [0 for _ in range(sample_count)]
spectrum_math.push_data(samples)
spectrum_math.process_data()
```

```swift
var samples: [NSNumber] = []
math.pushAndProcessData(samples)
```

```objectivec
NSArray<NSNumber*>* samples = [NSArray new];
[math pushAndProcessData:samples];
```

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

### Install React Native NeuroSDK2 Package

Source: https://sdk.brainbit.com/sdk2_rn_install

This code snippet demonstrates how to install the react-native-neurosdk2 package using npm. This package is essential for integrating BrainBit SDK functionalities into React Native applications for both iOS and Android platforms.

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

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

### Get and Set Sampling Frequency for BrainBit SDK

Source: https://sdk.brainbit.com/sdk2_par_desc

Demonstrates how to get and set the sampling frequency of a physiological signal using the BrainBit SDK. The default sampling frequency is 250 Hz. This functionality is available in multiple programming languages.

```cpp
// get
SensorSamplingFrequency sensorSamplingFrequency;
OpStatus outStatus;
readSamplingFrequencySensor(sensor, &sensorSamplingFrequency, &outStatus);
```

```java
// get
SensorSamplingFrequency sf = sensor.getSamplingFrequency();
```

```csharp
SensorSamplingFrequency sf = sensor.SamplingFrequency;
```

```typescript
var sensorSamplingFrequency: SensorSamplingFrequency = sensor.getSamplingFrequency()
```

```python
sensorSamplingFrequency = sensor.sampling_frequency
```

```swift
var samplingFrequency: NTSensorSamplingFrequency? = sensor?.samplingFrequency;
```

```objectivec
NTSensorSamplingFrequency samplingFrequency = sensor.SamplingFrequency;
```

```dart
FSensorSamplingFrequency samplingFrequency = await sensor.samplingFrequency.value;
```

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

### GET /websites/sdk_brainbit/validate-email

Source: https://sdk.brainbit.com/ntdevicetype

Handles email validation for SDK update subscriptions.

```APIDOC
## GET /websites/sdk_brainbit/validate-email

### Description
Validates the user's email address for SDK update subscriptions. This endpoint is typically used after a user clicks a validation link in an email.

### Method
GET

### Endpoint
/websites/sdk_brainbit/validate-email

### Parameters
#### Query Parameters
- **token** (string) - Required - The validation token sent to the user's email.

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **message** (string) - A confirmation message indicating successful email validation.

#### Error Response (400)
- **message** (string) - An error message indicating that email validation failed.

#### Response Example
```json
{
  "message": "Thank you! You have successfully subscribed to the SDK update mailing list."
}
```
```

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

### Retrieve Sensor Info and Create Sensor (Objective-C)

Source: https://sdk.brainbit.com/brainbit-2-devices

This Objective-C snippet illustrates fetching sensor details and initializing a BrainBit2 sensor. It emphasizes that the `createSensor` method is blocking and necessitates execution within a separate thread.

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

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