Supported Boards

BrainFlow Dummy Boards

Playback File Board

This board playbacks files recorded using other BrainFlow boards.

It allows you to test signal processing algorithms on real data without device.

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.PLAYBACK_FILE_BOARD

• master_board, it should contain board ID of the device used to create playback files

• file, it should contain full path to recorded file

• optional: file_aux, use it if your master board has auxiliary preset

• optional: file_anc, use it if your master board has ancillary preset

Initialization Example:

params = BrainFlowInputParams()
params.file = "streamer_default.csv"
params.file_aux = "streamer_aux.csv"
params.master_board = BoardIds.SYNTHETIC_BOARD
board = BoardShim(BoardIds.PLAYBACK_FILE_BOARD, params)

Supported platforms:

• Windows >= 8.1

• Linux

• MacOS

• Devices like Raspberry Pi

By default it generates new timestamps and stops at the end of the file. You can override such behavior using commands:

board.config_board ("loopback_true")
board.config_board ("loopback_false")
board.config_board ("new_timestamps")
board.config_board ("old_timestamps")

In methods like:

get_eeg_channels (board_id)
get_emg_channels (board_id)
get_ecg_channels (board_id)
# .......

You need to use master board id instead Playback Board Id, because exact data format for playback board is controlled by master board as well as sampling rate.

Streaming Board

BrainFlow boards can stream data to different destinations like file, socket, etc directly from BrainFlow. This board acts like a consumer for data streamed from the main process.

To use it in the first process(master process, data provider) you should call:

# choose any valid multicast address(from "224.0.0.0" to "239.255.255.255") and port
add_streamer ("streaming_board://225.1.1.1:6677", BrainFlowPresets.DEFAULT_PRESET)

In the second process you shoud create Streaming board instance and this process will act as a data consumer.

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.STREAMING_BOARD

• ip_address, for example above it’s 225.1.1.1

• ip_port, for example above it’s 6677

• master_board, it should contain board ID of the device used to create playback files

• optional: ip_address_aux, use it if your master board has auxiliary preset

• optional: ip_port_aux, use it if your master board has auxiliary preset

• optional: ip_address_anc, use it if your master board has ancillary preset

• optional: ip_port_anc, use it if your master board has ancillary preset

Initialization Example:

params = BrainFlowInputParams()
params.ip_port = 6677
params.ip_port_aux = 6678
params.ip_address = "225.1.1.1"
params.ip_address_aux = "225.1.1.1"
params.master_board = BoardIds.SYNTHETIC_BOARD
board = BoardShim(BoardIds.STREAMING_BOARD, params)

Supported platforms:

• Windows >= 8.1

• Linux

• MacOS

• Devices like Raspberry Pi

• Android

In methods like:

get_eeg_channels (board_id)
get_emg_channels (board_id)
get_ecg_channels (board_id)
# .......

You need to use master board id instead Streaming Board Id, because exact data format for streaming board is controlled by master board as well as sampling rate.

If you have problems on Windows try to disable virtual box network adapter and firewall. More info can be found here.

Synthetic Board

This board generates synthetic data and you dont need real hardware to use it.

It can be extremely useful during development.

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.SYNTHETIC_BOARD

Initialization Example:

params = BrainFlowInputParams()
board = BoardShim(BoardIds.SYNTHETIC_BOARD, params)

Supported platforms:

• Windows >= 8.1

• Linux

• MacOS

• Devices like Raspberry Pi

• Android

OpenBCI

Cyton

Cyton Getting Started Guide from OpenBCI

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.CYTON_BOARD

• serial_port, e.g. COM3, /dev/ttyUSB0, etc

Initialization Example:

params = BrainFlowInputParams()
params.serial_port = "COM3"
board = BoardShim(BoardIds.CYTON_BOARD, params)

Supported platforms:

• Windows >= 8.1

• Linux

• MacOS

• Devices like Raspberry Pi

On MacOS there are two serial ports for each device: /dev/tty….. and /dev/cu….. You HAVE to specify /dev/cu…..

On Unix-like systems you may need to configure permissions for serial port or run with sudo.

Ganglion

Ganglion Getting Started Guide from OpenBCI

To use Ganglion board you need a dongle

