User API

MindRove User API has three main modules:

  • BoardShim to read data from a board, it calls methods from underlying BoardController library

  • DataFilter to perform signal processing, it calls methods from underlying DataHandler library

  • MLModel to calculate derivative metrics, it calls methods from underlying MLModule library

These classes are independent, so if you want, you can use MindRove API only for data streaming and perform signal processing by yourself and vice versa.

MindRove data acqusition API is board agnostic, so to select a specific board you need to pass MindRove’s board id to BoardShim’s constructor and an instance of MindRoveInputParams structure which should hold information for your specific board, check Supported Boards. for details. This abstraction allows you to switch boards without any changes in code.

In BoardShim, all board data is returned as a 2d array. Rows in this array may contain timestamps, EEG and EMG data and so on. To see instructions how to query specific kind of data check Data Format Description and Code Samples.

Python API Reference

mindrove.board_shim

class mindrove.board_shim.BoardIds(value)

Bases: IntEnum

Enum to store all supported Board Ids

PLAYBACK_FILE_BOARD = -3
STREAMING_BOARD = -2
SYNTHETIC_BOARD = -1
MINDROVE_WIFI_BOARD = 0
MINDROVE_SYNCBOX_BOARD = 1
class mindrove.board_shim.MindroveConfigMode

Bases: object

Enum to store all supported Board Ids

EEG_MODE = b'\x00\x00\x00\x00\x00'
BEEP = b'\x01\x00\x00\x00\x00'
BOOP = b'\x02\x00\x00\x00\x00'
IMP_MODE = b'\x04\x00\x00\x00\x00'
TEST_MODE = b'\x10\x00\x00\x00\x00'
class mindrove.board_shim.IpProtocolTypes(value)

Bases: IntEnum

Enum to store Ip Protocol types

NO_IP_PROTOCOL = 0
UDP = 1
TCP = 2
class mindrove.board_shim.MindRovePresets(value)

Bases: IntEnum

Enum to store presets

DEFAULT_PRESET = 0
AUXILIARY_PRESET = 1
ANCILLARY_PRESET = 2
class mindrove.board_shim.MindRoveInputParams

Bases: object

inputs parameters for prepare_session method

Parameters:
  • serial_port (str) – serial port name is used for boards which reads data from serial port

  • mac_address (str) – mac address for example its used for bluetooth based boards

  • ip_address (str) – ip address is used for boards which reads data from socket connection

  • ip_address_aux (str) – ip address is used for boards which reads data from socket connection

  • ip_address_anc (str) – ip address is used for boards which reads data from socket connection

  • ip_port (int) – ip port for socket connection, for some boards where we know it in front you dont need this parameter

  • ip_port_aux (int) – ip port for socket connection, for some boards where we know it in front you dont need this parameter

  • ip_port_anc (int) – ip port for socket connection, for some boards where we know it in front you dont need this parameter

  • ip_protocol (int) – ip protocol type from IpProtocolTypes enum

  • other_info (str) – other info

  • serial_number (str) – serial number

  • file (str) – file

  • file_aux (str) – file

  • file_anc (str) – file

class mindrove.board_shim.BoardShim(board_id: int, input_params: MindRoveInputParams)

Bases: object

BoardShim class is a primary interface to all boards

Parameters:
  • board_id (int) – Id of your board

  • input_params (MindRoveInputParams) – board specific structure to pass required arguments

classmethod set_log_level(log_level: int) None

set MindRove log level, use it only if you want to write your own messages to MindRove logger, otherwise use enable_board_logger, enable_dev_board_logger or disable_board_logger

Parameters:

log_level (int) – log level, to specify it you should use values from LogLevels enum

classmethod enable_board_logger() None

enable MindRove Logger with level INFO, uses stderr for log messages by default

classmethod disable_board_logger() None

disable MindRove Logger

classmethod enable_dev_board_logger() None

enable MindRove Logger with level TRACE, uses stderr for log messages by default

classmethod log_message(log_level: int, message: str) None

write your own log message to MindRove logger, use it if you wanna have single logger for your own code and MindRove’s code

Parameters:
  • log_level – log level

  • message (str) – message

classmethod set_log_file(log_file: str) None

redirect logger from stderr to file, can be called any time

Parameters:

log_file (str) – log file name

classmethod get_sampling_rate(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) int

get sampling rate for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

sampling rate for this board id

Return type:

int

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_package_num_channel(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) int

get package num channel for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

number of package num channel

Return type:

int

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_battery_channel(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) int

get battery channel for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

number of batter channel

Return type:

int

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_num_rows(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) int

get number of rows in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

number of rows in returned numpy array

Return type:

int

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_timestamp_channel(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) int

get timestamp channel in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

number of timestamp channel in returned numpy array

Return type:

int

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_marker_channel(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) int

get marker channel in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

number of marker channel in returned numpy array

Return type:

int

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_eeg_names(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) List[str]

get names of EEG channels in 10-20 system if their location is fixed

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

EEG channels names

Return type:

List[str]

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_board_presets(board_id: int) List[str]

get available presets for this board id

Parameters:

board_id (int) – Board Id

Returns:

presets for this board id

Return type:

List[str]

:raises MindRoveError

classmethod get_version() str

get version of mindrove libraries

Returns:

version

Return type:

str

:raises MindRoveError

classmethod get_board_descr(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET)

get board description as json

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

info about board

Return type:

json

Raises:

MindRoveError – If there is no such board id exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_device_name(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) str

get device name

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

Device Name

Return type:

str

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_eeg_channels(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) List[int]

get list of eeg channels in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

list of eeg channels in returned numpy array

Return type:

List[int]

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_exg_channels(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) List[int]

