Index: DialityCoreCanProtocol.py =================================================================== diff -u -rbacdac2eb5cc03bfad1c55e9a3cb0f2f4bda95f5 -rf2b88894a458d9e03a9cb005af02ef16fd5e6f32 --- DialityCoreCanProtocol.py (.../DialityCoreCanProtocol.py) (revision bacdac2eb5cc03bfad1c55e9a3cb0f2f4bda95f5) +++ DialityCoreCanProtocol.py (.../DialityCoreCanProtocol.py) (revision f2b88894a458d9e03a9cb005af02ef16fd5e6f32) @@ -21,22 +21,42 @@ from time import sleep -class LongDialityPacketBuilder: +class DialinChannels: + # This are all the channels available + hd_alarm_broadcast_ch_id = 0x001 + dg_alarm_broadcast_ch_id = 0x002 + ui_alarm_broadcast_ch_id = 0x004 + hd_to_dg_ch_id = 0x008 + dg_to_hd_ch_id = 0x010 + hd_to_ui_ch_id = 0x020 + hd_sync_broadcast_ch_id = 0x040 + dg_sync_broadcast_ch_id = 0x080 + ui_to_hd_ch_id = 0x100 + dialin_to_hd_ch_id = 0x400 + hd_to_dialin_ch_id = 0x401 + dialin_to_dg_ch_id = 0x402 + dg_to_dialin_ch_id = 0x403 + dialin_to_ui_ch_id = 0x404 + ui_to_dialin_ch_id = 0x405 + + +class LongDialityMessageBuilder: + def __init__(self, can_message): """ - LongDialityPacketBuilder is a utility object that helps construct a diality packet + LongDialityMessageBuilder is a utility object that helps construct a diality message that is longer than 8 bytes. Basic principle is to construct an object with the - first 8 byte message which contains the length of the packet, and the later push the + first 8 byte message which contains the length of the message, and the later push the remaining messages. e.g., let's imagine a 3 message packet. - obj = LongDialityPacketBuilder(msg1) + obj = LongDialityMessageBuilder(msg1) - packet = obj.push(msg2), returns None + message = obj.push(msg2), returns None, message is not complete - packet = obj.push(msg3), return the packet which is the concatenation of msg1, msg2 and msg3 + message = obj.push(msg3), return the packet which is the concatenation of msg1, msg2 and msg3 - :param can_message: an 8 byte message needed to build a Diality packet. + :param can_message: an 8 byte message needed to build a diality message. :returns object @@ -71,28 +91,31 @@ return None -class DialityCanMessenger: +class DialinCanMessenger: START_BYTE = 0xA5 def __init__(self, can_interface='can0'): """ - DialityCanMesseger constructor + DialityCanMessenger constructor :param can_interface - string containing the can interface, e.g., 'can0" :returns DialityCanMessenger object """ - self.__canConnection = can.interface.Bus(can_interface, bustype='socketcan') + BusType = 'socketcan' + self.__canConnection = can.interface.Bus(channel=can_interface, bustype=BusType) self.__sendPacketRequestID = -1 self.__sendEvent = threading.Event() - self.__longPacketsBuilders = {} - self.__dialityPacket = None - self.__dialityResponsePacket = None - self.__dialityResponseChannelID = -1 + self.__longMessageBuilders = {} + self.__longMsgChannelIDSet = set() + self.__dialinMessage = None + self.__dialinCommandResponseMessage = None + self.__dialinResponseChannelID = -1 + self.__run = False self.__sync_response_dictionary = {} @@ -125,10 +148,6 @@ self.__run = False print("Can listener has stopped.") - def __getRequestID(self, message): - - return int.from_bytes(message[1:3], byteorder='big', signed=False) - def __listener(self): """ listens for diality message on the can interface passed during construction. @@ -145,258 +164,324 @@ can_data = [b for b in message.data] channel_id = message.arbitration_id - packet_length = can_data[3] + message_length = can_data[3] - # We decide what to do with it + # if we are building a long message, then proceed to push it to the channel dictionary + if channel_id in self.__longMsgChannelIDSet: - if can_data[0] == self.START_BYTE and packet_length <= 4: # This is a short packet + self.__dialinMessage = self.__longMessageBuilders[channel_id].push(can_data) - self.__dialityPacket = can_data # deliver the packet + elif can_data[0] == self.START_BYTE and message_length <= 4: # This is a short packet + # This is the first time that we are building a message - elif can_data[0] == self.START_BYTE and packet_length > 4: # This is the start of a long packet + self.__dialinMessage = can_data # deliver the packet - if channel_id not in self.__longPacketsBuilders.keys(): # if we don't have a builder. Create it! + elif can_data[0] == self.START_BYTE and message_length > 4: # This is the start of a long packet - self.__longPacketsBuilders[channel_id] = LongDialityPacketBuilder(can_data) - self.__dialityPacket = None + # We are starting to build a long message, include it in the lonMsgChannelIDSet + self.__longMsgChannelIDSet.add(channel_id) - else: #if we do have a builder. This is the first time + if channel_id not in self.__longMessageBuilders.keys(): # if we don't have a builder. Create it! - self.__dialityPacket = self.__longPacketsBuilders[channel_id].push(can_data, first_packet=True) + self.__longMessageBuilders[channel_id] = LongDialityMessageBuilder(can_data) + self.__dialinMessage = None - else: # this is the continuation of a long message + else: # if we do have a builder. This is the first time - if channel_id in self.__longPacketsBuilders.keys(): - self.__dialityPacket = self.__longPacketsBuilders[channel_id].push(can_data) + self.__dialinMessage = self.__longMessageBuilders[channel_id].push(can_data, first_packet=True) # At this point we have a complete (long or short) Diality Packet - if self.__dialityPacket is not None: + if self.__dialinMessage is not None: - dialityPacketRequestID = DialityPacket.getRequestID(self.__dialityPacket) - self.__dialityPacket[0] = channel_id + completeDialinMessage = DialinMessage.buildBasicMessage(channel_id=channel_id, + message=self.__dialinMessage) + dialin_msg_id = DialinMessage.getMessageID(completeDialinMessage) + dialin_ch_id = DialinMessage.getChannelID(completeDialinMessage) + if dialin_ch_id in self.__longMsgChannelIDSet: + # We need to remove channel ID from the long message set + self.__longMsgChannelIDSet.remove(dialin_ch_id) + # We first check if this is a response to a send request that is pending - if dialityPacketRequestID == self.__sendPacketRequestID: + if dialin_msg_id == self.__sendPacketRequestID: - self.__dialityResponsePacket = self.__dialityPacket + self.__dialinCommandResponseMessage = completeDialinMessage self.__sendEvent.set() self.__sendPacketRequestID = -1 - # If it is not, this is a sync packet and we need to call it's register function + # If it is not, this is a publication message and we need to call it's register function - elif channel_id in self.__sync_response_dictionary.keys() and \ - dialityPacketRequestID in self.__sync_response_dictionary[channel_id].keys(): + elif dialin_ch_id in self.__sync_response_dictionary.keys() and \ + dialin_msg_id in self.__sync_response_dictionary[channel_id].keys(): - self.__sync_response_dictionary[channel_id][dialityPacketRequestID](self.__dialityPacket) + self.__sync_response_dictionary[dialin_ch_id][dialin_msg_id](completeDialinMessage) - # Done with this packet, let's get the next one + # Done with this message, let's get the next one - self.__dialityPacket = None + self.__dialinMessage = None else: # We have received nothing, let's sleep 1 msec and let's check again sleep(0.001) - def registerSyncFunction(self, channel_id, request_id, function): + def registerReceivingPublicationFunction(self, channel_id, message_id, function): """ assign a function with packet parameter to an sync request id, e.g., def function(packet). :param channel_id: can channel number where messages are received - :param request_id: Diality request ID in message + :param message_id: Diality request ID in message :param function: function reference """ # if the channel_id exist, we just update the dictionary for the channel_id if channel_id in self.__sync_response_dictionary.keys(): - self.__sync_response_dictionary[channel_id].update({request_id: function}) + self.__sync_response_dictionary[channel_id].update({message_id: function}) # otherwise, we need to create the dictionary for the channel_id else: - self.__sync_response_dictionary[channel_id] = {request_id: function} + self.__sync_response_dictionary[channel_id] = {message_id: function} - def send(self, channel_id, can_packet, time_out=1): + def send(self, built_message, time_out=1): """ sends can_packet to channel_id. - :param channel_id: CAN channel ID - :param can_packet: list of integers with the Diality format + :param built_message: message built using DialinMessage class :param time_out: time it will wait for a response in seconds :return: Diality Packet, it it times out it returns None """ - padded_can_packet = DialityPacket.padPacketWithZeros(can_packet) + channel_id = DialinMessage.getChannelID(built_message) - padded_can_packet_length = padded_can_packet[3] + padded_can_message_array = built_message['message'] - self.__sendPacketRequestID = DialityPacket.getRequestID(can_packet) + padded_can_message_length = padded_can_message_array[3] - # A packet can be longer than 8 bytes, so we need to split it - # into 8 bytes messages. + self.__sendPacketRequestID = DialinMessage.getMessageID(built_message) - number_of_messages = math.ceil((padded_can_packet_length + 5) / 8) + # A message can be longer than 8 bytes, so we need to split it + # into 8 bytes packets. + number_of_packets = math.ceil((padded_can_message_length + 5) / 8) + # We are sending one message at a time on CAN - for n in range(number_of_messages): - message = padded_can_packet[n * 8:n * 8 + 8] + for n in range(number_of_packets): + packet = padded_can_message_array[n * 8:n * 8 + 8] - # Sending one message at a time - msg = can.Message(arbitration_id=channel_id, - data=message, - is_extended_id=False) + # Sending one packet at a time + pckt = can.Message(arbitration_id=channel_id, + data=packet, + is_extended_id=False) - self.__canConnection.send(msg) + self.__canConnection.send(pckt) # Sending - self.__dialityResponsePacket = None + self.__dialinCommandResponseMessage = None # After all message has been sent, we clear a flag self.__sendEvent.clear() # At this point, we sleep until the system times out or flag is set - didTimeOut = not self.__sendEvent.wait(time_out) + self.__sendEvent.wait(time_out) # We are ready to send again. Reset request ID appropriately self.__sendPacketRequestID = -1 # This value is None or it has a message depending of the listener - return self.__dialityResponsePacket + return self.__dialinCommandResponseMessage -class DialityPacket: - +class DialinMessage: BYTE_ORDER = 'little' @staticmethod - def buildPacket(request_id=0, cargo=[]): + def buildBasicMessage(channel_id=0, message=None): """ + build a message using channel_id and dialin message + :param channel_id: integer with channel id + :param message: array of int with message + :return: dictionary with channel_id and message keys + """ + if message is None: + message = [] + return {'channel_id': channel_id, 'message': message} + + @staticmethod + def buildMessage(channel_id=0, message_id=0, payload=None): + """ buildPacket builds a Diality Packet - :param request_id: is an integer indicating request ID - :param cargo: list with cargo. It does not include length + :param channel_id: is an integer with channel ID + :param message_id: is an integer indicating request ID + :param payload: list with payload. It does not include length + :return dictionary with channel_id and 8-byte padded message """ - packet = [DialityCanMessenger.START_BYTE] + if payload is None: + payload = [] + message = [DialinCanMessenger.START_BYTE] - if 0 <= request_id <= (2 ** 16 - 1): + if 0 <= message_id <= (2 ** 16 - 1): # Make sure an int was passed - request_id_in_bytes = request_id.to_bytes(2, byteorder=DialityPacket.BYTE_ORDER) + message_id_in_bytes = message_id.to_bytes(2, byteorder=DialinMessage.BYTE_ORDER) - packet += [request_id_in_bytes[0]] - packet += [request_id_in_bytes[1]] + message += [message_id_in_bytes[0]] + message += [message_id_in_bytes[1]] else: return [] - # Check cargo length - cargo_length = len(cargo) + # Check payload length + payload_length = len(payload) - # if cargo is larger than 255 return nothing - if cargo_length <= 255: - # cargo has to be a list - packet += [cargo_length] + # if payload is larger than 255 return nothing + if payload_length <= 255: + # payload has to be a list + message += [payload_length] else: return [] - packet += cargo + message += payload - return DialityPacket.padPacketWithZeros(packet) + message = DialinMessage.__padMessageWithZeros(message) + return DialinMessage.buildBasicMessage(channel_id=channel_id, message=message) + @staticmethod - def padPacketWithZeros(packet): + def __padMessageWithZeros(message): """ returns a packet padded with zeros that guarantees that the packet is a multiple of 8 bytes. - :param packet: packet that may or may not be multiple of 8 bytes + :param message: packet that may or may not be multiple of 8 bytes :return: packet that is 8-byte multiple """ - packet_length = len(packet) + message_length = len(message) # message must be multiple of 8 - if packet_length % 8 != 0: + if message_length % 8 != 0: # We need to pad the message with trailing zeros - add_these_many_zeros = math.ceil(packet_length / 8) * 8 - packet_length + add_these_many_zeros = math.ceil(message_length / 8) * 8 - message_length - packet += [0] * add_these_many_zeros + message += [0] * add_these_many_zeros - return packet + return message @staticmethod - def getRequestID(packet): + def getChannelID(message): """ + returns request ID from message + + :param message: dictionary with channel_id and message keys + :return: integer with channel id + + """ + + return message['channel_id'] + + @staticmethod + def getMessageID(message): + """ returns request ID from packet - :param packet: complete Diality Packet + :param message: complete Diality Packet :return: integer with request ID """ + msg_id_array = message['message'][1:3] - return int.from_bytes(packet[1:3], byteorder=DialityPacket.BYTE_ORDER) + return int.from_bytes(msg_id_array, byteorder=DialinMessage.BYTE_ORDER) + @staticmethod + def getPayloadLength(message): + """ + returns payload length from message + :param message: dictionary with channel_id and message keys + :return: a unsigned payload length + """ -def test_print_received_packet(packet, sync=False): - channel_id = packet[0] - packet[0] = 0xA5 + return message['message'][4] + @staticmethod + def getPayload(message): + """ + returns payload array from message + :param message: dictionary with channel_id and message keys + :return: a payload array if exist + """ + + payload_length = DialinMessage.getPayloadLength(message) + + if payload_length == 0: + return None + else: + return message['message'][5:] + + +def test_print_received_packet(messsage, sync=False): + channel_id = messsage[0] + messsage[0] = 0xA5 + introduction = "Received: " if sync: introduction = "Sync " + introduction - print(introduction, packet, " in channel: ", channel_id) + print(introduction, messsage, " in channel: ", channel_id) -def test_print_to_screen(packet): - if packet is None: +def test_print_to_screen(message): + if message is None: print("Timeout!!!") else: - test_print_received_packet(packet) + test_print_received_packet(message) -def test_function_for_sync(packet): - test_print_received_packet(packet, sync=True) +def test_function_for_sync(message): + test_print_received_packet(message, sync=True) -def test_print_sending_dg_board(channel_id, packet): - print("Sending to board: ", packet, " in channel: ", channel_id) +def test_print_sending_dg_board(channel_id, message): + print("Sending to board: ", message, " in channel: ", channel_id) -def test_print_sending_dg_sim(channel_id, packet): - print("Sending to DG simulator: ", packet, " in channel", channel_id, end=" ---> ") +def test_print_sending_dg_sim(channel_id, messsage): + print("Sending to DG simulator: ", messsage, " in channel", channel_id, end=" ---> ") if __name__ == "__main__": - test_messenger = DialityCanMessenger() - test_channel_id = 0x100 + test_messenger = DialinCanMessenger() + test_channel_id = DialinMessage.ui_to_hd_ch_id - test_received_channel_id = 0x20 - test_received_request_id = 0x100 + test_received_channel_id = DialinMessage.hd_to_ui_ch_id + test_received_message_id = 0x100 - test_messenger.registerSyncFunction(test_received_channel_id, test_received_request_id, test_function_for_sync) + test_messenger.registerReceivingPublicationFunction(test_received_channel_id, test_received_message_id, + test_function_for_sync) - test_dg_simulator_received_channel_id = 0x01 - test_dg_simulator_sync_req_id = 0x05 - test_dg_simulator_req_id = 0x03 + test_dg_simulator_received_channel_id = DialinMessage.dialin_to_dg_ch_id + test_dg_simulator_sync_msg_id = 0x05 + test_dg_simulator_msg_id = 0x03 - test_messenger.registerSyncFunction(test_dg_simulator_received_channel_id, test_dg_simulator_sync_req_id, - test_function_for_sync) + test_messenger.registerReceivingPublicationFunction(test_dg_simulator_received_channel_id, + test_dg_simulator_sync_msg_id, + test_function_for_sync) test_messenger.start() - #test_packet = DialityPacket.buildPacket(0x01, [1]) - test_packet = DialityPacket.buildPacket(1000, [1]) - test_dg_packet = DialityPacket.buildPacket(test_dg_simulator_req_id, []) + # test_packet = DialityPacket.buildPacket(0x01, [1]) + test_packet = DialinMessage.buildMessage(channel_id=1000, message_id=0x01, payload=[1]) + test_dg_packet = DialinMessage.buildMessage(test_dg_simulator_msg_id, []) sleep(3.0) test_print_sending_dg_board(test_channel_id, test_packet) Index: DialysateGenerator.py =================================================================== diff -u -rdcef300220f44f1bdc68e35dcee7bba1fc6e2a08 -rf2b88894a458d9e03a9cb005af02ef16fd5e6f32 --- DialysateGenerator.py (.../DialysateGenerator.py) (revision dcef300220f44f1bdc68e35dcee7bba1fc6e2a08) +++ DialysateGenerator.py (.../DialysateGenerator.py) (revision f2b88894a458d9e03a9cb005af02ef16fd5e6f32) @@ -14,24 +14,27 @@ # ############################################################################ -from DialityCoreCanProtocol import DialityCanMessenger -from DialityCoreCanProtocol import DialityPacket +from DialityCoreCanProtocol import * from time import sleep - -""" \mainpage Dialin API +""" :mainpage Dialin API Dialin API is comprised primarily by 3 classes: - - \ref DialysateGenerator.DG - - \ref HemodialysisDevice.HD + - :ref DialysateGenerator.DG + - :ref HemodialysisDevice.HD """ + +def PublicationReceiverHandler(message): + print(".", end='', flush=True) + + class DG: """ - \class DG + :class DG - \brief Dialysate Generator (DG) Dialin object API. It provides the basic interface to communicate with + Dialysate Generator (DG) Dialin object API. It provides the basic interface to communicate with the DG board """ @@ -40,71 +43,60 @@ """ DG constructor using can bus - \param bus: can bus, e.g. "can0" + :param can__interface: can bus, e.g. "can0" - \returns DG object that allows communication with board via port + :returns DG object that allows communication with board via port - \details For example: + :details For example: dg_object = DG(can__interface='can0') or dg_object = DG('can0') """ # Create listener - self.__can_interface = DialityCanMessenger(can_interface=can__interface) + self.__can_interface = DialinCanMessenger(can_interface=can__interface) + self.__can_interface.registerReceivingPublicationFunction(channel_id=DialinChannels.dg_sync_broadcast_ch_id, + message_id=0x7100, + function=PublicationReceiverHandler) self.__can_interface.start() - def fill(self, startOrStop='start'): + def fill(self, start_or_stop='start'): """ - \brief request the DG board to fill + request the DG board to fill - \returns True if ran the command, False otherwise + :returns True if ran the command, False otherwise, returns None if timeout """ - channel_id = 0x100 - msgID = 1000 + payload = [1] if start_or_stop == 'start' else [0] - if startOrStop == 'start': - cargo=[1] - else: - cargo=[0] + msg = DialinMessage.buildMessage(channel_id=DialinChannels.hd_to_dg_ch_id, + message_id=0x7000, + payload=payload) - packet = DialityPacket.buildPacket(request_id=msgID, cargo=cargo) - - # Send message - received_packet = self.__can_interface.send(channel_id, packet) + received_msg = self.__can_interface.send(msg) + returnValue = None - if received_packet is not None: + if received_msg is not None: + returnValue = True if DialinMessage.getPayload(received_msg)[0] == 1 else False - return received_packet[4] - else: - return False + return returnValue - def registerSyncReceiver(self, channel_id, request_id, method): - self.__can_interface.registerSyncFunction(channel_id, request_id, method) - -def test_sync_function(packet): - print("s", end="", flush=True) - - -def test_fill_print(packet): - - if packet is not False: - print("f") +def test_fill_print(msg): + if msg is not None: + print("f", end='', flush=True) else: - print("t") + print("t", end='', flush=True) if __name__ == "__main__": - test_dg = DG() sleep(2) test_packet = test_dg.fill('start') test_fill_print(test_packet) - sleep(20) + sleep(2) test_packet = test_dg.fill('stop') test_fill_print(test_packet) Index: HD_TestScript.py =================================================================== diff -u -r227fad421dde9339458aa8e5826be4807599038a -rf2b88894a458d9e03a9cb005af02ef16fd5e6f32 --- HD_TestScript.py (.../HD_TestScript.py) (revision 227fad421dde9339458aa8e5826be4807599038a) +++ HD_TestScript.py (.../HD_TestScript.py) (revision f2b88894a458d9e03a9cb005af02ef16fd5e6f32) @@ -14,8 +14,8 @@ # ############################################################################ -from DialityCoreCanProtocol import DialityCanMessenger -from DialityCoreCanProtocol import DialityPacket +from DialityCoreCanProtocol import DialinCanMessenger +from DialityCoreCanProtocol import DialinMessage from HemodialysisDevice import HD from time import sleep Index: HemodialysisDevice.py =================================================================== diff -u -r227fad421dde9339458aa8e5826be4807599038a -rf2b88894a458d9e03a9cb005af02ef16fd5e6f32 --- HemodialysisDevice.py (.../HemodialysisDevice.py) (revision 227fad421dde9339458aa8e5826be4807599038a) +++ HemodialysisDevice.py (.../HemodialysisDevice.py) (revision f2b88894a458d9e03a9cb005af02ef16fd5e6f32) @@ -14,8 +14,8 @@ # ############################################################################ -from DialityCoreCanProtocol import DialityCanMessenger -from DialityCoreCanProtocol import DialityPacket +from DialityCoreCanProtocol import DialinCanMessenger +from DialityCoreCanProtocol import DialinMessage from time import sleep from binascii import unhexlify import struct @@ -43,7 +43,7 @@ hd_object = HD('can0') """ # Create listener - self.can_interface = DialityCanMessenger(can_interface=can__interface) + self.can_interface = DialinCanMessenger(can_interface=can__interface) self.can_interface.start() # Create command groups self._Basics = HD.HD__Basics(self) @@ -86,7 +86,7 @@ request_id = 0x8000 cargo = b'123' - message = DialityPacket.buildPacket(request_id=request_id, cargo=cargo) + message = DialinMessage.buildMessage(message_id=request_id, payload=cargo) print("login") @@ -117,7 +117,7 @@ request_id = 0x8001 cargo = msg - message = DialityPacket.buildPacket(request_id=request_id, cargo=cargo) + message = DialinMessage.buildMessage(message_id=request_id, payload=cargo) print("insert HD message") @@ -172,7 +172,7 @@ sta = self.outer_instance.integer2ByteArray(state) cargo = rst + sta - message = DialityPacket.buildPacket(request_id=request_id, cargo=cargo) + message = DialinMessage.buildMessage(message_id=request_id, payload=cargo) print("override off button") @@ -211,7 +211,7 @@ sta = self.outer_instance.integer2ByteArray(state) cargo = rst + sta - message = DialityPacket.buildPacket(request_id=request_id, cargo=cargo) + message = DialinMessage.buildMessage(message_id=request_id, payload=cargo) print("override stop button") @@ -270,7 +270,7 @@ tsk = self.outer_instance.integer2ByteArray(task) cargo = rst + sta + tsk - message = DialityPacket.buildPacket(request_id=request_id, cargo=cargo) + message = DialinMessage.buildMessage(message_id=request_id, payload=cargo) print("override watchdog task check-in state") @@ -327,7 +327,7 @@ alm = self.outer_instance.integer2ByteArray(alarm) cargo = rst + sta + alm - message = DialityPacket.buildPacket(request_id=request_id, cargo=cargo) + message = DialinMessage.buildMessage(message_id=request_id, payload=cargo) print("override alarm state") @@ -368,7 +368,7 @@ alm = self.outer_instance.integer2ByteArray(alarm) cargo = rst + ms + alm - message = DialityPacket.buildPacket(request_id=request_id, cargo=cargo) + message = DialinMessage.buildMessage(message_id=request_id, payload=cargo) print("override alarm time since activated") @@ -416,7 +416,7 @@ pat = self.__integer2ByteArray(pattern) cargo = rst + pat - message = DialityPacket.buildPacket(request_id=request_id, cargo=cargo) + message = DialinMessage.buildMessage(message_id=request_id, payload=cargo) print("override alarm lamp pattern") @@ -465,7 +465,7 @@ if can_interface is not None: channel_id = 0x40 msg_id = 0x0005 - can_interface.registerSyncFunction( channel_id, msg_id, self.handlerBloodFlowSyncFunction) + can_interface.registerReceivingPublicationFunction(channel_id, msg_id, self.handlerBloodFlowSyncFunction) self.TargetBloodFlowRate = 0 self.MeasuredBloodFlowRate = 0.0 @@ -505,7 +505,7 @@ flo = self.outer_instance.integer2ByteArray(flow) cargo = rst + flo - message = DialityPacket.buildPacket(request_id=request_id, cargo=cargo) + message = DialinMessage.buildMessage(message_id=request_id, payload=cargo) print("override blood flow set point") @@ -544,7 +544,7 @@ flo = self.outer_instance.integer2ByteArray(flow) cargo = rst + flo - message = DialityPacket.buildPacket(request_id=request_id, cargo=cargo) + message = DialinMessage.buildMessage(message_id=request_id, payload=cargo) print("override measured blood flow") @@ -587,7 +587,7 @@ spd = self.outer_instance.integer2ByteArray(speed) cargo = rst + spd - message = DialityPacket.buildPacket(request_id=request_id, cargo=cargo) + message = DialinMessage.buildMessage(message_id=request_id, payload=cargo) print("override measured blood pump speed") @@ -626,7 +626,7 @@ cur = self.outer_instance.integer2ByteArray(curr) cargo = rst + cur - message = DialityPacket.buildPacket(request_id=request_id, cargo=cargo) + message = DialinMessage.buildMessage(message_id=request_id, payload=cargo) print("override measured blood pump motor current") @@ -665,7 +665,7 @@ mis = self.outer_instance.integer2ByteArray(ms) cargo = rst + mis - message = DialityPacket.buildPacket(request_id=request_id, cargo=cargo) + message = DialinMessage.buildMessage(message_id=request_id, payload=cargo) print("override blood flow broadcast interval") Index: Miscellaneous/DG_Firmware_Simulator.py =================================================================== diff -u -raf4e78cc8f334d92a29ce7aa2b89c15a2cca8064 -rf2b88894a458d9e03a9cb005af02ef16fd5e6f32 --- Miscellaneous/DG_Firmware_Simulator.py (.../DG_Firmware_Simulator.py) (revision af4e78cc8f334d92a29ce7aa2b89c15a2cca8064) +++ Miscellaneous/DG_Firmware_Simulator.py (.../DG_Firmware_Simulator.py) (revision f2b88894a458d9e03a9cb005af02ef16fd5e6f32) @@ -1,49 +1,39 @@ -from DialityCoreCanProtocol import DialityCanMessenger -from DialityCoreCanProtocol import DialityPacket +from DialityCoreCanProtocol import * from time import sleep +dialin_messenger = DialinCanMessenger() - - -diality_messenger = DialityCanMessenger() - - # Building response message -response_req_id = 0x03 -response_packet = DialityPacket.buildPacket(response_req_id, [1, 2]) -# Building Sync response message -sync_req_id = 0x05 -sync_packet = DialityPacket.buildPacket(sync_req_id, [0x06, 0x02]) +response_msg = DialinMessage.buildMessage(channel_id=DialinChannels.dg_to_hd_ch_id, + message_id=0x7000, + payload=[1]) -# Building Sync message -sync_req_id = 0x05 -sync_packet_2 = DialityPacket.buildPacket(sync_req_id, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) +# Building Publication message +publication_msg = DialinMessage.buildMessage(channel_id=DialinChannels.dg_sync_broadcast_ch_id, + message_id=0x7100, + payload=[1, 2, 3, 4, 5]) - -channel_id = 0x01 - print("") -print("o -> response") -print(". -> Sync") +print("o -> response to fill command") +print(". -> publication message") print("") -def respondToCommand(packet): - - diality_messenger.send(channel_id, response_packet) +def respondToCommand(message): + dialin_messenger.send(response_msg) print("o", end='', flush=True) # Register response command for the DG -diality_messenger.registerSyncFunction(channel_id, response_req_id, respondToCommand) -diality_messenger.start() +dialin_messenger.registerReceivingPublicationFunction(channel_id=DialinChannels.hd_to_dg_ch_id, + message_id=0x7000, + function=respondToCommand) +dialin_messenger.start() # This is the main loop while True: - - diality_messenger.send(channel_id, sync_packet_2) + dialin_messenger.send(publication_msg) print(".", end='', flush=True) - sleep(1)