def add_sensors():
# Creating an instance of sensor
my_camera = CameraStreaming(camera_no=0,
name="camera",
output_path="./output")
# Creating an instance of device coordinator
device_coordinator = DeviceCoordinator()
# Adding sensor to device coordinator
device_coordinator.add_devices([my_camera])
experiment_id = "p01"
stimuli_id = "S00"
input("Press a button to start data recording")
# Starts data recording
device_coordinator.dispatch(start_message(experiment_id, stimuli_id))
time.sleep(5)
# Stops deta recording
device_coordinator.dispatch(stop_message(experiment_id, stimuli_id))
time.sleep(0.5)
# Terminate, This step is necessary to close the connection with added devices
device_coordinator.terminate()
def test_should_auto_assign_device_id():
test_device = Device()
test_device._run = fake_run
coordinator = DeviceCoordinator()
coordinator.add_device(test_device)
assert isinstance(test_device.name, str)
assert len(test_device.name) > 0
def test_preprocess_continuous_saving_mode():
ch_names = [
"Fp1", "Fp2", "F7", "F3", "F4", "F8", "T3", "C3", "C4", "T4", "T5",
"P3", "P4", "T6", "O1", "O2"
]
openbci16 = \
MockedOpenBCIStreaming(name="OpenBCI_16_continuous",
saving_mode=SavingModeEnum.CONTINIOUS_SAVING_MODE,
output_path=os.path.join(
RECORDED_FILES_PATH, "OpenBCI_16_continuous"),
channels_order=ch_names)
ch_names = ["Fp1", "Fp2", "F7", "F3", "F4", "F8", "T3", "C3"]
openbci8 = \
MockedOpenBCIStreaming(name="OpenBCI_8_continuous",
saving_mode=SavingModeEnum.CONTINIOUS_SAVING_MODE,
output_path=os.path.join(
RECORDED_FILES_PATH, "OpenBCI_8_continuous"),
channels_order=ch_names,
daisy=False)
shimmer = \
MockedShimmer3Streaming(name="Shimmer_continuous",
saving_mode=SavingModeEnum.CONTINIOUS_SAVING_MODE,
output_path=os.path.join(RECORDED_FILES_PATH, "Shimmer_continuous"))
device_coordinator = DeviceCoordinator()
device_coordinator.add_devices([openbci16, openbci8, shimmer])
preprocess_file_path = "/tmp/preprocess"
preprocess_devices(device_coordinator,
preprocess_file_path,
openbci_sampling_rate=6,
shimmer3_sampling_rate=6,
signal_preprocess=False)
expected_openbci16_path = \
os.path.join(os.path.dirname(os.path.realpath(__file__)),
"data/preprocess_expected/OpenBCI_16_continuous")
preprocess_openbci16_path = "/tmp/preprocess/OpenBCI_16_continuous"
check_files(preprocess_openbci16_path, expected_openbci16_path)
expected_openbci8_path = \
os.path.join(os.path.dirname(os.path.realpath(__file__)),
"data/preprocess_expected/OpenBCI_8_continuous")
preprocess_openbci8_path = "/tmp/preprocess/OpenBCI_8_continuous"
check_files(preprocess_openbci8_path, expected_openbci8_path)
expected_shimmer_path = \
os.path.join(os.path.dirname(os.path.realpath(__file__)),
"data/preprocess_expected/Shimmer_continuous/gsr")
preprocess_shimmer_path = "/tmp/preprocess/Shimmer_continuous/gsr"
check_files(preprocess_shimmer_path, expected_shimmer_path)
expected_shimmer_path = \
os.path.join(os.path.dirname(os.path.realpath(__file__)),
"data/preprocess_expected/Shimmer_continuous/ppg")
preprocess_shimmer_path = "/tmp/preprocess/Shimmer_continuous/ppg"
check_files(preprocess_shimmer_path, expected_shimmer_path)
def simple_scenario(stimuli_path):
# Reading image stimuli and assigning an ID to them based on their alphabetical order
stimuli_list = os.listdir(stimuli_path)
stimuli_list.sort()
stimuli = {}
i = 0
for item in stimuli_list:
stimuli[i] = item
i += 1
print("initializing")
# Creating an instance of simmer3
my_shimmer = Shimmer3Streaming(name="Shimmer3_sensor",
output_path="./output")
# Creating an instance of camera. by uncommenting this line and adding it to the dive_coordinator
# you can record video data as well
# my_camera = CameraStreaming(0, name="camera", output_path="./output", )
# Creating an instance of device coordinator
device_coordinator = DeviceCoordinator()
# Adding sensor to device coordinator
device_coordinator.add_devices([my_shimmer])
experiment_id = "p01"
# A delay to be sure initialing devices have finished
time.sleep(3)
input("\nPress a key to run the scenario")
for stimuli_id, stmulus_name in stimuli.items():
# Starts data recording by displaying the image
device_coordinator.dispatch(start_message(experiment_id, stimuli_id))
# Displaying image may start with some miliseconds delay after data recording
# because of GTK initialization in show_image_standalone. If this delay is important to you,
# use other tools for displaying image stimuli
# Since image is displaying in another thread we have to manually create the same delay in current
# thread to record data for 10 seconds
timeout = 5
stimulus = ImageStimulus(stimuli_id,
os.path.join(stimuli_path, stmulus_name), 5)
stimulus.show_standalone()
time.sleep(timeout)
# IF the stimuli is a video we are displaying stimuli as follows
#stimulus = VideoStimulus(stimuli_id, os.path.join(stimuli_path, stmulus_name))
#stimulus.show()
# Stops data recording by closing image
device_coordinator.dispatch(stop_message(experiment_id, stimuli_id))
input("\nPress a key to continue")
# Terminate, This step is necessary to close the connection with added devices
device_coordinator.terminate()
def preprocess_devices(device_coordinator: DeviceCoordinator,
output_path: str,
openbci_sampling_rate: int = 128,
shimmer3_sampling_rate: int = 128,
signal_preprocess: bool = True):
'''
Preprocees recorded files for all devices that are added to device_coordinator,
Some devices do not have any preprocessing, so this function will ignore them
@param DeviceCoordinator device_coordinator: an instance of DeviceCoordinator
@param str output_path: Path for preprocessed Files
@param int openbci_sampling_rate: New sampling rate for openbci resampling
@param int shimmer3_sampling_rate: New sampling rate for shimmer3 resampling
'''
print("Start preprocessing ....")
devices = device_coordinator.get_devices()
for device in devices:
if isinstance(device, OpenBCIStreaming):
device_output_path = os.path.join(output_path, device.get_name())
print("device_output_path", device_output_path)
if not os.path.exists(device_output_path):
pathlib.Path(device_output_path).mkdir(parents=True,
exist_ok=True)
# This is the path that device saves recording data
input_path = device.get_output_path()
print("input_path", input_path)
file_names = os.listdir(input_path)
file_names.sort()
if not os.path.exists(device_output_path):
os.mkdir(device_output_path)
for file_name in file_names:
openbci_preprocess(input_path,
file_name,
device_output_path,
device.get_channels(),
saving_mode=device.get_saving_mode(),
sampling_rate=openbci_sampling_rate,
signal_preprocess=signal_preprocess)
elif isinstance(device, Shimmer3Streaming):
device_output_path = os.path.join(output_path, device.get_name())
if not os.path.exists(device_output_path):
pathlib.Path(device_output_path).mkdir(parents=True,
exist_ok=True)
# This is the path that device saves recording data
input_path = device.get_output_path()
file_names = os.listdir(input_path)
file_names.sort()
print("preprocess shimmer input_path", input_path)
print("preprocess shimmer device_output_path", device_output_path)
for file_name in file_names:
shimmer3_preprocess(input_path,
file_name,
device_output_path,
saving_mode=device.get_saving_mode(),
sampling_rate=shimmer3_sampling_rate,
signal_preprocess=signal_preprocess)
print("Preprocessing done")
def fixture():
test_device = Device()
test_device._run = fake_run
coordinator = DeviceCoordinator()
coordinator.add_device(test_device)
endpoint = DeviceMessageHTTPEndpoint(coordinator)
endpoint.start()
time.sleep(0.5)
http_client = http.client.HTTPConnection("127.0.0.1:9331", timeout=2)
yield (endpoint, coordinator, test_device, http_client)
endpoint.stop()
def test_http_network_device_happy_path():
coordinator = DeviceCoordinator()
device = HttpNetworkDevice(["http://localhost:5003/"],
name="test-http-network-device",
timeout=15)
coordinator.add_device(device)
server = http.server.ThreadingHTTPServer(("localhost", 5003), Handler)
threading.Thread(target=server.serve_forever, daemon=True).start()
# To ensure device and server are started
time.sleep(1)
coordinator.dispatch(start_message("exp1", "stim1"))
coordinator.dispatch(stop_message("exp1", "stim2"))
# Should send TERMINATE message
coordinator.terminate()
def test_should_not_add_duplicated_deivces():
test_device = Device(name="device1")
test_device._run = fake_run
coordinator = DeviceCoordinator()
coordinator.add_device(test_device)
with pytest.raises(RuntimeError):
coordinator.add_device(test_device)
def main():
device_coordinator = DeviceCoordinator()
subject_id = "00"
output_path = "output_remote/p{0}".format(subject_id)
if not os.path.exists(output_path):
os.makedirs(output_path, exist_ok=False)
# Add your devices
audio = AudioStreaming(2, name="Audio", output_path=output_path)
camera = \
CameraStreaming(name="webcam",
output_path=output_path,
camera_no=0,
image_width=640,
image_height=480)
device_coordinator = DeviceCoordinator()
device_coordinator.add_devices([audio, camera])
# Create and start the endpoint
message_endpoint = DeviceMessageHTTPEndpoint(device_coordinator)
print("start listening")
message_endpoint.start()
while True:
key = input("Please enter q to stop")
if key == "q":
break
message_endpoint.stop()
def main():
subject_id, task_id = get_input_parameters()
experiment_id = str(subject_id).zfill(2) + "-" + str(task_id).zfill(2)
output_path = "examples/output/video/p{0}".format(subject_id)
os.makedirs(output_path, exist_ok=False)
####### Create video device ###########
#webcam_camera_path = "/dev/v4l/by-id/usb-046d_081b_97E6A7D0-video-index0"
#main_camera = \
# CameraStreaming(name="camera",
# output_path=output_path,
# camera_path=webcam_camera_path,
# image_width=640,
# image_height=360)
####### Create OpenBCI device ###########
#openbci = OpenBCIStreaming(name="OpenBCI_video", output_path=output_path)
####### Create Shimmer3 device ###########
#shimmer = Shimmer3Streaming(name="Shimmer_video", output_path=output_path)
####### Create Network device ###########
socket_device = SocketNetworkDevice("localhost", 5003)
# Add to device coordinator for synchronous data recording
device_coordinator = DeviceCoordinator()
device_coordinator.add_devices([socket_device
]) #, openbci, shimmer, main_camera])
stimuli_list = load_stimuli(stimuli_path)
# Make delay for initializing all processes
time.sleep(5)
main_window = \
MainWindow(experiment_id,
stimuli_list,
device_coordinator)
main_window.show()
def main():
'''
Scenario starts by
1- Initialization and displaying a gray screen (Put the cursor on each monitor that
you want to the scenario is being displayed)
2- Displaying a fixation cross for 3 seconds
3- Displaying a video stimulus and start to record data
4- Displaying a questionnaire
5- By answering the questionnaire and closing it, the same process repeat from the step 2.
It will be repeated for the number of video stimulus in the stimuli directory
Run the code like `pipenv run python watching_video_scenario.py -s 1`
By running this command it will consider `1` as the subject number and will record data in `p01` directory
'''
subject_id = get_input_parameters()
experiment_id = str(subject_id).zfill(2)
output_path = "output/p{0}".format(experiment_id)
os.makedirs(output_path, exist_ok=True)
# Create and instance of video device
camera = \
CameraStreaming(name="webcam",
output_path=output_path,
camera_no=0,
image_width=640,
image_height=360)
# Create an instance of OpenBCI device
openbci = BrainFlowOpenBCIStreaming(name="eeg",
output_path=output_path,
serial_port="/dev/ttyUSB2",
channels_order=[
"Fp1", "Fp2", "F7", "F3", "F4",
"F8", "T3", "C3", "C4", "T4", "T5",
"P3", "P4", "T6", "O1", "O2"
])
# Create Network device if you want to send triggers to other software and add it to device_coordinator
#socket_device = SocketNetworkDevice("localhost", 5006)
# Add to device coordinator for synchronous data recording
device_coordinator = DeviceCoordinator()
device_coordinator.add_devices([openbci, camera])
stimuli_list = load_stimuli(stimuli_path)
# Make delay for initializing all processes
print("Initializing")
time.sleep(5)
# Creating the main Gtk window
main_window = \
MainWindow(experiment_id,
stimuli_list,
device_coordinator,
output_path=output_path)
# After running this code, Run `pipenv run octopus-sensing-monitoring` in another terminal
# and then monitor data on browser.
# (Make sure to install octopus-sensing-monitoring if you want to monitor data in real time)
monitoring_endpoint = MonitoringEndpoint(device_coordinator)
monitoring_endpoint.start()
try:
# Start the scenario
main_window.show()
monitoring_endpoint.stop()
# After running this code, data will be prepared in preprocessed_output path
# By configging octopus_sensing_visualizer_config.conf in your project derectory and
# running `pipenv run octopus-sensing-visualizer` you can visualize data on browser after finishing
# the data collection (Make sure to install octopus-sensing-visualizer if you want to visualize data)
preprocess_devices(device_coordinator,
"preprocessed_output",
openbci_sampling_rate=125,
signal_preprocess=True)
finally:
device_coordinator.terminate()
def __server():
'''
Starts a server and send several messages and terminates
'''
device_coordinator = DeviceCoordinator()
socket_device = SocketNetworkDevice("localhost", 5002)
device_coordinator.add_devices([socket_device])
time.sleep(5)
message = start_message("test", "00")
device_coordinator.dispatch(message)
time.sleep(2)
message = stop_message("test", "00")
device_coordinator.dispatch(message)
time.sleep(2)
message = start_message("test", "01")
device_coordinator.dispatch(message)
time.sleep(2)
message = stop_message("test", "01")
device_coordinator.dispatch(message)
time.sleep(3)
device_coordinator.terminate()
def test_system_health(mocked):
'''Runs the whole system to roughly check everything is working together.'''
# To ensure mocks are applied, we import these modules here.
import octopus_sensing.devices.openbci_streaming as openbci_streaming
import octopus_sensing.devices.shimmer3_streaming as shimmer3_streaming
from octopus_sensing.device_coordinator import DeviceCoordinator
from octopus_sensing.common.message_creators import start_message, stop_message, terminate_message
from octopus_sensing.monitoring_endpoint import MonitoringEndpoint
output_dir = tempfile.mkdtemp(prefix="octopus-sensing-test")
coordinator = DeviceCoordinator()
openbci = openbci_streaming.OpenBCIStreaming(name="eeg",
output_path=output_dir)
coordinator.add_device(openbci)
shimmer = shimmer3_streaming.Shimmer3Streaming(name="shimmer",
output_path=output_dir)
coordinator.add_device(shimmer)
monitoring_endpoint = MonitoringEndpoint(coordinator)
monitoring_endpoint.start()
try:
coordinator.dispatch(start_message("int_test", "stimulus_1"))
# Allowing data collection for five seconds
time.sleep(5)
coordinator.dispatch(stop_message("int_test", "stimulus_1"))
http_client = http.client.HTTPConnection("127.0.0.1:9330")
http_client.request("GET", "/")
response = http_client.getresponse()
assert response.status == 200
monitoring_data = pickle.loads(response.read())
assert isinstance(monitoring_data, dict)
assert isinstance(monitoring_data["eeg"], list)
# three seconds * data rate
assert len(monitoring_data["eeg"]) == 3 * 128
assert len(monitoring_data["eeg"][0]) in (34, 35)
assert len(monitoring_data["eeg"][-1]) in (34, 35)
assert isinstance(monitoring_data["shimmer"], list)
assert len(monitoring_data["shimmer"]) == 3 * 128
assert len(monitoring_data["shimmer"][0]) in (8, 9)
assert len(monitoring_data["shimmer"][-1]) in (8, 9)
finally:
coordinator.dispatch(terminate_message())
monitoring_endpoint.stop()
# To ensure termination is happened.
time.sleep(0.5)
eeg_output = os.path.join(output_dir, "eeg")
assert os.path.exists(eeg_output)
assert len(os.listdir(eeg_output)) == 1
assert os.listdir(eeg_output)[0] == "eeg-int_test.csv"
shimmer_output = os.path.join(output_dir, "shimmer")
assert os.path.exists(shimmer_output)
assert len(os.listdir(shimmer_output)) == 1
assert os.listdir(shimmer_output)[0] == "shimmer-int_test.csv"
def server():
'''
Starts a server and sends several messages and terminates
'''
device_coordinator = DeviceCoordinator()
socket_device = SocketNetworkDevice("0.0.0.0", 5002)
device_coordinator.add_devices([socket_device])
time.sleep(2)
input("Press enter to start sending marker")
message = start_message("test", "00")
device_coordinator.dispatch(message)
time.sleep(2)
message = stop_message("test", "00")
device_coordinator.dispatch(message)
time.sleep(2)
message = start_message("test", "01")
device_coordinator.dispatch(message)
time.sleep(2)
message = stop_message("test", "01")
device_coordinator.dispatch(message)
time.sleep(3)
device_coordinator.terminate()