On MacOS there are two serial ports for each device: /dev/tty….. and /dev/cu….. You HAVE to specify /dev/cu…..

Also, for Macbooks without USB ports you may need to use specific USBC-USB dongles, some of them may lead to slow data streaming.

On Unix-like systems you may need to configure permissions for serial port or run with sudo.

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.GANGLION_BOARD

• serial_port, e.g. COM4, /dev/ttyACM0, etc

• optoinal: mac_address, if not provided BrainFlow will try to autodiscover the device

• optional: timeout, timeout for device discovery, default is 15sec

Initialization Example:

params = BrainFlowInputParams()
params.serial_port = "COM4"
board = BoardShim(BoardIds.GANGLION_BOARD, params)

To get Ganglion’s MAC address you can use:

• Windows: Bluetooth LE Explorer App

• Linux: hcitool command

Supported platforms:

• Windows >= 8.1

• Linux

• MacOS

• Devices like Raspberry Pi

Ganglion Native

Ganglion Getting Started Guide from OpenBCI

Unlike Ganglion board this BrainFlow board does not use BLED112 dongle, so you need to have BLE support on your device in order to use it.

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.GANGLION_NATIVE_BOARD

• optoinal: mac_address, if not provided BrainFlow will try to autodiscover the device

• optoinal: serial_number, if not provided BrainFlow will try to autodiscover the device

Initialization Example:

params = BrainFlowInputParams()
board = BoardShim(BoardIds.GANGLION_NATIVE_BOARD, params)

To get Ganglion’s MAC address or device name you can use:

• Windows: Bluetooth LE Explorer App

• Linux: hcitool command

Supported platforms:

• Windows 10.0.19041.0+

• MacOS 10.15+, 12.0 to 12.2 have known issues while scanning, you need to update to 12.3+. On MacOS 12+ you may need to configure Bluetooth permissions for your appication

• Linux, compilation from source code probably will be needed

• Devices like Raspberry Pi

Cyton Daisy

CytonDaisy Getting Started Guide from OpenBCI

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.CYTON_DAISY_BOARD

• serial_port, e.g. COM3, /dev/ttyUSB0, etc

Initialization Example:

params = BrainFlowInputParams()
params.serial_port = "COM3"
board = BoardShim(BoardIds.CYTON_DAISY_BOARD, params)

Supported platforms:

• Windows >= 8.1

• Linux

• MacOS

• Devices like Raspberry Pi

On MacOS there are two serial ports for each device: /dev/tty….. and /dev/cu….. You HAVE to specify /dev/cu…..

On Unix-like systems you may need to configure permissions for serial port or run with sudo.

Ganglion with WIFI Shield

WIFI Shield Getting Started Guide from OpenBCI

WIFI Shield Programming Guide from OpenBCI

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.GANGLION_WIFI_BOARD

• ip_port, any local port which is currently free, e.g. 6789

• optional: ip_address, ip address of WIFI Shield, in direct mode it’s 192.168.4.1. If not provided BrainFlow will try to use SSDP for discovery

• optional: timeout, timeout for device discovery, default is 10sec

Initialization Example:

params = BrainFlowInputParams()
params.ip_port = 6987
params.ip_address = "192.168.4.1"
board = BoardShim(BoardIds.GANGLION_WIFI_BOARD, params)

Supported platforms:

• Windows >= 8.1

• Linux

• MacOS

• Android

Cyton with WIFI Shield

WIFI shield Getting Started Guide from OpenBCI

WIFI shield Programming Guide from OpenBCI

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.CYTON_WIFI_BOARD

• ip_port, any local port which is currently free, e.g. 6789

• optional: ip_address, ip address of WIFI Shield, in direct mode it’s 192.168.4.1. If not provided BrainFlow will try to use SSDP for discovery

• optional: timeout, timeout for device discovery, default is 10sec

Initialization Example:

params = BrainFlowInputParams()
params.ip_port = 6987
params.ip_address = "192.168.4.1"
board = BoardShim(BoardIds.CYTON_WIFI_BOARD, params)

Supported platforms:

• Windows >= 8.1

• Linux

• MacOS

• Devices like Raspberry Pi

• Android

