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 filesfile
, 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.
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.1ip_port
, for example above it's 6677master_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.
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
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 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 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
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.
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
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
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
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
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 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
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
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.
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.
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.
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.
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.
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
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
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 :ref:`presets-label`:
BrainFlowPresets.DEFAULT_PRESET
, it contains EEG data, to enable 5th EEG channel useboard.config_board("p50")
BrainFlowPresets.AUXILIARY_PRESET
, it contains Gyro and Accel data, enabled by defaultBrainFlowPresets.ANCILLARY_PRESET
, it contains PPG data, to enable it useboard.config_board("p61")
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 :ref:`presets-label`:
BrainFlowPresets.DEFAULT_PRESET
, it contains EEG data, to enable 5th EEG channel useboard.config_board("p50")
BrainFlowPresets.AUXILIARY_PRESET
, it contains Gyro and Accel data, enabled by defaultBrainFlowPresets.ANCILLARY_PRESET
, it contains PPG data, to enable it useboard.config_board("p50")
. It also enables 5th channel for EEG
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 :ref:`presets-label`:
BrainFlowPresets.DEFAULT_PRESET
, it contains EEG dataBrainFlowPresets.AUXILIARY_PRESET
, it contains Gyro and Accel data, enabled by default
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 :ref:`presets-label`:
BrainFlowPresets.DEFAULT_PRESET
, it contains EEG data, to enable 5th EEG channel useboard.config_board("p50")
BrainFlowPresets.AUXILIARY_PRESET
, it contains Gyro and Accel data, enabled by defaultBrainFlowPresets.ANCILLARY_PRESET
, it contains PPG data, to enable it useboard.config_board("p61")
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 :ref:`presets-label`:
BrainFlowPresets.DEFAULT_PRESET
, it contains EEG data, to enable 5th EEG channel useboard.config_board("p50")
BrainFlowPresets.AUXILIARY_PRESET
, it contains Gyro and Accel data, enabled by defaultBrainFlowPresets.ANCILLARY_PRESET
, it contains PPG data, to enable it useboard.config_board("p50")
. It also enables 5th channel for EEG
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 :ref:`presets-label`:
BrainFlowPresets.DEFAULT_PRESET
, it contains EEG dataBrainFlowPresets.AUXILIARY_PRESET
, it contains Gyro and Accel data, enabled by default
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.
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
.
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
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 :ref:`presets-label`:
BrainFlowPresets.DEFAULT_PRESET
, it contains EEG dataBrainFlowPresets.AUXILIARY_PRESET
, it contains Gyro and Accel dataBrainFlowPresets.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
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 :ref:`presets-label`:
BrainFlowPresets.DEFAULT_PRESET
, it contains EEG dataBrainFlowPresets.AUXILIARY_PRESET
, it contains Gyro and Accel dataBrainFlowPresets.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
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 :ref:`presets-label`:
BrainFlowPresets.DEFAULT_PRESET
, it contains accelerometer, gyroscope and magnetometer dataBrainFlowPresets.AUXILIARY_PRESET
, it contains PPG dataBrainFlowPresets.ANCILLARY_PRESET
, it contains EDA and temperature data