get list of exg channels in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

list of eeg channels in returned numpy array

Return type:

List[int]

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_emg_channels(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) List[int]

get list of emg channels in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

list of eeg channels in returned numpy array

Return type:

List[int]

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_ecg_channels(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) List[int]

get list of ecg channels in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

list of ecg channels in returned numpy array

Return type:

List[int]

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_eog_channels(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) List[int]

get list of eog channels in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

list of eog channels in returned numpy array

Return type:

List[int]

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_eda_channels(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) List[int]

get list of eda channels in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

list of eda channels in returned numpy array

Return type:

List[int]

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_ppg_channels(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) List[int]

get list of ppg channels in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

list of ppg channels in returned numpy array

Return type:

List[int]

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_accel_channels(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) List[int]

get list of accel channels in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

list of accel channels in returned numpy array

Return type:

List[int]

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_rotation_channels(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) List[int]

get list of rotation channels in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

list of rotation channels in returned numpy array

Return type:

List[int]

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_analog_channels(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) List[int]

get list of analog channels in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

list of analog channels in returned numpy array

Return type:

List[int]

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_gyro_channels(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) List[int]

get list of gyro channels in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

list of gyro channels in returned numpy array

Return type:

List[int]

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_other_channels(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) List[int]

get list of other channels in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

list of other channels in returned numpy array

Return type:

List[int]

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_temperature_channels(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) List[int]

get list of temperature channels in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

list of temperature channels in returned numpy array

Return type:

List[int]

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_resistance_channels(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) List[int]

get list of resistance channels in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

list of resistance channels in returned numpy array

Return type:

List[int]

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod get_magnetometer_channels(board_id: int, preset: int = MindRovePresets.DEFAULT_PRESET) List[int]

get list of magnetometer channels in resulting data table for a board

Parameters:
  • board_id (int) – Board Id

  • preset (int) – preset

Returns:

list of magnetometer channels in returned numpy array

Return type:

List[int]

Raises:

MindRoveError – If this board has no such data exit code is UNSUPPORTED_BOARD_ERROR

classmethod release_all_sessions() None

release all prepared sessions

prepare_session() None

prepare streaming sesssion, init resources, you need to call it before any other BoardShim object methods

add_streamer(streamer_params: str, preset: int = MindRovePresets.DEFAULT_PRESET) None

Add streamer

Parameters:
  • preset (int) – preset

  • vals (streamer_params parameter to stream data from mindrove, supported) – “file://%file_name%:w”, “file://%file_name%:a”, “streaming_board://%multicast_group_ip%:%port%”. Range for multicast addresses is from “224.0.0.0” to “239.255.255.255”

delete_streamer(streamer_params: str, preset: int = MindRovePresets.DEFAULT_PRESET) None

Delete streamer

Parameters:
  • preset (int) – preset

  • vals (streamer_params parameter to stream data from mindrove, supported) – “file://%file_name%:w”, “file://%file_name%:a”, “streaming_board://%multicast_group_ip%:%port%”. Range for multicast addresses is from “224.0.0.0” to “239.255.255.255”

start_stream(num_samples: int = 450000, streamer_params: str | None = None) None

Start streaming data, this methods stores data in ringbuffer

Parameters:
  • num_samples (int) – size of ring buffer to keep data

  • vals (streamer_params parameter to stream data from mindrove, supported) – “file://%file_name%:w”, “file://%file_name%:a”, “streaming_board://%multicast_group_ip%:%port%”. Range for multicast addresses is from “224.0.0.0” to “239.255.255.255”

stop_stream() None

Stop streaming data

release_session() None

release all resources

get_current_board_data(num_samples: int, preset: int = MindRovePresets.DEFAULT_PRESET)

Get specified amount of data or less if there is not enough data, doesnt remove data from ringbuffer

Parameters:
  • num_samples (int) – max number of samples

  • preset (int) – preset

Returns:

latest data from a board

Return type:

NDArray[Float64]

get_board_data_count(preset: int = MindRovePresets.DEFAULT_PRESET) int

Get num of elements in ringbuffer

Parameters:

preset (int) – preset

Returns:

number of elements in ring buffer

Return type:

int

get_board_id() int

Get’s the actual board id, can be different than provided

Returns:

board id

Return type:

int

insert_marker(value: float, preset: int = MindRovePresets.DEFAULT_PRESET) None

Insert Marker to Data Stream

Parameters:
  • value (float) – value to insert

  • preset (int) – preset

Returns:

board id

Return type:

int

is_prepared() bool

Check if session is ready or not

Returns:

session status

Return type:

bool

get_board_data(num_samples=None, preset: int = MindRovePresets.DEFAULT_PRESET)

Get board data and remove data from ringbuffer

Parameters:
  • num_samples (int) – number of packages to get

  • preset (int) – preset

Returns:

all data from a board if num_samples is None, num_samples packages or less if not None

Return type:

NDArray[Float64]

config_board(config) None

Use this method carefully and only if you understand what you are doing, do NOT use it to start or stop streaming

Parameters:

config (str) – string to send to a board

Returns:

response string if any

Return type:

str

mindrove.exit_codes

exception mindrove.exit_codes.MindRoveError(message: str, exit_code: int)

Bases: Exception

This exception is raised if non-zero exit code is returned from C code

Parameters:
  • message (str) – exception message

  • exit_code (int) – exit code flow low level API

class mindrove.exit_codes.MindRoveExitCodes(value)

Bases: IntEnum

Enum to store all possible exit codes

