def initialize_device(self):
collector = MeasurementCollector()
rr_signal_analysis = BioHarnessSignalAnalysis([], [collector.handle_event])
signal_packet_handler_bh = BioHarnessPacketHandler([collector.handle_signal, rr_signal_analysis.handle_signal],
[collector.handle_event])
# Handle the payload of the message.
# We don't treat the message payload at this time. The MessagePayloadParser class, when its method
# handle_message() is executed (after the MessageFrameParser has verified the frame), will callbacks
# the function specified in the list below with a correct message format.
payload_parser = MessagePayloadParser([signal_packet_handler_bh.handle_packet, self.anyotherpackets])
# handle the frame: verify STX, DLC, CRC and execute callback with the message in parameter
message_parser = MessageFrameParser([payload_parser.handle_message])
# The delayed stream is useful to synchronize the data coming from the device
# and provides an easy reading by sending tuples like (signal name, sample value)
self.delayed_stream_thread = DelayedRealTimeStream(collector, [self.callback], 1)
self.protocol = BioHarnessProtocol(self.ser, [message_parser.parse_data, self.create_test_data_function])
if self.virtual_serial is False :
self.protocol.add_initilization_message( 0x0B, []) # get Serial Number
self.connect( self, SIGNAL( 'Message' ), self._callback_serial_test )
# by default disable every packet:
self.protocol.add_initilization_message(self.PacketType['SUMMARY'], [0]) # disable summary packet
self.protocol.add_initilization_message(self.PacketType['BREATHING'], [0]) # disable breathing waveform
self.protocol.add_initilization_message(self.PacketType['ECG'], [0]) # disable ecg waveform
self.protocol.add_initilization_message(self.PacketType['RRDATA'], [0]) # disable rr data
self.protocol.add_initilization_message(self.PacketType['ACC'], [0]) # disable accelerometer waveform
def main():
zephyr.configure_root_logger()
collector = MeasurementCollector()
rr_signal_analysis = BioHarnessSignalAnalysis([], [collector.handle_event])
signal_packet_handlers = [collector.handle_signal, rr_signal_analysis.handle_signal]
signal_packet_handler = BioHarnessPacketHandler(signal_packet_handlers, [collector.handle_event])
payload_parser = MessagePayloadParser(signal_packet_handler.handle_packet)
delayed_stream_thread = DelayedRealTimeStream(collector, callback)
simulation_thread = FilePacketSimulator(test_data_dir + "/120-second-bt-stream.dat",
test_data_dir + "/120-second-bt-stream-timing.csv",
payload_parser.handle_message)
delayed_stream_thread.start()
simulation_thread.start()
visualization = VisualizationWindow(collector)
visualization.show()
simulation_thread.terminate()
simulation_thread.join()
delayed_stream_thread.terminate()
delayed_stream_thread.join()
def simulation_workflow(callbacks, ser):
zephyr.configure_root_logger()
collector = MeasurementCollector()
rr_signal_analysis = BioHarnessSignalAnalysis([], [collector.handle_event])
signal_packet_handler_bh = BioHarnessPacketHandler(
[collector.handle_signal, rr_signal_analysis.handle_signal],
[collector.handle_event])
signal_packet_handler_hxm = HxMPacketAnalysis([collector.handle_event])
payload_parser = MessagePayloadParser([
signal_packet_handler_bh.handle_packet,
signal_packet_handler_hxm.handle_packet
])
message_parser = MessageFrameParser(payload_parser.handle_message)
delayed_stream_thread = DelayedRealTimeStream(collector, callbacks, 1.2)
protocol = BioHarnessProtocol(ser, [message_parser.parse_data])
print "Enabling packets"
protocol.enable_periodic_packets()
delayed_stream_thread.start()
try:
protocol.run()
except EOFError:
pass
delayed_stream_thread.terminate()
delayed_stream_thread.join()