CytonDaisy with WIFI Shield

WIFI Shield Getting Started Guide from OpenBCI

WIFI Shield Programming Guide from OpenBCI

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.CYTON_DAISY_WIFI_BOARD

• ip_port, any local port which is currently free, e.g. 6789

• optional: ip_address, ip address of WIFI Shield, in direct mode it’s 192.168.4.1. If not provided BrainFlow will try to use SSDP for discovery

• optional: timeout, timeout for device discovery, default is 10sec

Initialization Example:

params = BrainFlowInputParams()
params.ip_port = 6987
params.ip_address = "192.168.4.1"
board = BoardShim(BoardIds.CYTON_DAISY_WIFI_BOARD, params)

Supported platforms:

• Windows >= 8.1

• Linux

• MacOS

• Devices like Raspberry Pi

• Android

NeuroMD

BrainBit

BrainBit website

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.BRAINBIT_BOARD

• optional: serial_number, serial number of device, usually it’s printed on the headset. Important if you have multiple devices in the same place

• optional: timeout, timeout for device discovery, default is 15sec

Initialization Example:

params = BrainFlowInputParams()
board = BoardShim(BoardIds.BRAINBIT_BOARD, params)

Supported platforms:

• Windows >= 10

• MacOS

Available commands for config_board:

• CommandStartSignal

• CommandStopSignal

• CommandStartResist

• CommandStopResist

BrainBitBLED

This board allows you to use BLED112 dongle instead native API to work with BLE. Unlike original BrainBit libraries it works on Linux and devices like Raspberry Pi.

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.BRAINBIT_BLED_BOARD

• serial port, e.g. COM4, /dev/ttyACM0