STATUS_OK = 0
PORT_ALREADY_OPEN_ERROR = 1
UNABLE_TO_OPEN_PORT_ERROR = 2
SER_PORT_ERROR = 3
BOARD_WRITE_ERROR = 4
INCOMMING_MSG_ERROR = 5
INITIAL_MSG_ERROR = 6
BOARD_NOT_READY_ERROR = 7
STREAM_ALREADY_RUN_ERROR = 8
INVALID_BUFFER_SIZE_ERROR = 9
STREAM_THREAD_ERROR = 10
STREAM_THREAD_IS_NOT_RUNNING = 11
EMPTY_BUFFER_ERROR = 12
INVALID_ARGUMENTS_ERROR = 13
UNSUPPORTED_BOARD_ERROR = 14
BOARD_NOT_CREATED_ERROR = 15
ANOTHER_BOARD_IS_CREATED_ERROR = 16
GENERAL_ERROR = 17
SYNC_TIMEOUT_ERROR = 18
JSON_NOT_FOUND_ERROR = 19
NO_SUCH_DATA_IN_JSON_ERROR = 20
CLASSIFIER_IS_NOT_PREPARED_ERROR = 21
ANOTHER_CLASSIFIER_IS_PREPARED_ERROR = 22
UNSUPPORTED_CLASSIFIER_AND_METRIC_COMBINATION_ERROR = 23

mindrove.data_filter

class mindrove.data_filter.FilterTypes(value)

Bases: IntEnum

Enum to store all supported Filter Types

BUTTERWORTH = 0
CHEBYSHEV_TYPE_1 = 1
BESSEL = 2
BUTTERWORTH_ZERO_PHASE = 3
CHEBYSHEV_TYPE_1_ZERO_PHASE = 4
BESSEL_ZERO_PHASE = 5
class mindrove.data_filter.AggOperations(value)

Bases: IntEnum

Enum to store all supported aggregation operations

MEAN = 0
MEDIAN = 1
EACH = 2
class mindrove.data_filter.WindowOperations(value)

Bases: IntEnum

Enum to store all supported window functions

NO_WINDOW = 0
HANNING = 1
HAMMING = 2
BLACKMAN_HARRIS = 3
class mindrove.data_filter.DetrendOperations(value)

Bases: IntEnum

Enum to store all supported detrend options

NO_DETREND = 0
CONSTANT = 1
LINEAR = 2
class mindrove.data_filter.NoiseTypes(value)

Bases: IntEnum

Enum to store noise types

FIFTY = 0
SIXTY = 1
FIFTY_AND_SIXTY = 2
class mindrove.data_filter.WaveletDenoisingTypes(value)

Bases: IntEnum

Enum to store all supported wavelet denoising methods

VISUSHRINK = 0
SURESHRINK = 1
class mindrove.data_filter.ThresholdTypes(value)

Bases: IntEnum

Enum to store all supported thresholding types

SOFT = 0
HARD = 1
class mindrove.data_filter.WaveletExtensionTypes(value)

Bases: IntEnum

Enum to store all supported wavelet extension types

SYMMETRIC = 0
PERIODIC = 1
class mindrove.data_filter.NoiseEstimationLevelTypes(value)

Bases: IntEnum

Enum to store all supported values for noise estemation levels in wavelet denoising

FIRST_LEVEL = 0
ALL_LEVELS = 1
class mindrove.data_filter.WaveletTypes(value)

Bases: IntEnum

Enum to store all supported wavelets

HAAR = 0
DB1 = 1
DB2 = 2
DB3 = 3
DB4 = 4
DB5 = 5
DB6 = 6
DB7 = 7
DB8 = 8
DB9 = 9
DB10 = 10
DB11 = 11
DB12 = 12
DB13 = 13
DB14 = 14
DB15 = 15
BIOR1_1 = 16
BIOR1_3 = 17
BIOR1_5 = 18
BIOR2_2 = 19
BIOR2_4 = 20
BIOR2_6 = 21
BIOR2_8 = 22
BIOR3_1 = 23
BIOR3_3 = 24
BIOR3_5 = 25
BIOR3_7 = 26
BIOR3_9 = 27
BIOR4_4 = 28
BIOR5_5 = 29
BIOR6_8 = 30
COIF1 = 31
COIF2 = 32
COIF3 = 33
COIF4 = 34
COIF5 = 35
SYM2 = 36
SYM3 = 37
SYM4 = 38
SYM5 = 39
SYM6 = 40
SYM7 = 41
SYM8 = 42
SYM9 = 43
SYM10 = 44
class mindrove.data_filter.DataFilter

Bases: object

DataFilter class contains methods for signal processig

classmethod set_log_level(log_level: int) None

set MindRove log level, use it only if you want to write your own messages to MindRove logger, otherwise use enable_data_logger, enable_dev_data_logger or disable_data_logger

Parameters:

log_level (int) – log level, to specify it you should use values from LogLevels enum

classmethod enable_data_logger() None

enable Data Logger with level INFO, uses stderr for log messages by default

classmethod disable_data_logger() None

disable Data Logger

classmethod enable_dev_data_logger() None

enable Data Logger with level TRACE, uses stderr for log messages by default

classmethod set_log_file(log_file: str) None

redirect logger from stderr to file, can be called any time

Parameters:

log_file (str) – log file name

classmethod perform_lowpass(data, sampling_rate: int, cutoff: float, order: int, filter_type: int, ripple: float) None

apply low pass filter to provided data

Parameters:
  • data (NDArray[Float64]) – data to filter, filter works in-place

  • sampling_rate (int) – board’s sampling rate

  • cutoff (float) – cutoff frequency

  • order (int) – filter order

  • filter_type (int) – filter type from special enum

  • ripple (float) – ripple value for Chebyshev filter

