def test_get_data_for_clock(self):
"""Test queries to the data store by experiment clock units."""
channels = ['ch1', 'ch2', 'TRG']
sample_hz = 100
trigger_at = 10
num_records = 1000
n_channels = len(channels) - 1
data = [
mock_record(n_channels) + [0 if (i + 1) < trigger_at else 1]
for i in range(num_records)
]
device = _MockConnector(data=data,
device_spec=DeviceSpec(name="Mock_device",
channels=channels,
sample_rate=sample_hz))
daq = DataAcquisitionClient(
connector=device,
buffer_name='buffer_client_test_get_data_for_clock.db',
raw_data_file_name=None,
delete_archive=True,
clock=CountClock())
daq.start_acquisition()
time.sleep(0.2)
daq.stop_acquisition()
self.assertTrue(daq.is_calibrated)
# rownum at calibration should be trigger_at
self.assertEqual(trigger_at, daq.record_at_calib.rownum)
self.assertEqual(trigger_at, daq.record_at_calib.timestamp)
self.assertEqual(data[trigger_at - 1], daq.record_at_calib.data)
# Test with clocks exactly synchronized.
self.assertEqual(0.1, daq.offset)
data_slice = daq.get_data_for_clock(calib_time=0.1,
start_time=0.2,
end_time=0.3)
self.assertEqual(10, len(data_slice))
start_offset = 20
for i, record in enumerate(data_slice):
# mock-data is 0-based, so we have to subtract 1 from the start.
mock_data_index = i + start_offset - 1
self.assertEqual(record.data, data[mock_data_index])
# Test with clocks offset
data_slice = daq.get_data_for_clock(calib_time=0.2,
start_time=0.4,
end_time=0.6)
self.assertEqual(20, len(data_slice))
start_offset = 30
for i, record in enumerate(data_slice):
# mock-data is 0-based, so we have to subtract 1 from the start.
mock_data_index = i + start_offset - 1
self.assertEqual(record.data, data[mock_data_index])
daq.cleanup()
def test_missing_offset(self):
"""Test missing offset when no triggers are present in the data."""
channels = ['ch1', 'ch2', 'TRG']
sample_hz = 100
num_records = 500
# mock_data only has empty trigger values.
n_channels = len(channels) - 1
data = [mock_record(n_channels) + [0] for i in range(num_records)]
device = _MockConnector(data=data,
device_spec=DeviceSpec(name="Mock_device",
channels=channels,
sample_rate=sample_hz))
daq = DataAcquisitionClient(
connector=device,
clock=CountClock(),
buffer_name='buffer_client_test_missing_offset.db',
raw_data_file_name=None,
delete_archive=True)
with daq:
time.sleep(0.1)
self.assertFalse(daq.is_calibrated)
self.assertEqual(daq.offset, None)
daq.cleanup()
def test_clock(self):
"""Test clock integration."""
clock = CountClock()
clock.counter = 10 # ensures that clock gets reset.
device = _MockConnector(data=self.mock_data,
device_spec=self.device_spec)
daq = DataAcquisitionClient(connector=device,
buffer_name='buffer_client_test_clock.db',
raw_data_file_name=None,
delete_archive=True,
clock=clock)
with daq:
time.sleep(0.1)
# Get all records from buffer
data = daq.get_data()
# NOTE: we can't make any assertions about the Clock, since it is
# copied when it's passed to the acquisition thread.
self.assertTrue(len(data) > 0)
for i, record in enumerate(data):
self.assertEqual(record.timestamp, float(i + 1))
daq.cleanup()
def test_zero_offset(self):
"""Test offset value override"""
channels = ['ch1', 'ch2', 'TRG']
sample_hz = 100
trigger_at = 10
num_records = 500
n_channels = len(channels) - 1
data = [mock_record(n_channels) + [0 if (i + 1) < trigger_at else 1]
for i in range(num_records)]
device = _MockDevice(data=data, channels=channels, fs=sample_hz)
daq = DataAcquisitionClient(device=device,
processor=NullProcessor(),
buffer_name='buffer_client_test_offset.db',
clock=CountClock())
daq.is_calibrated = True # force the override.
daq.start_acquisition()
time.sleep(0.1)
daq.stop_acquisition()
self.assertTrue(daq.is_calibrated)
self.assertEqual(daq.offset, 0.0, "Setting the is_calibrated to True\
should override the offset calcution.")
daq.cleanup()
def test_zero_offset(self):
"""Test offset value override"""
channels = ['ch1', 'ch2', 'TRG']
sample_hz = 100
trigger_at = 10
num_records = 500
n_channels = len(channels) - 1
data = [
mock_record(n_channels) + [0 if (i + 1) < trigger_at else 1]
for i in range(num_records)
]
device = _MockConnector(data=data,
device_spec=DeviceSpec(name="Mock_device",
channels=channels,
sample_rate=sample_hz))
daq = DataAcquisitionClient(connector=device,
buffer_name='buffer_client_test_offset.db',
raw_data_file_name=None,
delete_archive=True,
clock=CountClock())
daq.is_calibrated = True # force the override.
daq.start_acquisition()
time.sleep(0.1)
daq.stop_acquisition()
self.assertTrue(daq.is_calibrated)
self.assertEqual(
daq.offset, 0.0, "Setting the is_calibrated to True\
should override the offset calcution.")
daq.cleanup()
def test_offset(self):
"""Test offset calculation"""
channels = ['ch1', 'ch2', 'TRG']
sample_hz = 100
trigger_at = 10
num_records = 500
n_channels = len(channels) - 1
data = [mock_record(n_channels) + [0 if (i + 1) < trigger_at else 1]
for i in range(num_records)]
device = _MockDevice(data=data, channels=channels, fs=sample_hz)
daq = DataAcquisitionClient(device=device,
processor=NullProcessor(),
buffer_name='buffer_client_test_offset.db',
clock=CountClock())
daq.start_acquisition()
time.sleep(0.1)
daq.stop_acquisition()
# The assertions should work before the stop_acquisition, but on some
# Windows environments the tests were taking too long to setup and the
# time would complete before any data had been processed.
self.assertTrue(daq.is_calibrated)
self.assertEqual(daq.offset, float(trigger_at) / sample_hz)
daq.cleanup()
def test_acquisition_null_device_exception(self):
"""Exception should be thrown if unable to connect to device or message not understood """
daq = DataAcquisitionClient(connector=None)
daq._is_streaming = False
with self.assertRaises(Exception):
daq.start_acquisition()
daq.cleanup()
def test_get_data(self):
"""Data should be queryable."""
device = _MockDevice(data=self.mock_data, channels=self.mock_channels)
daq = DataAcquisitionClient(device=device,
processor=NullProcessor())
daq.start_acquisition()
time.sleep(0.1)
daq.stop_acquisition()
# Get all records
data = daq.get_data()
self.assertTrue(
len(data) > 0, "DataAcquisitionClient should have data.")
for i, record in enumerate(data):
self.assertEqual(record.data, self.mock_data[i])
daq.cleanup()
def test_missing_offset(self):
"""Test missing offset when no triggers are present in the data."""
channels = ['ch1', 'ch2', 'TRG']
sample_hz = 100
num_records = 500
# mock_data only has empty trigger values.
n_channels = len(channels) - 1
data = [mock_record(n_channels) + [0] for i in range(num_records)]
device = _MockDevice(data=data, channels=channels, fs=sample_hz)
daq = DataAcquisitionClient(
device=device,
processor=NullProcessor(),
clock=CountClock(),
buffer_name='buffer_client_test_missing_offset.db')
with daq:
time.sleep(0.1)
self.assertFalse(daq.is_calibrated)
self.assertEqual(daq.offset, None)
daq.cleanup()
def test_get_data(self):
"""Data should be queryable."""
device = _MockConnector(data=self.mock_data,
device_spec=self.device_spec)
daq = DataAcquisitionClient(connector=device,
delete_archive=True,
raw_data_file_name=None)
daq.start_acquisition()
time.sleep(0.1)
daq.stop_acquisition()
# Get all records
data = daq.get_data()
self.assertTrue(
len(data) > 0, "DataAcquisitionClient should have data.")
for i, record in enumerate(data):
self.assertEqual(record.data, self.mock_data[i])
daq.cleanup()
def test_clock(self):
"""Test clock integration."""
clock = CountClock()
clock.counter = 10 # ensures that clock gets reset.
daq = DataAcquisitionClient(
device=_MockDevice(data=self.mock_data,
channels=self.mock_channels),
processor=NullProcessor(),
buffer_name='buffer_client_test_clock.db',
clock=clock)
with daq:
time.sleep(0.1)
# Get all records from buffer
data = daq.get_data()
# NOTE: we can't make any assertions about the Clock, since it is
# copied when it's passed to the acquisition thread.
self.assertTrue(len(data) > 0)
for i, record in enumerate(data):
self.assertEqual(record.timestamp, float(i + 1))
daq.cleanup()
def main():
"""Creates a sample client that reads data from a TCP server
(see demo/server.py). Data is written to a rawdata.csv file, as well as a
buffer.db sqlite3 database. These files are written in whichever directory
the script was run.
The client can be stopped with a Keyboard Interrupt (Ctl-C)."""
import sys
from psychopy import clock
# Allow the script to be run from the bci root, acquisition dir, or
# demo dir.
sys.path.append('.')
sys.path.append('..')
sys.path.append('../..')
from bcipy.acquisition.client import DataAcquisitionClient
from bcipy.acquisition.protocols import registry
# pylint: disable=invalid-name
Device = registry.find_device('LSL')
dsi_device = Device(connection_params={'host': '127.0.0.1', 'port': 9000})
# Use default processor (FileWriter), buffer, and clock.
client = DataAcquisitionClient(device=dsi_device, clock=clock.Clock())
try:
client.start_acquisition()
print("\nCollecting data... (Interrupt [Ctl-C] to stop)\n")
while True:
pass
except IOError as e:
print(f'{e.strerror}; make sure you started the server.')
except KeyboardInterrupt:
print("Keyboard Interrupt")
print("Number of samples: {0}".format(client.get_data_len()))
client.stop_acquisition()
client.cleanup()
def test_offset_column(self):
"""Test offset calculation when a custom offset column is specified."""
col_name = 'PHOTODIODE'
channels = ['ch1', 'ch2', col_name]
sample_hz = 100
trigger_at = 10
num_records = 500
n_channels = len(channels) - 1
data = [
mock_record(n_channels) + [0 if (i + 1) < trigger_at else 1]
for i in range(num_records)
]
device = _MockConnector(data=data,
device_spec=DeviceSpec(name="Mock_device",
channels=channels,
sample_rate=sample_hz))
daq = DataAcquisitionClient(connector=device,
buffer_name='buffer_client_test_offset.db',
raw_data_file_name=None,
delete_archive=True,
clock=CountClock())
daq.trigger_column = col_name
daq.start_acquisition()
time.sleep(0.1)
daq.stop_acquisition()
# The assertions should work before the stop_acquisition, but on some
# Windows environments the tests were taking too long to setup and the
# time would complete before any data had been processed.
self.assertTrue(daq.is_calibrated)
self.assertEqual(daq.offset, float(trigger_at) / sample_hz)
daq.cleanup()
def main(debug: bool = False):
# pylint: disable=too-many-locals
"""Creates a sample lsl client that reads data from a sample TCP server
(see demo/server.py). Data is written to a rawdata.csv file, as well as a
buffer.db sqlite3 database. These files are written in whichever directory
the script was run.
The client/server can be stopped with a Keyboard Interrupt (Ctl-C)."""
import time
import sys
# Allow the script to be run from the bci root, acquisition dir, or
# demo dir.
sys.path.append('.')
sys.path.append('..')
sys.path.append('../..')
from bcipy.acquisition.devices import DeviceSpec
from bcipy.acquisition.protocols.lsl.lsl_connector import LslConnector
from bcipy.acquisition.client import DataAcquisitionClient
from bcipy.acquisition.datastream.lsl_server import LslDataServer
from bcipy.acquisition.datastream.tcp_server import await_start
from bcipy.helpers.system_utils import log_to_stdout
if debug:
log_to_stdout()
# Generic LSL device with 16 channels.
device_spec = DeviceSpec(name="LSL_demo",
channels=[
"Ch1", "Ch2", "Ch3", "Ch4", "Ch5", "Ch6",
"Ch7", "Ch8", "Ch9", "Ch10", "Ch11", "Ch12",
"Ch13", "Ch14", "Ch15", "Ch16"
],
sample_rate=256.0)
server = LslDataServer(device_spec=device_spec)
await_start(server)
# Device is for reading data.
connector = LslConnector(connection_params={}, device_spec=device_spec)
raw_data_name = 'demo_raw_data.csv'
client = DataAcquisitionClient(connector=connector,
raw_data_file_name=raw_data_name)
try:
client.start_acquisition()
print("\nCollecting data for 3s... (Interrupt [Ctl-C] to stop)\n")
while True:
time.sleep(1)
client.marker_writer.push_marker('calibration_trigger')
time.sleep(2)
# since calibration trigger was pushed after 1 second of sleep
print(f"Offset: {client.offset}; this value should be close to 1.")
client.stop_acquisition()
client.cleanup()
server.stop()
print(f"\nThe collected data has been written to {raw_data_name}")
break
except KeyboardInterrupt:
print("Keyboard Interrupt; stopping.")
client.stop_acquisition()
client.cleanup()
server.stop()
print(f"\nThe collected data has been written to {raw_data_name}")
def init_eeg_acquisition(parameters: dict,
save_folder: str,
clock=CountClock(),
server: bool = False):
"""Initialize EEG Acquisition.
Initializes a client that connects with the EEG data source and begins
data collection.
Parameters
----------
parameters : dict
configuration details regarding the device type and other relevant
connection information.
{
"acq_device": str,
"acq_connection_method": str,
"acq_host": str,
"acq_port": int,
"buffer_name": str,
"raw_data_name": str
}
clock : Clock, optional
optional clock used in the client; see client for details.
server : bool, optional
optionally start a mock data server that streams random data.
Returns
-------
(client, server) tuple
"""
# Set configuration parameters with default values if not provided.
host = parameters['acq_host']
port = parameters['acq_port']
buffer_name = str(
Path(save_folder, parameters.get('buffer_name', 'raw_data.db')))
raw_data_file = Path(save_folder,
parameters.get('raw_data_name', 'raw_data.csv'))
connection_method = ConnectionMethod.by_name(
parameters['acq_connection_method'])
# TODO: parameter for loading devices; path to devices.json?
# devices.load(devices_path)
device_spec = supported_device(parameters['acq_device'])
dataserver = False
if server:
dataserver = start_server(connection_method, device_spec, host, port)
# TODO: only use these connection_params if this is ConnectionMethod.TCP
# Refactor to extract only the needed connection params from parameters.
connection_params = {'host': host, 'port': port}
connector = registry.make_connector(device_spec, connection_method,
connection_params)
client = DataAcquisitionClient(connector=connector,
buffer_name=buffer_name,
delete_archive=False,
raw_data_file_name=raw_data_file,
clock=clock)
client.start_acquisition()
if parameters['acq_show_viewer']:
viewer_screen = 1 if int(parameters['stim_screen']) == 0 else 0
start_viewer(display_screen=viewer_screen)
# If we're using a server or data generator, there is no reason to
# calibrate data.
if server and connection_method != ConnectionMethod.LSL:
client.is_calibrated = True
return (client, dataserver)
def main():
"""Creates a sample client that reads data from a sample TCP server
(see demo/server.py). Data is written to a buffer.db sqlite3 database
and streamed through a GUI. These files are written in whichever directory
the script was run.
The client/server can be stopped with a Keyboard Interrupt (Ctl-C)."""
import time
from bcipy.acquisition.datastream import generator
from bcipy.acquisition.protocols import registry
from bcipy.acquisition.client import DataAcquisitionClient
from bcipy.acquisition.datastream.server import DataServer
from bcipy.gui.viewer.processor.viewer_processor import ViewerProcessor
host = '127.0.0.1'
port = 9000
# The Protocol is for mocking data.
protocol = registry.default_protocol('DSI')
server = DataServer(protocol=protocol,
generator=generator.random_data,
gen_params={'channel_count': len(protocol.channels)},
host=host,
port=port)
# Device is for reading data.
# pylint: disable=invalid-name
Device = registry.find_device('DSI')
dsi_device = Device(connection_params={'host': host, 'port': port})
client = DataAcquisitionClient(device=dsi_device,
processor=ViewerProcessor())
try:
server.start()
client.start_acquisition()
seconds = 10
print(
f"\nCollecting data for {seconds}s... (Interrupt [Ctl-C] to stop)\n"
)
t0 = time.time()
elapsed = 0
while elapsed < seconds:
time.sleep(0.1)
elapsed = (time.time()) - t0
client.stop_acquisition()
client.cleanup()
print("Number of samples: {0}".format(client.get_data_len()))
server.stop()
except KeyboardInterrupt:
print("Keyboard Interrupt; stopping.")
client.stop_acquisition()
client.cleanup()
print("Number of samples: {0}".format(client.get_data_len()))
server.stop()
def main():
"""Creates a sample client that reads data from an LSL server
(see demo/server.py). Data is written to a rawdata.csv file, as well as a
buffer.db sqlite3 database. These files are written in whichever directory
the script was run.
The client can be stopped with a Keyboard Interrupt (Ctl-C).
Note: This demo assumes that you already have a running lsl_server.
"""
import sys
import time
# Allow the script to be run from the bci root, acquisition dir, or
# demo dir.
sys.path.append('.')
sys.path.append('..')
sys.path.append('../..')
from bcipy.acquisition.client import DataAcquisitionClient
from bcipy.acquisition.protocols import registry
from bcipy.acquisition.devices import supported_device
from bcipy.acquisition.connection_method import ConnectionMethod
# pylint: disable=invalid-name
device_spec = supported_device('LSL')
print(f"\nAcquiring data from device {device_spec}")
Connector = registry.find_connector(device_spec, ConnectionMethod.LSL)
lsl_connector = Connector(connection_params={}, device_spec=device_spec)
lsl_connector.include_marker_streams = True
if Connector:
print(f"Found device connector: {lsl_connector}")
# Use default processor (FileWriter), buffer, and clock.
raw_data_name = 'lsl_client_raw_data.csv'
client = DataAcquisitionClient(connector=lsl_connector,
raw_data_file_name=raw_data_name)
try:
client.start_acquisition()
print("\nCollecting data for 3s... (Interrupt [Ctl-C] to stop)\n")
while True:
time.sleep(3)
print(f"Number of samples: {client.get_data_len()}")
client.stop_acquisition()
client.cleanup()
print(f"The collected data has been written to {raw_data_name}")
break
except IOError as e:
print(f'{e.strerror}; make sure you started the server.')
except KeyboardInterrupt:
print("Keyboard Interrupt")
client.stop_acquisition()
client.cleanup()
def test_daq_with_no_buffer(self):
"""get_data should return an empty list if daq._buf is None
data length should return 0
"""
device = _MockConnector(data=self.mock_data,
device_spec=self.device_spec)
daq = DataAcquisitionClient(connector=device,
delete_archive=True,
raw_data_file_name=None)
daq.start_acquisition()
time.sleep(0.1)
daq.stop_acquisition()
# Make sure we are able to stop the buffer process
buf_temp = daq._buf
daq._buf = None
# test get_data
data = daq.get_data()
self.assertEqual(data, [])
# test get_data_len
data_length = daq.get_data_len()
self.assertEqual(data_length, 0)
# test offset
offset = daq.offset
self.assertEqual(offset, None)
daq._buf = buf_temp
daq.cleanup()
def main():
"""Creates a sample client that reads data from a sample TCP server
(see demo/server.py). Data is written to a rawdata.csv file, as well as a
buffer.db sqlite3 database. These files are written in whichever directory
the script was run.
The client/server can be stopped with a Keyboard Interrupt (Ctl-C)."""
import time
import sys
# Allow the script to be run from the bci root, acquisition dir, or
# demo dir.
sys.path.append('.')
sys.path.append('..')
sys.path.append('../..')
from bcipy.acquisition.datastream import generator
from bcipy.acquisition.protocols import registry
from bcipy.acquisition.client import DataAcquisitionClient
from bcipy.acquisition.datastream.server import DataServer
host = '127.0.0.1'
port = 9000
# The Protocol is for mocking data.
protocol = registry.default_protocol('DSI')
server = DataServer(protocol=protocol,
generator=generator.random_data,
gen_params={'channel_count': len(protocol.channels)},
host=host, port=port)
# Device is for reading data.
# pylint: disable=invalid-name
Device = registry.find_device('DSI')
dsi_device = Device(connection_params={'host': host, 'port': port})
client = DataAcquisitionClient(device=dsi_device)
try:
server.start()
client.start_acquisition()
print("\nCollecting data for 10s... (Interrupt [Ctl-C] to stop)\n")
while True:
time.sleep(10)
client.stop_acquisition()
client.cleanup()
print("Number of samples: {0}".format(client.get_data_len()))
server.stop()
print("The collected data has been written to rawdata.csv")
break
except KeyboardInterrupt:
print("Keyboard Interrupt; stopping.")
client.stop_acquisition()
client.cleanup()
print("Number of samples: {0}".format(client.get_data_len()))
server.stop()
print("The collected data has been written to rawdata.csv")
def main():
"""Creates a sample client that reads data from a TCP server
(see demo/server.py). Data is written to a rawdata.csv file, as well as a
buffer.db sqlite3 database. These files are written in whichever directory
the script was run.
The client can be stopped with a Keyboard Interrupt (Ctl-C)."""
import time
import sys
from psychopy import clock
# Allow the script to be run from the bci root, acquisition dir, or
# demo dir.
sys.path.append('.')
sys.path.append('..')
sys.path.append('../..')
from bcipy.acquisition.client import DataAcquisitionClient
from bcipy.acquisition.devices import supported_device
from bcipy.acquisition.protocols.dsi.dsi_connector import DsiConnector
# Start the server with the command:
# python bcipy/acquisition/datastream/tcp_server.py --name DSI --port 9000
device_spec = supported_device('DSI')
connection_params = {'host': '127.0.0.1', 'port': 9000}
connector = DsiConnector(connection_params=connection_params,
device_spec=device_spec)
# Use default processor (FileWriter), buffer, and clock.
client = DataAcquisitionClient(connector=connector, clock=clock.Clock())
try:
client.start_acquisition()
print("\nCollecting data for 3s... (Interrupt [Ctl-C] to stop)\n")
while True:
time.sleep(3)
print(f"Number of samples: {client.get_data_len()}")
client.stop_acquisition()
client.cleanup()
break
except IOError as e:
print(f'{e.strerror}; make sure you started the server.')
except KeyboardInterrupt:
print("Keyboard Interrupt")
client.stop_acquisition()
client.cleanup()
def init_eeg_acquisition(parameters: dict,
save_folder: str,
clock=CountClock(),
server: bool = False):
"""Initialize EEG Acquisition.
Initializes a client that connects with the EEG data source and begins
data collection.
Parameters
----------
parameters : dict
configuration details regarding the device type and other relevant
connection information.
{
"acq_device": str,
"acq_host": str,
"acq_port": int,
"buffer_name": str,
"raw_data_name": str
}
clock : Clock, optional
optional clock used in the client; see client for details.
server : bool, optional
optionally start a server that streams random DSI data; defaults
to true; if this is True, the client will also be a DSI client.
Returns
-------
(client, server) tuple
"""
# Initialize the needed DAQ Parameters
host = parameters['acq_host']
port = parameters['acq_port']
parameters = {
'acq_show_viewer': parameters['acq_show_viewer'],
'viewer_screen': 1 if int(parameters['stim_screen']) == 0 else 0,
'buffer_name': save_folder + '/' + parameters['buffer_name'],
'device': parameters['acq_device'],
'filename': save_folder + '/' + parameters['raw_data_name'],
'connection_params': {
'host': host,
'port': port
}
}
# Set configuration parameters (with default values if not provided).
buffer_name = parameters.get('buffer_name', 'buffer.db')
connection_params = parameters.get('connection_params', {})
device_name = parameters.get('device', 'DSI')
filename = parameters.get('filename', 'rawdata.csv')
dataserver = False
if server:
if device_name == 'DSI':
protocol = registry.default_protocol(device_name)
dataserver, port = start_socket_server(protocol, host, port)
connection_params['port'] = port
elif device_name == 'LSL':
channel_count = 16
sample_rate = 256
channels = ['ch{}'.format(c + 1) for c in range(channel_count)]
dataserver = LslDataServer(
params={
'name': 'LSL',
'channels': channels,
'hz': sample_rate
},
generator=generator.random_data(channel_count=channel_count))
await_start(dataserver)
else:
raise ValueError(
'Server (fake data mode) for this device type not supported')
Device = registry.find_device(device_name)
filewriter = FileWriter(filename=filename)
proc = filewriter
if parameters['acq_show_viewer']:
proc = DispatchProcessor(
filewriter,
ViewerProcessor(display_screen=parameters['viewer_screen']))
# Start a client. We assume that the channels and fs will be set on the
# device; add a channel parameter to Device to override!
client = DataAcquisitionClient(
device=Device(connection_params=connection_params),
processor=proc,
buffer_name=buffer_name,
clock=clock)
client.start_acquisition()
# If we're using a server or data generator, there is no reason to
# calibrate data.
if server and device_name != 'LSL':
client.is_calibrated = True
return (client, dataserver)
def main():
# pylint: disable=too-many-locals
"""Creates a sample lsl client that reads data from a sample TCP server
(see demo/server.py). Data is written to a rawdata.csv file, as well as a
buffer.db sqlite3 database. These files are written in whichever directory
the script was run.
The client/server can be stopped with a Keyboard Interrupt (Ctl-C)."""
import time
import sys
# Allow the script to be run from the bci root, acquisition dir, or
# demo dir.
sys.path.append('.')
sys.path.append('..')
sys.path.append('../..')
from bcipy.acquisition.datastream import generator
from bcipy.acquisition.protocols import registry
from bcipy.acquisition.client import DataAcquisitionClient
from bcipy.acquisition.datastream.lsl_server import LslDataServer
from bcipy.acquisition.datastream.server import await_start
host = '127.0.0.1'
port = 9000
channel_count = 16
sample_rate = 256
channels = ['ch{}'.format(c + 1) for c in range(channel_count)]
# The Protocol is for mocking data.
server = LslDataServer(params={'name': 'LSL',
'channels': channels,
'hz': sample_rate},
generator=generator.random_data(
channel_count=channel_count))
await_start(server)
# Device is for reading data.
# pylint: disable=invalid-name
Device = registry.find_device('LSL')
device = Device(connection_params={'host': host, 'port': port})
client = DataAcquisitionClient(device=device)
try:
client.start_acquisition()
print("\nCollecting data for 10s... (Interrupt [Ctl-C] to stop)\n")
while True:
time.sleep(10)
client.stop_acquisition()
client.cleanup()
print("Number of samples: {0}".format(client.get_data_len()))
server.stop()
print("The collected data has been written to rawdata.csv")
break
except KeyboardInterrupt:
print("Keyboard Interrupt; stopping.")
client.stop_acquisition()
client.cleanup()
print("Number of samples: {0}".format(client.get_data_len()))
server.stop()
print("The collected data has been written to rawdata.csv")