def __init__(self,
device,
processor=FileWriter(filename='rawdata.csv'),
buffer_name='buffer.db',
clock=CountClock(),
delete_archive=True):
self._device = device
self._processor = processor
self._buffer_name = buffer_name
self._clock = clock
# boolean; set to false to retain the sqlite db.
self.delete_archive = delete_archive
self._device_info = None # set on start.
self._is_streaming = False
# Offset in seconds from the start of acquisition to calibration
# trigger. Calculated once, then cached.
self._cached_offset = None
self._record_at_calib = None
self._max_wait = 0.1 # for process loop
# Max number of records in queue before it blocks for processing.
maxsize = 500
self._process_queue = multiprocessing.JoinableQueue(maxsize=maxsize)
self.marker_writer = NullMarkerWriter()
self._acq_process = None
self._data_processor = None
self._buf = None
def test_filewriter_setup(self):
"""
Test that FileWriter throws an exception if it is used without setting
the device_info.
"""
filewriter = FileWriter('foo.csv')
with pytest.raises(Exception):
with filewriter:
pass
def test_filewriter(self):
"""Test FileWriter functionality"""
data = [[i + j for j in range(3)] for i in range(3)]
expected_csv_rows = ['0,1,2\r\n', '1,2,3\r\n', '2,3,4\r\n']
filewriter = FileWriter('foo.csv')
filewriter.set_device_info(
DeviceInfo(name='foo-device', fs=100, channels=['c1', 'c2', 'c3']))
mockopen = mock_open()
with patch('bcipy.acquisition.processor.open', mockopen):
with filewriter:
mockopen.assert_called_once_with('foo.csv', 'w', newline='')
handle = mockopen()
handle.write.assert_called_with('timestamp,c1,c2,c3\r\n')
for i, row in enumerate(data):
timestamp = float(i)
filewriter.process(row, timestamp)
handle.write.assert_called_with(
str(timestamp) + "," + str(expected_csv_rows[i]))
mockopen().close.assert_called_once()
def main():
"""Test script."""
import sys
if sys.version_info >= (3, 0, 0):
# Only available in Python 3; allows us to test process code as it
# behaves in Windows environments.
multiprocessing.set_start_method('spawn')
import argparse
import json
from bcipy.acquisition.protocols import registry
parser = argparse.ArgumentParser()
parser.add_argument('-b', '--buffer', default='buffer.db',
help='buffer db name')
parser.add_argument('-f', '--filename', default='rawdata.csv')
parser.add_argument('-d', '--device', default='DSI',
choices=registry.supported_devices.keys())
parser.add_argument('-c', '--channels', default='',
help='comma-delimited list')
parser.add_argument('-p', '--params', type=json.loads,
default={'host': '127.0.0.1', 'port': 9000},
help="device connection params; json")
args = parser.parse_args()
device_builder = registry.find_device(args.device)
# Instantiate and start collecting data
dev = device_builder(connection_params=args.params)
if args.channels:
dev.channels = args.channels.split(',')
daq = DataAcquisitionClient(device=dev,
processor=FileWriter(filename=args.filename),
buffer_name=args.buffer,
delete_archive=True)
daq.start_acquisition()
# Get data from buffer
time.sleep(1)
print("Number of samples in 1 second: {0}".format(daq.get_data_len()))
time.sleep(1)
print("Number of samples in 2 seconds: {0}".format(daq.get_data_len()))
daq.stop_acquisition()
daq.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)
type=json.loads,
default={
'host': '127.0.0.1',
'port': 9000
},
help="device connection params; json")
args = parser.parse_args()
Device = registry.find_device(args.device)
# Instantiate and start collecting data
device = Device(connection_params=args.params)
if args.channels:
device.channels = args.channels.split(',')
daq = Client(device=device,
processor=FileWriter(filename=args.filename),
buffer_name=args.buffer,
delete_archive=True)
daq.start_acquisition()
# Get data from buffer
time.sleep(1)
print("Number of samples in 1 second: {0}".format(daq.get_data_len()))
time.sleep(1)
print("Number of samples in 2 seconds: {0}".format(daq.get_data_len()))
daq.stop_acquisition()