classmethod perform_highpass(data, sampling_rate: int, cutoff: float, order: int, filter_type: int, ripple: float) None

apply high pass filter to provided data

Parameters:
  • data (NDArray[Float64]) – data to filter, filter works in-place

  • sampling_rate (int) – board’s sampling rate

  • cutoff (float) – cutoff frequency

  • order (int) – filter order

  • filter_type (int) – filter type from special enum

  • ripple (float) – ripple value for Chebyshev filter

classmethod perform_bandpass(data, sampling_rate: int, start_freq: float, stop_freq: float, order: int, filter_type: int, ripple: float) None

apply band pass filter to provided data

Parameters:
  • data (NDArray[Float64]) – data to filter, filter works in-place

  • sampling_rate (int) – board’s sampling rate

  • start_freq (float) – start frequency

  • stop_freq (float) – stop frequency

  • order (int) – filter order

  • filter_type (int) – filter type from special enum

  • ripple (float) – ripple value for Chebyshev filter

classmethod perform_bandstop(data, sampling_rate: int, start_freq: float, stop_freq: float, order: int, filter_type: int, ripple: float) None

apply band stop filter to provided data

Parameters:
  • data (NDArray[Float64]) – data to filter, filter works in-place

  • sampling_rate (int) – board’s sampling rate

  • start_freq (float) – start frequency

  • stop_freq (float) – stop frequency

  • order (int) – filter order

  • filter_type (int) – filter type from special enum

  • ripple (float) – ripple value for Chebyshev filter

classmethod remove_environmental_noise(data, sampling_rate: int, noise_type: float) None

remove env noise using notch filter

Parameters:
  • data (NDArray[Float64]) – data to filter, filter works in-place

  • sampling_rate (int) – board’s sampling rate

  • noise_type (int) – noise type

classmethod perform_rolling_filter(data, period: int, operation: int) None

smooth data using moving average or median

Parameters:
  • data (NDArray[Float64]) – data to smooth, it works in-place

  • period (int) – window size

  • operation (int) – int value from AggOperation enum

classmethod calc_stddev(data)

calc stddev

Parameters:

data (NDArray[Float64]) – input array

Returns:

stddev

Return type:

float

classmethod get_railed_percentage(data, gain: int)

get railed percentage

Parameters:
  • data (NDArray[Float64]) – input array

  • gain (int) – gain

Returns:

railed percentage

Return type:

float

classmethod get_oxygen_level(ppg_ir, ppg_red, sampling_rate: int, coef1=1.5958422, coef2=-34.6596622, coef3=112.6898759)

get oxygen level from ppg

Parameters:
  • ppg_ir (NDArray[Float64]) – input array

  • ppg_red (NDArray[Float64]) – input array

  • sampling_rate (int) – sampling rate

Returns:

oxygen level

Return type:

float

classmethod get_heart_rate(ppg_ir, ppg_red, sampling_rate: int, fft_size: int)

get heart rate

Parameters:
  • ppg_ir (NDArray[Float64]) – input array

  • ppg_red (NDArray[Float64]) – input array

  • sampling_rate (int) – sampling rate

  • fft_size (int) – recommended 8192

Returns:

heart rate

Return type:

float

classmethod perform_downsampling(data, period: int, operation: int)

perform data downsampling, it doesnt apply lowpass filter for you, it just aggregates several data points

Parameters:
  • data (NDArray[Float64]) – initial data

  • period (int) – downsampling period

  • operation (int) – int value from AggOperation enum

Returns:

downsampled data

Return type:

NDArray[Float64]

classmethod perform_wavelet_transform(data, wavelet: int, decomposition_level: int, extension_type=WaveletExtensionTypes.SYMMETRIC) Tuple

perform wavelet transform

Parameters:
  • data (NDArray[Float64]) – initial data

  • wavelet (int) – use WaveletTypes enum

  • decomposition_level (int) – level of decomposition

  • extension_type – extension type, use WaveletExtensionTypes

Returns:

tuple of wavelet coeffs in format [A(J) D(J) D(J-1) ….. D(1)] where J is decomposition level, A - app coeffs, D - detailed coeffs, and array with lengths for each block

Return type:

tuple

classmethod restore_data_from_wavelet_detailed_coeffs(data, wavelet, decomposition_level, level_to_restore)

restore data from a single wavelet coeff

Parameters:
  • data (NDArray[Float64]) – initial data

  • wavelet (int) – use WaveletTypes enum

  • decomposition_level (int) – level of decomposition

  • level_to_restore (int) – level of coeffs

Returns:

Return type:

NDArray[Float64]

classmethod detect_peaks_z_score(data, lag=5, threshold=3.5, influence=0.1)

z score algorithm for peak detection

Parameters:
  • data (NDArray[Float64]) – initial data

  • lag (int) – window size for averaging

  • threshold (float) – in stddev units

  • influence (float) – contribution of peaks to mean value, between 0 and 1

Returns:

Return type:

NDArray[Float64]

classmethod perform_inverse_wavelet_transform(wavelet_output: Tuple, original_data_len: int, wavelet: int, decomposition_level: int, extension_type=WaveletExtensionTypes.SYMMETRIC)

perform wavelet transform

Parameters:
  • wavelet_output – tuple of wavelet_coeffs and array with lengths

  • original_data_len (int) – len of signal before wavelet transform

  • wavelet (int) – use WaveletTypes enum

  • decomposition_level (int) – level of decomposition

  • extension_type – extension type, use WaveletExtensionTypes

Returns:

restored data

Return type:

NDArray[Float64]

