This is forked from the great mindwave-python from Moonshot Barkley at https://github.com/BarkleyUS/mindwave-python. Thanks for sharing!
This is the only code i found working with the wireless (non-bluetooth) Neurosky MindWave. This fork is for the Raspberry Pi and contains a script for displaying the attention level with an LED.
Checkout the tutorial at http://www.knight-of-pi.org/raspberry-pi-mindcontrol-neurosky-mindwave-as-simple-eeg-interface
Download the code with
wget https://github.com/JoBergs/mindwave-python
Plugin the Neurosky dongle, then run
dmesg
to find the USB port with the dongle. In test_mindwave.py, change the line
headset = mindwave.Headset('/dev/ttyUSB3', '1E5F')
for the correct USB port and the Neurosky serial from inside the battery box.
python2 test_mindwave.py
or attach an LED like shown in rpi_with_led.png and run
python2 mindwave_LED.py
- Added test_mindwave.py for a simple functionality test
- Added mindwave_LED.py for demonstrating attention level with an LED
Linux and Mac-friendly Python parser to connect and interact with multiple NeuroSky MindWave headsets from one machine.
This is the software used by Moonshot Lab at Barkley (http://moonshot.barkleyus.com/) for all of our internal MindWave projects.
A connection to the headset dongle is established by creating a new Headset
object. Find the MindWave device(s) on your machine. On a Mac, it looks like this:
import mindwave
headset = mindwave.Headset('/dev/tty.MindWave', '625f')
Pass in the device path and the headset ID printed inside the battery case.
It's recommended to wait at least a couple seconds before connecting the dongle to the headset:
import mindwave, time
headset = mindwave.Headset('/dev/tty.MindWave', '625f')
time.sleep(2)
headset.connect()
print "Connecting..."
while headset.status != 'connected':
time.sleep(0.5)
if headset.status == 'standby':
headset.connect()
print "Retrying connect..."
print "Connected."
while True:
print "Attention: %s, Meditation: %s" % (headset.attention, headset.meditation)
For the MindWave Mobile bluetooth headsets, it's unnecessary to use the connect()
or disconnect()
methods. If your operating system automatically creates a serial port for the bluetooth device, there's also no need to specify a headset ID. Just pass the serial device path as a parameter when you create a new Headset
object and you're good to go.
The library can also auto-connect the dongle to the first available headset, rather than specifying a headset ID.
import mindwave, time
headset = mindwave.Headset('/dev/tty.MindWave')
time.sleep(2)
headset.connect()
Use headset.autoconnect()
to auto-connect explicitly, regardless of whether or not a headset ID was specified.
The library can handle multiple devices used simultaneously.
import mindwave, time
h1 = mindwave.Headset('/dev/tty.MindWave', '625f')
h2 = mindwave.Headset('/dev/tty.MindWave2', 'a662')
time.sleep(2)
h1.connect()
print "Connecting h1..."
while h1.status != 'connected':
time.sleep(0.5)
if h1.status == 'standby':
h1.connect()
print "Retrying connect..."
print "Connected h1."
h2.connect()
print "Connecting h2..."
while h2.status != 'connected':
time.sleep(0.5)
if h2.status == 'standby':
h2.connect()
print "Retrying connect..."
print "Connected h2."
while True:
print "Attention 1: %s, Meditation 1: %s" % (h1.attention, h1.meditation)
print "Attention 2: %s, Meditation 2: %s" % (h2.attention, h2.meditation)
The library provides hooks for certain events to allow for the attachment of custom handlers.
def on_blink(headset, blink_strength):
print "Blink detected. Strength: %s" % blink_strength
headset.blink_handlers.append(on_blink)
headset.
device - The device path of the dongle on the system.
headset.
headset_id - The ID of the connected headset.
headset.
poor_signal - The "poor signal" reading of the headset connection. This indicates how poorly the headset is reading EEG waves, 0 being the best reading and 255 being the worst. Try readjusting the headset if this value is too high.
headset.
attention - The last-read attention value from the headset.
headset.
meditation - The last-read meditation value from the headset.
headset.
blink - The last-read blink strength from the headset.
headset.
status - The current status of the headset: connected
, scanning
, or standby
headset.
connect ([headset_id])
- Connect to the specified headset ID. If no headset was specified, the dongle will auto-connect to the first available.
headset.
autoconnect ()
- Auto-connect to the first available headset, regardless of any headset ID specified.
headset.
disconnect ()
- Disconnect the dongle from the headset.
headset.
poor_signal_handlers []
- Handlers are fired whenever a poor signal is detected. Expects handlers with the prototype my_function(headset, poor_signal)
and passes in the current headset object and poor signal value.
headset.
good_signal_handlers []
- Handlers are fired whenever a good signal is detected. Expects handlers with the prototype my_function(headset, poor_signal)
and passes in the current headset object and poor signal value.
headset.
attention_handlers []
- Handlers are fired whenever an attention value is received. Expects handlers with the prototype my_function(headset, attention)
and passes in the current headset object and attention value.
headset.
meditation_handlers []
- Handlers are fired whenever an meditation value is received. Expects handlers with the prototype my_function(headset, meditation)
and passes in the current headset object and meditation value.
headset.
blink_handlers []
- Handlers are fired whenever a blink is detected. Expects handlers with the prototype my_function(headset, blink_strength)
and passes in the current headset object and blink strength value.
headset.
connected_handlers []
- Handlers are fired whenever the headset is connected. Expects handlers with the prototype my_function(headset)
and passes in the current headset object.
headset.
notfound_handlers []
- Handlers are fired whenever the headset specified cannot be found. Expects handlers with the prototype my_function(headset, not_found_id)
and passes in the current headset object and the headset id that could not be found.
headset.
disconnected_handlers []
- Handlers are fired whenever the headset is disconnected. Expects handlers with the prototype my_function(headset)
and passes in the current headset object.
headset.
request_denied_handlers []
- Handlers are fired whenever a request to the dongle is denied (connect/disconnect/autoconnect). Expects handlers with the prototype my_function(headset)
and passes in the current headset object.
headset.
scanning_handlers []
- Handlers are fired whenever the dongle begins scanning for a headset. Expects handlers with the prototype my_function(headset)
and passes in the current headset object.
headset.
standby_handlers []
- Handlers are fired whenever the dongle goes into standby (not connected to a headset). Expects handlers with the prototype my_function(headset)
and passes in the current headset object.