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():
"""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,
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 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 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.protocols import registry
# pylint: disable=invalid-name
Device = registry.find_device('DSI')
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:
time.sleep(10)
print("Ten Second Passed")
print("Number of samples: {0}".format(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")
print("Number of samples: {0}".format(client.get_data_len()))
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)
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 = 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)
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")