classmethod perform_wavelet_denoising(data, wavelet: int, decomposition_level: int, wavelet_denoising=WaveletDenoisingTypes.SURESHRINK, threshold=ThresholdTypes.HARD, extension_type=WaveletExtensionTypes.SYMMETRIC, noise_level=NoiseEstimationLevelTypes.FIRST_LEVEL) None

perform wavelet denoising

Parameters:
  • data (NDArray[Float64]) – data to denoise

  • wavelet (int) – use WaveletTypes enum

  • decomposition_level (int) – decomposition level

  • wavelet_denoising (int) – use WaveletDenoisingTypes enum

  • threshold (int) – use ThresholdTypes enum

  • extension_type (int) – use WaveletExtensionTypes enum

  • noise_level (int) – use NoiseEstimationLevelTypes enum

classmethod get_csp(data, labels) Tuple

calculate filters and the corresponding eigenvalues using the Common Spatial Patterns

Parameters:
  • data (NDArray[Float64]) – [epochs x channels x times]-shaped 3D array of data for two classes

  • labels (NDArray[Int64]) – n_epochs-length 1D array of zeros and ones that assigns class labels for each epoch. Zero corresponds to the first class

Returns:

[channels x channels]-shaped 2D array of filters and [channels]-length 1D array of the corresponding eigenvalues

Return type:

Tuple

classmethod get_window(window_function: int, window_len: int)

perform data windowing

Parameters:
  • window_function – window function

  • window_len – len of the window function

Returns:

numpy array, len of the array is the same as data

Return type:

NDArray[Float64]

classmethod perform_fft(data, window: int)

perform direct fft

Parameters:
  • data (NDArray[Float64]) – data for fft, len of data must be even

  • window (int) – window function

Returns:

numpy array of complex values, len of this array is N / 2 + 1

Return type:

NDArray[Complex128]

classmethod get_psd(data, sampling_rate: int, window: int) Tuple

calculate PSD

Parameters:
  • data (NDArray[Float64]) – data to calc psd, len of data must be even

  • sampling_rate (int) – sampling rate

  • window (int) – window function

Returns:

amplitude and frequency arrays of len N / 2 + 1

Return type:

tuple

classmethod get_psd_welch(data, nfft: int, overlap: int, sampling_rate: int, window: int) Tuple

calculate PSD using Welch method

Parameters:
  • data (NDArray[Float64]) – data to calc psd

  • nfft (int) – FFT Window size, must be even

  • overlap (int) – overlap of FFT Windows, must be between 0 and nfft

  • sampling_rate (int) – sampling rate

  • window (int) – window function

Returns:

amplitude and frequency arrays of len N / 2 + 1

Return type:

tuple

classmethod detrend(data, detrend_operation: int) None

detrend data

Parameters:
  • data (NDArray[Float64]) – data to calc psd

  • detrend_operation (int) – Type of detrend operation

classmethod get_band_power(psd: Tuple, freq_start: float, freq_end: float) float

calculate band power

Parameters:
  • psd (tuple) – psd from get_psd

  • freq_start (int) – start freq

  • freq_end (int) – end freq

Returns:

band power

Return type:

float

classmethod get_avg_band_powers(data, channels: List, sampling_rate: int, apply_filter: bool) Tuple

calculate avg and stddev of BandPowers across all channels, bands are 1-4,4-8,8-13,13-30,30-50

Parameters:
  • data (NDArray) – 2d array for calculation

  • channels (List) – channels - rows of data array which should be used for calculation

  • sampling_rate (int) – sampling rate

  • apply_filter (bool) – apply bandpass and bandstop filtrers or not

Returns:

avg and stddev arrays for bandpowers

Return type:

tuple

classmethod get_custom_band_powers(data, bands: List, channels: List, sampling_rate: int, apply_filter: bool) Tuple

calculate avg and stddev of BandPowers across selected channels

Parameters:
  • data (NDArray) – 2d array for calculation

  • bands (List) – List of typles with bands to use. E.g [(1.5, 4.0), (4.0, 8.0), (8.0, 13.0), (13.0, 30.0), (30.0, 45.0)]

  • channels (List) – channels - rows of data array which should be used for calculation

  • sampling_rate (int) – sampling rate

  • apply_filter (bool) – apply bandpass and bandstop filtrers or not

Returns:

avg and stddev arrays for bandpowers

Return type:

tuple

classmethod perform_ica(data, num_components: int, channels=None) Tuple

perform ICA

Parameters:
  • data (NDArray) – 2d array for calculation

  • num_components (int) – number of components

  • channels (List) – channels - rows of data array which should be used for calculation, if None use all

Returns:

w, k, a, s matrixes as a tuple

Return type:

tuple

classmethod perform_ifft(data)

perform inverse fft

Parameters:

data (NDArray[Complex128]) – data from fft

Returns:

restored data

Return type:

NDArray[Float64]

classmethod get_nearest_power_of_two(value: int) int

calc nearest power of two

Parameters:

value (int) – input value

Returns:

nearest power of two

Return type:

int

classmethod write_file(data, file_name: str, file_mode: str) None

write data to file, in file data will be transposed

Parameters:
  • data (2d numpy array) – data to store in a file

  • file_name (str) – file name to store data

  • file_mode (str) – ‘w’ to rewrite file or ‘a’ to append data to file

classmethod read_file(file_name: str)

read data from file

Parameters:

file_name (str) – file name to read

Returns:

2d numpy array with data from this file, data will be transposed to original dimensions

Return type:

2d numpy array

classmethod get_version() str

get version of mindrove libraries

Returns:

version

Return type:

str

:raises MindRoveError

classmethod log_message(log_level: int, message: str) None

write your own log message to MindRove logger, use it if you wanna have single logger for your own code and MindRove’s code

