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 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 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 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 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")