def setUp(self):
"""Run before each test."""
self.server = LslDataServer(
params={
'name': 'LSL',
'channels': self.channels,
'hz': self.hz
},
generator=generator.random_data(channel_count=self.channel_count),
include_meta=self.include_meta,
add_markers=True)
await_start(self.server)
def main():
"""Initialize and start the server."""
import time
import argparse
from bcipy.acquisition.datastream.generator import file_data, random_data
default_channels = ['ch' + str(i + 1) for i in range(16)]
parser = argparse.ArgumentParser()
parser.add_argument('-f',
'--filename',
default=None,
help="file containing data to be streamed; "
"if missing, random data will be served.")
parser.add_argument('-c',
'--channels',
default=','.join(default_channels),
help='comma-delimited list')
parser.add_argument('-s',
'--sample_rate',
default='256',
help='sample rate in hz')
parser.add_argument('-m', '--markers', action="store_true", default=False)
parser.add_argument('-n', '--name', default='LSL')
args = parser.parse_args()
params = {
'channels': args.channels.split(','),
'hz': int(args.sample_rate)
}
# Generate data from the file if provided, otherwise random data.
generator = file_data(filename=args.filename) if args.filename \
else random_data(channel_count=len(params['channels']))
markers = True if args.markers else False
try:
server = LslDataServer(params=params,
generator=generator,
add_markers=markers,
name=args.name)
logging.debug("New server created")
server.start()
logging.debug("Server started")
while True:
time.sleep(1)
except KeyboardInterrupt:
print("Keyboard Interrupt")
server.stop()
def __init__(self,
queue,
freq=1 / 100,
generator=random_data(),
maxiters=None):
super(Producer, self).__init__()
self.daemon = True
self._running = True
self.freq = freq
self.generator = generator
self.maxiters = maxiters
self.queue = queue
def test_random_with_custom_encoder(self):
"""Random generator should allow a custom encoder."""
channel_count = 10
gen = random_data(encoder=CustomEncoder(),
channel_count=channel_count)
data = [next(gen) for _ in range(100)]
self.assertEqual(len(data), 100)
for _count, record in data:
self.assertEqual(len(record), channel_count)
self.assertEqual(data[0][0], 1)
self.assertEqual(data[99][0], 100)
def test_random_high_low_values(self):
"""Random generator should allow user to set value ranges."""
channel_count = 10
low = -100
high = 100
gen = random_data(low=-100, high=100,
channel_count=channel_count)
data = [next(gen) for _ in range(100)]
self.assertEqual(len(data), 100)
for record in data:
self.assertEqual(len(record), channel_count)
for value in record:
self.assertTrue(low <= value <= high)
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 test_random_generator(self):
"""Test default parameters for random generator"""
gen = random_data()
data = [next(gen) for _ in range(100)]
self.assertEqual(len(data), 100)
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")