Parameters:
  • log_level – log level

  • message (str) – message

mindrove.ml_model

class mindrove.ml_model.MindRoveMetrics(value)

Bases: IntEnum

Enum to store all supported metrics

MINDFULNESS = 0
RESTFULNESS = 1
USER_DEFINED = 2
class mindrove.ml_model.MindRoveClassifiers(value)

Bases: IntEnum

Enum to store all supported classifiers

DEFAULT_CLASSIFIER = 0
DYN_LIB_CLASSIFIER = 1
ONNX_CLASSIFIER = 2
class mindrove.ml_model.MindRoveModelParams(metric, classifier)

Bases: object

inputs parameters for prepare_session method

Parameters:
  • metric (int) – metric to calculate

  • classifier (int) – classifier to use

  • file (str) – file to load model

  • other_info (str) – additional information

  • output_name (str) – output node name

  • max_array_size (int) – max array size to preallocate

class mindrove.ml_model.MLModel(model_params: MindRoveModelParams)

Bases: object

MLModel class used to calc derivative metrics from raw data

Parameters:

model_params (MindRoveModelParams) – Model Params

classmethod set_log_level(log_level: int) None

set MindRove log level, use it only if you want to write your own messages to MindRove logger, otherwise use enable_ml_logger, enable_dev_ml_logger or disable_ml_logger

Parameters:

log_level (int) – log level, to specify it you should use values from LogLevels enum

classmethod enable_ml_logger() None

enable ML Logger with level INFO, uses stderr for log messages by default

classmethod disable_ml_logger() None

disable MindRove Logger

classmethod enable_dev_ml_logger() None

enable ML Logger with level TRACE, uses stderr for log messages by default

classmethod set_log_file(log_file: str) None

redirect logger from stderr to file, can be called any time

Parameters:

log_file (str) – log file name

classmethod log_message(log_level: int, message: str) None

write your own log message to MindRove logger, use it if you wanna have single logger for your own code and MindRove’s code

Parameters:
  • log_level – log level

  • message (str) – message

classmethod release_all() None

release all classifiers

classmethod get_version() str

get version of mindrove libraries

Returns:

version

Return type:

str

:raises MindRoveError

prepare() None

prepare classifier

release() None

release classifier

predict(data) List

calculate metric from data

Parameters:

data (NDArray) – input array

Returns:

metric value

Return type:

List

C++ API Reference

BoardShim class

Warning

doxygenclass: Unable to find project ‘MindRoveCpp’ in breathe_projects dictionary

DataFilter class

Warning

doxygenclass: Unable to find project ‘MindRoveCpp’ in breathe_projects dictionary

MLModel class

Warning

doxygenclass: Unable to find project ‘MindRoveCpp’ in breathe_projects dictionary

MindRove constants

#pragma once

enum class MindRoveExitCodes : int
{
    STATUS_OK = 0,
    PORT_ALREADY_OPEN_ERROR = 1,
    UNABLE_TO_OPEN_PORT_ERROR = 2,
    SET_PORT_ERROR = 3,
    BOARD_WRITE_ERROR = 4,
    INCOMMING_MSG_ERROR = 5,
    INITIAL_MSG_ERROR = 6,
    BOARD_NOT_READY_ERROR = 7,
    STREAM_ALREADY_RUN_ERROR = 8,
    INVALID_BUFFER_SIZE_ERROR = 9,
    STREAM_THREAD_ERROR = 10,
    STREAM_THREAD_IS_NOT_RUNNING = 11,
    EMPTY_BUFFER_ERROR = 12,
    INVALID_ARGUMENTS_ERROR = 13,
    UNSUPPORTED_BOARD_ERROR = 14,
    BOARD_NOT_CREATED_ERROR = 15,
    ANOTHER_BOARD_IS_CREATED_ERROR = 16,
    GENERAL_ERROR = 17,
    SYNC_TIMEOUT_ERROR = 18,
    JSON_NOT_FOUND_ERROR = 19,
    NO_SUCH_DATA_IN_JSON_ERROR = 20,
    CLASSIFIER_IS_NOT_PREPARED_ERROR = 21,
    ANOTHER_CLASSIFIER_IS_PREPARED_ERROR = 22,
    UNSUPPORTED_CLASSIFIER_AND_METRIC_COMBINATION_ERROR = 23
};

enum class BoardIds : int
{
    NO_BOARD = -100, // only for internal usage
    PLAYBACK_FILE_BOARD = -3,
    STREAMING_BOARD = -2,
    SYNTHETIC_BOARD = -1,
    MINDROVE_WIFI_BOARD = 0,
    MINDROVE_SYNCBOX_BOARD = 1,
    // use it to iterate
    FIRST = PLAYBACK_FILE_BOARD,
    LAST = MINDROVE_SYNCBOX_BOARD
};

enum class IpProtocolTypes : int
{
    NO_IP_PROTOCOL = 0,
    UDP = 1,
    TCP = 2
};

enum class FilterTypes : int
{
    BUTTERWORTH = 0,
    CHEBYSHEV_TYPE_1 = 1,
    BESSEL = 2,
    BUTTERWORTH_ZERO_PHASE = 3,
    CHEBYSHEV_TYPE_1_ZERO_PHASE = 4,
    BESSEL_ZERO_PHASE = 5
};

enum class AggOperations : int
{
    MEAN = 0,
    MEDIAN = 1,
    EACH = 2
};

enum class WindowOperations : int
{
    NO_WINDOW = 0,
    HANNING = 1,
    HAMMING = 2,
    BLACKMAN_HARRIS = 3
};

enum class DetrendOperations : int
{
    NO_DETREND = 0,
    CONSTANT = 1,
    LINEAR = 2
};