• optional: :code:mac_address`, mac address of BrainBit device, important if you have multiple devices in the same place

Initialization Example:

params = BrainFlowInputParams()
params.serial_port = "COM4"
board = BoardShim(BoardIds.BRAINBIT_BLED_BOARD, params)

To get BrainBit’s MAC address you can use:

• Windows: Bluetooth LE Explorer App

• Linux: hcitool command

Supported platforms:

• Windows

• MacOS

• Linux

• Devices like Raspberry Pi

Callibri(Yellow)

Callibri website

Callibri can be used to record EMG, ECG and EEG, but based on signal type you need to apply different settings for device.

BrainFlow does it for you, so there are:

• BoardIds.CALLIBRI_EEG_BOARD

• BoardIds.CALLIBRI_EMG_BOARD

• BoardIds.CALLIBRI_ECG_BOARD

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.CALLIBRI_EEG_BOARD

• optional: other_info, to use electrodes connected vis USB write “ExternalSwitchInputMioUSB” to this field

• optional: timeout, timeout for device discovery, default is 15sec

Initialization Example:

params = BrainFlowInputParams()
board = BoardShim(BoardIds.CALLIBRI_EEG_BOARD, params)

Supported platforms:

• Windows >= 10

• MacOS

G.TEC

Unicorn

Unicorn website

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.UNICORN_BOARD

• optional: serial_number, important if you have multiple devices in the same place

Initialization Example:

params = BrainFlowInputParams()
board = BoardShim(BoardIds.UNICORN_BOARD, params)

Supported platforms:

• Ubuntu 18.04, may work on other Linux OSes, it depends on dynamic library provided by Unicorn

• Windows

• May also work on Raspberry PI, if you replace libunicorn.so by library provided by Unicorn for Raspberry PI

Steps to Setup:

• Connect the dongle

• Make sure that you paired Unicorn device with PC using provided dongle instead built-in Bluetooth

Neurosity

Notion 1

Neurosity website

Link to Neurosity Tutorial

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.NOTION_1_BOARD

• optional: serial_number important if you have multiple devices in the same place

Initialization Example:

params = BrainFlowInputParams()
board = BoardShim(BoardIds.NOTION_1_BOARD, params)

Supported platforms:

• Windows

• Linux

• MacOS

• Devices like Raspberry Pi

Note: On Windows you may need to disable firewall to allow broadcast messages. And since the device uses broadcasting it may not work in university network.

Notion 2

Neurosity website

Link to Neurosity Tutorial

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.NOTION_2_BOARD

• optional: serial_number important if you have multiple devices in the same place

Initialization Example:

params = BrainFlowInputParams()
board = BoardShim(BoardIds.NOTION_2_BOARD, params)

Supported platforms:

• Windows

• Linux

• MacOS

• Devices like Raspberry Pi

Note: On Windows you may need to disable firewall to allow broadcast messages. And since the device uses broadcasting it may not work in university network.

Crown

Neurosity website

Link to Neurosity Tutorial

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.CROWN_BOARD

• optional: serial_number important if you have multiple devices in the same place

Initialization Example:

params = BrainFlowInputParams()
board = BoardShim(BoardIds.CROWN_BOARD, params)

Supported platforms:

• Windows

• Linux

• MacOS

• Devices like Raspberry Pi

Note: On Windows you may need to disable firewall to allow broadcast messages. And since the device uses broadcasting it may not work in university network.

OYMotion

gForcePro ArmBand

OYMotion website

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.GFORCE_PRO_BOARD

Initialization Example:

params = BrainFlowInputParams()
board = BoardShim(BoardIds.GFORCE_PRO_BOARD, params)

Supported platforms:

• Windows

Note: Unlike other boards it returns ADC values instead uV.

gForceDual ArmBand

OYMotion website

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.GFORCE_DUAL_BOARD

Initialization Example:

params = BrainFlowInputParams()
board = BoardShim(BoardIds.GFORCE_DUAL_BOARD, params)

Supported platforms:

• Windows

Note: Unlike other boards it returns ADC values instead uV.

FreeEEG

FreeEEG32

CrowdSupply

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.FREEEEG32_BOARD

• serial_port, e.g. COM3

Initialization Example:

params = BrainFlowInputParams()
params.serial_port = "COM3"
board = BoardShim(BoardIds.FREEEEG32_BOARD, params)

On Unix-like systems you may need to configure permissions for serial port or run with sudo.

Supported platforms:

• Windows

• Linux

• MacOS

• Devices like Raspberry Pi

FreeEEG128

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.FREEEEG128_BOARD

• serial_port, e.g. COM6

Initialization Example:

params = BrainFlowInputParams()
params.serial_port = "COM6"
board = BoardShim(BoardIds.FREEEEG128_BOARD, params)

On Unix-like systems you may need to configure permissions for serial port or run with sudo.

Supported platforms:

• Windows

• Linux

• MacOS

• Devices like Raspberry Pi

Muse

Muse S BLED

Muse Website

To use this board you need to get BLED112 dongle.

On Unix-like systems you may need to configure permissions for serial port or run with sudo.

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.MUSE_S_BLED_BOARD

• serial_port, e.g. COM3, /dev/ttyACM0

• optional: serial_number, device name, can be printed on the Muse device or discoovered via mobile apps

Initialization Example:

params = BrainFlowInputParams()
params.serial_port = "COM3"
board = BoardShim(BoardIds.MUSE_S_BLED_BOARD, params)

Supported platforms:

• Windows

• MacOS

• Linux

• Devices like Raspberry Pi

Available BrainFlow Presets:

• BrainFlowPresets.DEFAULT_PRESET, it contains EEG data, to enable 5th EEG channel use board.config_board("p50")

• BrainFlowPresets.AUXILIARY_PRESET, it contains Gyro and Accel data, enabled by default

• BrainFlowPresets.ANCILLARY_PRESET, it contains PPG data, to enable it use board.config_board("p61")

Muse 2 BLED

Muse Website

To use this board you need to get BLED112 dongle.

On Unix-like systems you may need to configure permissions for serial port or run with sudo.

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.MUSE_2_BLED_BOARD

• serial_port, e.g. COM3, /dev/ttyACM0

• optional: serial_number, device name, can be printed on the Muse device or discoovered via mobile apps

Initialization Example:

params = BrainFlowInputParams()
params.serial_port = "COM3"
board = BoardShim(BoardIds.MUSE_2_BLED_BOARD, params)

Supported platforms:

• Windows

• MacOS

• Linux

• Devices like Raspberry Pi

Available BrainFlow Presets:

• BrainFlowPresets.DEFAULT_PRESET, it contains EEG data, to enable 5th EEG channel use board.config_board("p50")

• BrainFlowPresets.AUXILIARY_PRESET, it contains Gyro and Accel data, enabled by default

• BrainFlowPresets.ANCILLARY_PRESET, it contains PPG data, to enable it use board.config_board("p50"). It also enables 5th channel for EEG

Muse 2016 BLED

Muse Website

To use this board you need to get BLED112 dongle.

On Unix-like systems you may need to configure permissions for serial port or run with sudo.

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.MUSE_2016_BLED_BOARD

• serial_port, e.g. COM3, /dev/ttyACM0

• optional: serial_number, device name, can be printed on the Muse device or discoovered via mobile apps

Initialization Example:

params = BrainFlowInputParams()
params.serial_port = "COM3"
board = BoardShim(BoardIds.MUSE_2016_BLED_BOARD, params)

Supported platforms:

• Windows

• MacOS

• Linux

• Devices like Raspberry Pi

Available BrainFlow Presets:

• BrainFlowPresets.DEFAULT_PRESET, it contains EEG data

• BrainFlowPresets.AUXILIARY_PRESET, it contains Gyro and Accel data, enabled by default

Muse S

Muse Website

On Linux systems you may need to install libdbus and we recommend to compile BrainFlow from the source code:

sudo apt-get install libdbus-1-dev # for ubuntu
sudo yum install dbus-devel # for centos
python3 tools/build.py --ble # to compile

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.MUSE_S_BOARD

• optional: mac_address, mac address of the device to connect

• optional: serial_number, device name, can be printed on the Muse device or discoovered via mobile apps

Initialization Example:

params = BrainFlowInputParams()
board = BoardShim(BoardIds.MUSE_S_BOARD, params)

Supported platforms:

• Windows 10.0.19041.0+

• MacOS 10.15+, 12.0 to 12.2 have known issues while scanning, you need to update to 12.3+. On MacOS 12+ you may need to configure Bluetooth permissions for your appication

• Linux, compilation from source code probably will be needed

• Devices like Raspberry Pi

Available BrainFlow Presets:

• BrainFlowPresets.DEFAULT_PRESET, it contains EEG data, to enable 5th EEG channel use board.config_board("p50")

• BrainFlowPresets.AUXILIARY_PRESET, it contains Gyro and Accel data, enabled by default

• BrainFlowPresets.ANCILLARY_PRESET, it contains PPG data, to enable it use board.config_board("p61")

Muse 2

Muse Website

On Linux systems you may need to install libdbus and we recommend to compile BrainFlow from the source code:

sudo apt-get install libdbus-1-dev # for ubuntu
sudo yum install dbus-devel # for centos
python3 tools/build.py --ble # to compile

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.MUSE_2_BOARD

• optional: mac_address, mac address of the device to connect

• optional: serial_number, device name, can be printed on the Muse device or discoovered via mobile apps

Initialization Example:

params = BrainFlowInputParams()
board = BoardShim(BoardIds.MUSE_2_BOARD, params)

Supported platforms:

• Windows 10.0.19041.0+

• MacOS 10.15+, 12.0 to 12.2 have known issues while scanning, you need to update to 12.3+. On MacOS 12+ you may need to configure Bluetooth permissions for your appication

• Linux, compilation from source code probably will be needed

• Devices like Raspberry Pi

Available BrainFlow Presets:

• BrainFlowPresets.DEFAULT_PRESET, it contains EEG data, to enable 5th EEG channel use board.config_board("p50")

• BrainFlowPresets.AUXILIARY_PRESET, it contains Gyro and Accel data, enabled by default

• BrainFlowPresets.ANCILLARY_PRESET, it contains PPG data, to enable it use board.config_board("p50"). It also enables 5th channel for EEG

Muse 2016

Muse Website

On Linux systems you may need to install libdbus and we recommend to compile BrainFlow from the source code:

sudo apt-get install libdbus-1-dev # for ubuntu
sudo yum install dbus-devel # for centos
python3 tools/build.py --ble # to compile

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.MUSE_2016_BOARD

• optional: mac_address, mac address of the device to connect

• optional: serial_number, device name, can be printed on the Muse device or discoovered via mobile apps

Initialization Example:

params = BrainFlowInputParams()
board = BoardShim(BoardIds.MUSE_2016_BOARD, params)

Supported platforms:

• Windows 10.0.19041.0+

• MacOS 10.15+, 12.0 to 12.2 have known issues while scanning, you need to update to 12.3+. On MacOS 12+ you may need to configure Bluetooth permissions for your appication

• Linux, compilation from source code probably will be needed

• Devices like Raspberry Pi

Available BrainFlow Presets:

• BrainFlowPresets.DEFAULT_PRESET, it contains EEG data

• BrainFlowPresets.AUXILIARY_PRESET, it contains Gyro and Accel data, enabled by default

Ant Neuro

Ant Website

Ant Neuro has many devices and all of them are supported by BrainFlow:

• ANT_NEURO_EE_410_BOARD

• ANT_NEURO_EE_411_BOARD

• ANT_NEURO_EE_430_BOARD

• ANT_NEURO_EE_211_BOARD

• ANT_NEURO_EE_212_BOARD

• ANT_NEURO_EE_213_BOARD

• ANT_NEURO_EE_214_BOARD

• ANT_NEURO_EE_215_BOARD

• ANT_NEURO_EE_221_BOARD

• ANT_NEURO_EE_222_BOARD

• ANT_NEURO_EE_223_BOARD

• ANT_NEURO_EE_224_BOARD

• ANT_NEURO_EE_225_BOARD

• ANT_NEURO_EE_511_BOARD

Initialization Example:

params = BrainFlowInputParams()
board = BoardShim(BoardIds.ANT_NEURO_EE_410_BOARD, params)

Supported platforms:

• Windows

• Linux

Available commands:

• Set sampling rate: board.config_board("sampling_rate:500"), for available values check docs from Ant Neuro.

For more information about Ant Neuro boards please refer to their User Manual.

Enophone

Enophone Headphones

Enophone website

You need to pair your device first.

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.ENOPHONE_BOARD

• mac_address, it’s optional for some OSes. Windows and MacOS can autodiscover paired devices, Linux cannot

Initialization Example:

params = BrainFlowInputParams()
params.mac_address = "F4:0E:11:75:76:78"
board = BoardShim(BoardIds.ENOPHONE_BOARD, params)

Supported platforms:

• Windows

• Linux

• MacOS

• Devices like Raspberry Pi

Steps to find MAC address:

• On Windows: open device manager, navigate to enophone device, click properties, details, and select Bluetooth Address

• On Linux: install bluez-utils and run bluetoothctl paired-devices

• On MacOS: run system_profiler SPBluetoothDataType

On Linux in order to compile and use it you may need to install libbluetooth-dev for Debian like systems from apt-get and bluez-libs-devel for Fedora like systems from dnf.

BrainAlive

BrainAlive Device

BrainAlive Website

On Linux systems you may need to install libdbus and we recommend to compile BrainFlow from the source code:

sudo apt-get install libdbus-1-dev # for ubuntu
sudo yum install dbus-devel # for centos
python3 tools/build.py --ble # to compile

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.BRAINALIVE_BOARD

• optional: mac_address, mac address of the device to connect

• optional: serial_number, device name

Initialization Example:

params = BrainFlowInputParams()
board = BoardShim(BoardIds.BRAINALIVE_BOARD, params)

Supported platforms:

• Windows 10.0.19041.0+

• MacOS 10.15+

• Linux, compilation from source code probably will be needed

• Devices like Raspberry Pi

Mentalab

Explore 4 Channels Board

Mentalab website

You need to pair your device first.

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.EXPLORE_4_CHAN_BOARD

• mac_address, it’s optional for some OSes. Windows and MacOS can autodiscover paired devices, Linux cannot

Initialization Example:

params = BrainFlowInputParams()
params.mac_address = "F4:0E:11:75:76:78"
board = BoardShim(BoardIds.EXPLORE_4_CHAN_BOARD, params)

Supported platforms:

• Windows

• Linux

• MacOS

• Devices like Raspberry Pi

On Linux in order to compile and use it you may need to install libbluetooth-dev for Debian like systems from apt-get and bluez-libs-devel for Fedora like systems from dnf.

Available BrainFlow Presets:

• BrainFlowPresets.DEFAULT_PRESET, it contains EEG data

• BrainFlowPresets.AUXILIARY_PRESET, it contains Gyro and Accel data

• BrainFlowPresets.ANCILLARY_PRESET, it contains battery and temperature data

Steps to find MAC address:

• On Windows: open device manager, navigate to explore device, click properties, details, and select Bluetooth Address

• On Linux: install bluez-utils and run bluetoothctl paired-devices

• On MacOS: run system_profiler SPBluetoothDataType

Steps to connect:

• Enable device and Pair it with your laptop using bluetooth settings

• Ensure that blue LED is blinking before calling board.prepare_session()

• If you see green LED probably you need to reboot a devce

Explore 8 Channels Board

Mentalab website

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

You need to pair your enophone device first.

• BoardIds.EXPLORE_8_CHAN_BOARD

• mac_address, it’s optional for some OSes. Windows and MacOS can autodiscover paired Enophone devices, Linux cannot

Initialization Example:

params = BrainFlowInputParams()
params.mac_address = "F4:0E:11:75:76:78"
board = BoardShim(BoardIds.EXPLORE_8_CHAN_BOARD, params)

Supported platforms:

• Windows

• Linux

• MacOS

• Devices like Raspberry Pi

On Linux in order to compile and use it you may need to install libbluetooth-dev for Debian like systems from apt-get and bluez-libs-devel for Fedora like systems from dnf.

Available BrainFlow Presets:

• BrainFlowPresets.DEFAULT_PRESET, it contains EEG data

• BrainFlowPresets.AUXILIARY_PRESET, it contains Gyro and Accel data

• BrainFlowPresets.ANCILLARY_PRESET, it contains battery and temperature data

Steps to find MAC address:

• On Windows: open device manager, navigate to explore device, click properties, details, and select Bluetooth Address

• On Linux: install bluez-utils and run bluetoothctl paired-devices

• On MacOS: run system_profiler SPBluetoothDataType

Steps to connect:

• Enable device and Pair it with your laptop using bluetooth settings

• Ensure that blue LED is blinking before calling board.prepare_session()

• If you see green LED probably you need to reboot a devce

EmotiBit

EmotiBit board

EmotiBit Website

To create such board you need to specify the following board ID and fields of BrainFlowInputParams object:

• BoardIds.EMOTIBIT_BOARD

• optional: ip_address, you can provide broadcast ip address of the network with EmotiBit device, e.g. 192.168.178.255. If not provided BrainFlow will try to autodiscover the network and it may take a little longer.

Initialization Example:

params = BrainFlowInputParams()
board = BoardShim(BoardIds.EMOTIBIT_BOARD, params)

Supported platforms:

• Windows

• MacOS

• Linux

• Devices like Raspberry Pi

Available BrainFlow Presets:

• BrainFlowPresets.DEFAULT_PRESET, it contains accelerometer, gyroscope and magnetometer data

• BrainFlowPresets.AUXILIARY_PRESET, it contains PPG data

• BrainFlowPresets.ANCILLARY_PRESET, it contains EDA and temperature data

PiEEG

PiEEG Board

PiEEG (Measure EEG with RaspberryPi) – Brain-computer interface (EEG, EMG, and ECG bio-signals) is an open-source Raspberry Pi shield that measures biosignals such as those used in electroencephalography (EEG), electromyography (EMG), and electrocardiography (ECG). It integrates seamlessly with BrainFlow’s API, allowing for easy data streaming, processing, and analysis.

PiEEG Website

To create such a board, you need to specify the following board ID and fields of the BrainFlowInputParams object:

• BoardIds.PIEEG_BOARD

• :code:`serial_port`(optional), e.g. /dev/spidev0.0, etc. More likely you dont need to change the default

Initialization Example:

Supported platforms:

• Raspberry Pi

Note: Ensure that you have the necessary permissions to access the serial port on your operating system. For Unix-like systems, you may need to configure permissions for the serial port or run with sudo.

To use this board you need to compile BrainFlow from the source code right on your Raspbery Pi device with flag –build-periphery(build.py) or with -DBUILD_PERIPHERY=ON(CMake) and install desired bindings using local libraries.