signalino

signalino is the high-level Python API for Signalino 4 EEG devices. It wraps the Signalino board implemented in BrainFlow and adds a non-destructive sample buffer, typed battery and impedance results, Lab Streaming Layer publishing, and conversion to MNE-Python.

This is research software. It is not a medical device and must not be used for diagnosis or patient monitoring.

Status

The package is published on PyPI. Signalino support currently lives in the Signalino-enabled BrainFlow repository. The official brainflow wheel does not yet contain board ID 69, so install the matching Signalino-enabled BrainFlow Python package and native library before connecting hardware. The wrapper verifies both the Python binding and native library and reports a clear error when they do not match.

Installation

Install the published package:

python -m pip install signalino
python examples/check_import.py

The import check does not connect to hardware. To use a Signalino device, build the Signalino-enabled BrainFlow version, then install its Python package and this wrapper:

cmake -S ../brainflow-signalino -B ../brainflow-signalino/build \
  -DCMAKE_BUILD_TYPE=Release -DBUILD_BLE=ON
cmake --build ../brainflow-signalino/build --parallel
python -m pip install ../brainflow-signalino/python_package
python -m pip install .

The BrainFlow fork currently uses a development package version (0.0.1). The signalino dependency intentionally does not impose a misleading BrainFlow version floor; runtime capability checks are authoritative until board 69 is available in an official BrainFlow release.

Install optional integrations as needed:

python -m pip install ".[lsl]"
python -m pip install ".[mne]"
python -m pip install ".[all]"

For development:

python -m pip install -e ".[dev,all]"
pytest

USB

import time

from signalino import Signalino

with Signalino.usb() as device:  # Automatically chooses the most probable port
    device.start_streaming()
    time.sleep(2)
    eeg_uv = device.get_data()

print(eeg_uv.shape)  # (8, approximately 500)

Use COM3-style names on Windows and /dev/ttyACM0-style names on Linux. Pass one explicitly as Signalino.usb("/dev/cu.usbmodem1101") when needed. Discovery only examines port names and USB descriptors; it does not open ports. Use find_usb_ports() to display every probable candidate. If two devices are equally likely, automatic selection refuses to guess.

Bluetooth LE

from signalino import Signalino

device = Signalino.ble("Signalino-852960")
device.connect()
device.start_streaming()

When only one Signalino is advertising, Signalino.ble() lets BrainFlow choose it automatically. Provide the advertised name whenever multiple devices may be present.

Bluetooth Classic

Signalino devices fitted with an HC-06 appear as a serial port after pairing. The example can locate a probable paired port automatically:

python examples/basic_classic_bluetooth.py

The example automatically selects a probable Signalino port. Pass the port as an argument if several paired devices are plausible. On Linux the port is commonly /dev/rfcomm0; on Windows it is a COM port. On macOS the example uses the RFCOMM bridge bundled with Signalino Suite.

Measure the effective rate and detect packet-counter gaps over 30 seconds:

python examples/measure_classic_bluetooth.py

Live viewer

Install the viewer extra and open the eight-channel rolling display:

python -m pip install "matplotlib>=3.9,<4"
python examples/live_viewer.py

Bluetooth Classic is selected by default. Use --transport usb or --transport ble for the other connections. Press Space to pause the display without stopping acquisition, and press Q or Escape to close it.

Data

get_data() returns a NumPy array in microvolts with shape (channels, samples). Data is consumed oldest first by default:

latest_copy = device.get_data(250, clear=False)
oldest_consumed = device.get_data(250)

For timestamps, use get_data_batch():

batch = device.get_data_batch()
print(batch.samples_uv.shape)
print(batch.timestamps)

The package continuously drains BrainFlow into its own bounded buffer. LSL and get_data() therefore receive the same samples without stealing data from one another.

Public API

The stable top-level API is:

Signalino.usb(...) / Signalino.ble(...)
find_usb_port() / find_usb_ports()
connect() / disconnect()
start_streaming() / stop_streaming()
get_data() / get_data_batch() / clear_data()
battery() / impedance()
start_lsl() / stop_lsl()
to_mne()

Public result types and exceptions are importable directly from signalino. Implementation modules whose names begin with an underscore are private.

Battery

status = device.battery()
print(status.volts, status.percent, status.charging)

With the current USB BrainFlow bridge, battery replies cannot be collected while binary EEG is streaming. Stop USB streaming before refreshing the value. BLE uses a separate control characteristic and can refresh battery state while EEG is active.

Impedance

reading = device.impedance()
print(reading.kiloohms)

The ADS1299 cannot emit normal EEG while measuring impedance. If streaming is active, impedance() pauses EEG, takes one reading, exits impedance mode, and restores both EEG acquisition and the previous LSL outlet. This produces a short, timestamp-visible gap by design.

LSL

device.start_streaming()
stream = device.start_lsl()
print(stream.name, stream.source_id)

The outlet contains eight float32 EEG channels in microvolts. It is closed automatically before acquisition stops, so Signalino never leaves an advertised but empty LSL stream behind.

MNE

raw = device.to_mne(clear=False)
print(raw.info["sfreq"])

MNE stores EEG in volts; conversion from Signalino's microvolts is automatic. Pass an MNE montage with device.to_mne(montage=montage) when channel names have been assigned to physical electrode positions.

Development and release checks

ruff check .
ruff format --check .
pytest --cov=signalino
python -m build
python -m twine check dist/*

Building creates an sdist and a platform-independent wheel. Publishing is deliberately not part of the build process.

License

MIT