enum class MindRoveMetrics : int
{
    MINDFULNESS = 0,
    RESTFULNESS = 1,
    USER_DEFINED = 2
};

enum class MindRoveClassifiers : int
{
    DEFAULT_CLASSIFIER = 0,
    DYN_LIB_CLASSIFIER = 1,
    ONNX_CLASSIFIER = 2
};

enum class MindRovePresets : int
{
    DEFAULT_PRESET = 0,
    AUXILIARY_PRESET = 1,
    ANCILLARY_PRESET = 2
};

enum class LogLevels : int
{
    LEVEL_TRACE = 0,
    LEVEL_DEBUG = 1,
    LEVEL_INFO = 2,
    LEVEL_WARN = 3,
    LEVEL_ERROR = 4,
    LEVEL_CRITICAL = 5,
    LEVEL_OFF = 6
};

enum class NoiseTypes : int
{
    FIFTY = 0,
    SIXTY = 1,
    FIFTY_AND_SIXTY = 2
};

enum class WaveletDenoisingTypes : int
{
    VISUSHRINK = 0,
    SURESHRINK = 1
};

enum class ThresholdTypes : int
{
    SOFT = 0,
    HARD = 1
};

enum class WaveletExtensionTypes : int
{
    SYMMETRIC = 0,
    PERIODIC = 1
};

enum class NoiseEstimationLevelTypes : int
{
    FIRST_LEVEL = 0,
    ALL_LEVELS = 1
};

enum class WaveletTypes : int
{
    HAAR = 0,
    DB1 = 1,
    DB2 = 2,
    DB3 = 3,
    DB4 = 4,
    DB5 = 5,
    DB6 = 6,
    DB7 = 7,
    DB8 = 8,
    DB9 = 9,
    DB10 = 10,
    DB11 = 11,
    DB12 = 12,
    DB13 = 13,
    DB14 = 14,
    DB15 = 15,
    BIOR1_1 = 16,
    BIOR1_3 = 17,
    BIOR1_5 = 18,
    BIOR2_2 = 19,
    BIOR2_4 = 20,
    BIOR2_6 = 21,
    BIOR2_8 = 22,
    BIOR3_1 = 23,
    BIOR3_3 = 24,
    BIOR3_5 = 25,
    BIOR3_7 = 26,
    BIOR3_9 = 27,
    BIOR4_4 = 28,
    BIOR5_5 = 29,
    BIOR6_8 = 30,
    COIF1 = 31,
    COIF2 = 32,
    COIF3 = 33,
    COIF4 = 34,
    COIF5 = 35,
    SYM2 = 36,
    SYM3 = 37,
    SYM4 = 38,
    SYM5 = 39,
    SYM6 = 40,
    SYM7 = 41,
    SYM8 = 42,
    SYM9 = 43,
    SYM10 = 44,
    // to iterate and check sizes
    FIRST_WAVELET = HAAR,
    LAST_WAVELET = SYM10
};

C# API Reference

Content of C# mindrove namespace is similar to C++ API.

Matlab API Reference

Matlab binding calls C/C++ code as any other binding, it’s not compatible with Octave.

A few general rules to keep in mind:

  • Use char arrays instead strings to work with MindRove API, it means 'my_string' instead "my_string", otherwise you will get calllib error

  • Use int32 values intead enums, it means int32 (BoardIDs.SYNTHETIC_BOARD) instead BoardIDs.SYNTHETIC_BOARD, the same is true for all enums in MindRove API

class mindrove.WaveletDenoisingTypes

Bases: int32

Store all possible denoising methods for wavelets

class mindrove.MLModel

MLModel for inference

Method Summary
static release_all()

release all sessions

static log_message(log_level, message)

write message to ML logger

static set_log_level(log_level)

set log level for MLModel

static set_log_file(log_file)

set log file for MLModel

static enable_ml_logger()

enable logger with level INFO

static enable_dev_ml_logger()

enable logger with level TRACE

static disable_ml_logger()

disable logger

static get_version()

get version

prepare()

prepare model

release()

release model

predict(input_data)

perform inference for input data

class mindrove.LogLevels

Bases: int32

Store all possible log levels

class mindrove.BoardShim

BoardShim object to communicate with device

BoardShim constructor

Method Summary
static release_all_sessions()

release all sessions

static set_log_level(log_level)

set log level for BoardShim

static set_log_file(log_file)

set log file for BoardShim, logger uses stderr by default

static enable_board_logger()

enable logger with level INFO

static enable_dev_board_logger()

enable logger with level TRACE

static disable_board_logger()

disable logger

static log_message(log_level, message)

write message to BoardShim logger

static get_sampling_rate(board_id, preset)

get sampling rate for provided board id

static get_package_num_channel(board_id, preset)

get package num channel for provided board id

static get_marker_channel(board_id, preset)

get marker channel for provided board id

static get_battery_channel(board_id, preset)

get battery channel for provided board id

static get_num_rows(board_id, preset)

get num rows for provided board id

static get_timestamp_channel(board_id, preset)

get timestamp channel for provided board id

static get_board_descr(board_id, preset)

get board descr for provided board id

static get_eeg_names(board_id, preset)

get eeg names for provided board id

static get_board_presets(board_id)

get supported presets

static get_version()

get version

static get_device_name(board_id, preset)

get device name for provided board id

static get_eeg_channels(board_id, preset)

get eeg channels for provided board id

static get_exg_channels(board_id, preset)

get exg channels for provided board id

static get_emg_channels(board_id, preset)

get emg channels for provided board id

static get_ecg_channels(board_id, preset)

get ecg channels for provided board id

static get_eog_channels(board_id, preset)

