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()
def simulation_workflow(self,callbacks, ser): #zephyr.configure_root_logger() don't want no logging file 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) self.delayed_stream_thread = DelayedRealTimeStream(collector, callbacks, 1.2) self.protocol = BioHarnessProtocol(ser, [message_parser.parse_data]) self.protocol.enable_periodic_packets() self.delayed_stream_thread.start() try: self.protocol.run() except EOFError: pass self.delayed_stream_thread.terminate() self.delayed_stream_thread.join()
class ZephyrDevice( QThread ): """ Send QT signal whenever the selected packet is received from the device """ def __init__( self ): QThread.__init__(self) self.prev_val = 0 self.SerialNumber = '' self.connected = False self.paused = False self.running = False self.create_test_data = False self.PacketType = { 'GENERAL':0x14, 'BREATHING':0x15, 'ECG':0x16, 'RRDATA':0x19, 'ACC':0x1E, 'SUMMARY':0xBD,} self.virtual_serial = False zephyr.configure_root_logger() if CREATE_TEST_DATA is True and self.virtual_serial is False: self.testdata_writer = MessageDataLogger(test_data_dir + "/5-minutes-zephyr-stream-03") def connectTo(self, serialport, virtual=False): try: if virtual is True: self.ser = TimedVirtualSerial(test_data_dir + "/5-minutes-zephyr-stream-03.dat", test_data_dir + "/5-minutes-zephyr-stream-03-timing.csv") self.connected = True self.virtual_serial = True else: self.ser = serial.Serial( serialport ) self.virtual_serial = False self.ser.close() # in case the port is already in use self.ser.open() self.initialize_device() return True except serial.SerialException: return False 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 _callback_serial_test( self, message ): if hasattr(message, 'Number'): # Message is the serial number self.disconnect(self, SIGNAL( 'Message' ), self._callback_serial_test) if message.Number != '': self.SerialNumber = message.Number.strip() self.connected = True self.emit( SIGNAL( 'Message' ), "connected" ) def run(self): self.running = True self.delayed_stream_thread.start() self.protocol.start() while self.running: try: time.sleep(1) except KeyboardInterrupt: self.terminate() logging.debug("ZephyrDevice QThread is out of the while loop.") def terminate(self): self.protocol.terminate() self.protocol.join() self.delayed_stream_thread.terminate() self.delayed_stream_thread.join() self.ser.close() self.running = False self.connected = False del self.protocol def resume(self): self.ser.paused = False def pause(self): self.ser.paused = True def callback(self, value_name, value): if value_name is 'rr' and value != self.prev_val: rri_ms = int(abs(value)*1000) self.prev_val = value self.emit( SIGNAL( 'rrinterval' ), rri_ms ) # if value_name is 'breathing': # self.emit( SIGNAL( 'breathing_wave' ), value ) # if value_name is 'ecg': # self.emit( SIGNAL( 'ecg' ), value ) if value_name is 'heart_rate': self.emit( SIGNAL( 'heart_rate' ), value ) if value_name is 'respiration_rate': self.emit( SIGNAL( 'respiration_rate' ), value ) if value_name is 'breathing_wave_amplitude': self.emit( SIGNAL( 'breathing_wave_amplitude' ), value ) print value if value_name is 'activity': self.emit( SIGNAL( 'activity' ), value ) if value_name is 'posture': if value > 180: # convert two's complement to decimal posture = value-(1<<16) else: posture = value self.emit( SIGNAL( 'posture' ), posture ) def anyotherpackets( self, message ): self.emit( SIGNAL( 'Message' ), message ) if type(message) is zephyr.message.SignalPacket and message.type == 'ecg': self.emit( SIGNAL( 'ecg' ), message.samples ) if type(message) is zephyr.message.SignalPacket and message.type == 'breathing': self.emit( SIGNAL( 'breathing_wave' ), message.samples ) def sendmessage(self, message_id, payload): self.protocol.add_initilization_message(message_id, payload) def enablePacket( self, packet_type ): try: data = [1] if packet_type == 'SUMMARY': data = [1, 0] self.sendmessage(self.PacketType[packet_type], data) return True except: return False def disablePacket( self, packet_type ): try: data = [0] if packet_type == 'SUMMARY': data = [0, 0] self.sendmessage(self.PacketType[packet_type], data) return True except: return False def create_test_data_function(self, stream_data): if CREATE_TEST_DATA is True and self.virtual_serial is False: self.testdata_writer( stream_data )