get eog channels for provided board id

static get_ppg_channels(board_id, preset)

get ppg channels for provided board id

static get_eda_channels(board_id, preset)

get eda channels for provided board id

static get_accel_channels(board_id, preset)

get accel channels for provided board id

static get_rotation_channels(board_id, preset)

get rotation channels for provided board id

static get_analog_channels(board_id, preset)

get analog channels for provided board id

static get_other_channels(board_id, preset)

get other channels for provided board id

static get_temperature_channels(board_id, preset)

get temperature channels for provided board id

static get_resistance_channels(board_id, preset)

get resistance channels for provided board id

static get_magnetometer_channels(board_id, preset)

get magnetometer channels for provided board id

prepare_session()

prepare BoardShim session

config_board(config)

send string to the board

add_streamer(streamer, preset)

add streamer

delete_streamer(streamer, preset)

delete streamer

start_stream(buffer_size, streamer_params)

start data acqusition

stop_stream()

stop acqusition

release_session()

release session

insert_marker(value, preset)

insert marker

get_board_data_count(preset)

get amount of datapoints in internal buffer

get_board_data(num_datapoints, preset)

get required amount of data by specifying it and remove it from the buffer

get_current_board_data(num_samples, preset)

get latest datapoints, doesnt remove it from internal buffer

is_prepared()

check if mindrove session prepared

class mindrove.DetrendOperations

Bases: int32

Store possible detrend operations

class mindrove.IpProtocolTypes

Bases: int32

Store all possible IP protocols

class mindrove.WaveletTypes

Bases: int32

Store all possible Wavelet Types

class mindrove.MindRoveExitCodes

Bases: int32

Store all possible exit codes

class mindrove.BoardIds

Bases: int32

Store all supported board ids

class mindrove.MindRovePresets

Bases: int32

Store all supported presets

class mindrove.WindowOperations

Bases: int32

Store window functions

class mindrove.FilterTypes

Bases: int32

Store all possible filters

class mindrove.ThresholdTypes

Bases: int32

Store all possible threshold types

class mindrove.WaveletExtensionTypes

Bases: int32

Store all possible extensions

class mindrove.AggOperations

Bases: int32

Store all supported Agg Operations

class mindrove.MindRoveMetrics

Bases: int32

Store all supported metrics

class mindrove.NoiseTypes

Bases: int32

Store noise types

class mindrove.DataFilter

DataFilter class for signal processing

Method Summary
static get_version()

get version

static log_message(log_level, message)

write message to Data Filter logger

static set_log_level(log_level)

set log level for DataFilter

static set_log_file(log_file)

set log file for DataFilter

static enable_data_logger()

enable logger with level INFO

static enable_dev_data_logger()

enable logger with level TRACE

static disable_data_logger()

disable logger

static perform_lowpass(data, sampling_rate, cutoff, order, filter_type, ripple)

perform lowpass filtering

static perform_highpass(data, sampling_rate, cutoff, order, filter_type, ripple)

perform highpass filtering

static perform_bandpass(data, sampling_rate, start_freq, stop_freq, order, filter_type, ripple)

perform bandpass filtering

static perform_bandstop(data, sampling_rate, start_freq, stop_freq, order, filter_type, ripple)

perform bandpass filtering

static remove_environmental_noise(data, sampling_rate, noise_type)

perform noth filtering

static perform_rolling_filter(data, period, operation)

apply rolling filter

static detrend(data, operation)

remove trend from data

static perform_downsampling(data, period, operation)

downsample data

static restore_data_from_wavelet_detailed_coeffs(data, wavelet, decomposition_level, level_to_restore)

restore data from a single wavelet level

static detect_peaks_z_score(data, lag, threshold, influence)

peaks detection using z score algorithm

static perform_wavelet_transform(data, wavelet, decomposition_level, extension)

perform wavelet transform

static perform_inverse_wavelet_transform(wavelet_data, wavelet_sizes, original_data_len, wavelet, decomposition_level, extension)

perform inverse wavelet transform

static perform_wavelet_denoising(data, wavelet, decomposition_level, denoising, threshold, extention, noise_level)

perform wavelet denoising

static get_csp(data, labels)

get common spatial patterns

static get_window(window_function, window_len)

get window

static calc_stddev(data)

calc stddev

static get_railed_percentage(data, gain)

calc railed percentage

static get_oxygen_level(ppg_ir, ppg_red, sampling_rate, coef1, coef2, coef3)

calc oxygen level

static get_heart_rate(ppg_ir, ppg_red, sampling_rate, fft_size)

calc heart rate

static perform_fft(data, window)

perform fft

static perform_ifft(fft_data)

perform inverse fft

static get_custom_band_powers(data, start_freqs, stop_freqs, channels, sampling_rate, apply_filters)

calculate average band powers

static perform_ica_select_channels(data, num_components, channels)

calculate ica

static perform_ica(data, num_components)

calculate ica

static get_psd(data, sampling_rate, window)

calculate PSD

static get_psd_welch(data, nfft, overlap, sampling_rate, window)

calculate PSD using welch method

static get_band_power(ampls, freqs, freq_start, freq_end)

calculate band power

static get_nearest_power_of_two(value)

get nearest power of two

static write_file(data, file_name, file_mode)

write data to file, in file data will be transposed

static read_file(file_name)

read data from file

class mindrove.MindRoveClassifiers

Bases: int32

Store supported classifiers

class mindrove.NoiseEstimationLevelTypes

Bases: int32

Store all possible noise estimation levels

class mindrove.MindRoveModelParams

Store MLModel params

class mindrove.MindRoveInputParams

MindRove input params, check docs for params for your device