Index: DialityCoreCanProtocol.py =================================================================== diff -u -rc460fdd776add82105b0688371e2929dcbaf3d57 -rf1a95e42324e7f6da895039e4863db6af49bf0d2 --- DialityCoreCanProtocol.py (.../DialityCoreCanProtocol.py) (revision c460fdd776add82105b0688371e2929dcbaf3d57) +++ DialityCoreCanProtocol.py (.../DialityCoreCanProtocol.py) (revision f1a95e42324e7f6da895039e4863db6af49bf0d2) @@ -21,29 +21,25 @@ import time from time import sleep import sys +import argparse +import logging class DenaliMessage: - BYTE_ORDER = 'little' + BYTE_ORDER = 'little' START_BYTE = 0xA5 - START_INDEX = 0 MSG_SEQ_INDEX = 1 MSG_ID_INDEX = 3 - PAYLOAD_LENGTH_INDEX = 5 PAYLOAD_START_INDEX = 6 - PAYLOAD_LENGTH_FIRST_PACKET = 1 HEADER_LENGTH = 6 - PACKET_LENGTH = 8 CRC_LENGTH = 1 MAX_MSG_ID_NUMBER = 65535 - MAX_NUMBER_OF_PAYLOAD_BYTES = 254 - CRC_LIST = [ 0, 49, 98, 83, 196, 245, 166, 151, 185, 136, 219, 234, 125, 76, 31, 46, 67, 114, 33, 16, 135, 182, 229, 212, 250, 203, 152, 169, 62, 15, 92, 109, @@ -64,19 +60,20 @@ ] @staticmethod - def buildBasicMessage(channel_id=0, message=None): + def build_basic_message(channel_id=0, message=None): """ - build a message using channel_id and dialin message + Builds a basic message dictionary containing the channel id and message + \param channel_id: integer with channel id - \param message: array of int with message + \param message: an array of ints forming the 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): + def build_message(channel_id=0, message_id=0, payload=None): """ buildPacket builds a Diality Packet @@ -125,15 +122,15 @@ # Because CRC does not include first byte, then we pass a list with out it message_list += [DenaliMessage.crc8(message_list[1:])] - message_list = DenaliMessage.__padMessageWithZeros(message_list) + message_list = DenaliMessage.pad_message_with_zeros(message_list) - return DenaliMessage.buildBasicMessage(channel_id=channel_id, message=message_list) + return DenaliMessage.build_basic_message(channel_id=channel_id, message=message_list) - @staticmethod def crc8(message_list): """ - returns the calculated crc from a message list + Returns the calculated crc from a message list + \param message_list: is a list of integer numbers containing the message \return: integer containing a unsigned byte """ @@ -145,11 +142,11 @@ return crc @staticmethod - def __padMessageWithZeros(message): + def pad_message_with_zeros(message): """ - returns a packet padded with zeros that guarantees that the packet is a multiple of 8 bytes. - \param message: packet that may or may not be multiple of 8 bytes + Returns a packet padded with zeros that guarantees that the packet is a multiple of 8 bytes. + \param message: packet that may or may not be multiple of 8 bytes \return: packet that is 8-byte multiple """ @@ -166,23 +163,23 @@ return message @staticmethod - def getCRC(message): + def get_crc(message): """ - gets the CRC in message + Gets the CRC in message \param message: Dialin complete message with CRC \return: CRC in message """ - crc_index = DenaliMessage.PAYLOAD_START_INDEX + DenaliMessage.getPayloadLength(message) + crc_index = DenaliMessage.PAYLOAD_START_INDEX + DenaliMessage.get_payload_length(message) return message['message'][crc_index] @staticmethod - def verifyCRC(message): + def verify_crc(message): """ - verifies message CRC equals calculated message CRC + Verifies message CRC equals calculated message CRC \return: TRUE if CRC matches, FALSE otherwise """ @@ -192,16 +189,16 @@ else: message_list = message['message'] - message_length = DenaliMessage.PAYLOAD_START_INDEX + DenaliMessage.getPayloadLength(message) + message_length = DenaliMessage.PAYLOAD_START_INDEX + DenaliMessage.get_payload_length(message) calculated_crc = DenaliMessage.crc8(message_list[1:message_length]) - actual_crc = DenaliMessage.getCRC(message) + actual_crc = DenaliMessage.get_crc(message) return calculated_crc == actual_crc @staticmethod - def getChannelID(message): + def get_channel_id(message): """ - returns request ID from message + Returns request ID from message \param message: dictionary with channel_id and message keys \return: integer with channel id @@ -211,9 +208,9 @@ return message['channel_id'] @staticmethod - def getMessageID(message): + def get_message_id(message): """ - returns request ID from packet + Returns request ID from packet \param message: complete Diality Packet @@ -226,46 +223,49 @@ return int.from_bytes(msg_id_array, byteorder=DenaliMessage.BYTE_ORDER) @staticmethod - def getPayloadLength(message): + def get_payload_length(message): """ - returns payload length from message + Returns payload length from message + \param message: dictionary with channel_id and message keys \return: a unsigned payload length """ return message['message'][DenaliMessage.PAYLOAD_LENGTH_INDEX] @staticmethod - def getPayload(message): + def get_payload(message): """ - returns payload array from message + Returns payload array from message + \param message: dictionary with channel_id and message keys \return: a payload array if exist """ - payload_length = DenaliMessage.getPayloadLength(message) + payload_length = DenaliMessage.get_payload_length(message) if payload_length == 0: return None else: return message['message'][DenaliMessage.PAYLOAD_START_INDEX:] @staticmethod - def getTotalPackets(message, is_array=True): + def get_total_packets(message, is_array=True): """ - returns the number of packets needed to transmit Denali Message + Returns the number of packets needed to transmit Denali Message + \param message: dictionary with channel_id and message keys or raw message \param is_array: True if message is an array and not a dictionary \return: number of packets """ the_message = message if is_array else message['message'] return math.ceil((the_message[DenaliMessage.PAYLOAD_LENGTH_INDEX] + - DenaliMessage.HEADER_LENGTH + DenaliMessage.CRC_LENGTH) / + DenaliMessage.HEADER_LENGTH + DenaliMessage.CRC_LENGTH) / DenaliMessage.PACKET_LENGTH) class DenaliChannels: - # This are all the channels available + # All the available channels hd_alarm_broadcast_ch_id = 0x001 dg_alarm_broadcast_ch_id = 0x002 @@ -305,9 +305,9 @@ \returns object """ - self.__message = can_message - self.__number_of_can_packets_needed = DenaliMessage.getTotalPackets(can_message) - self.__number_of_can_packets_up_to_now = 1 + self.message = can_message + self.number_of_can_packets_needed = DenaliMessage.get_total_packets(can_message) + self.number_of_can_packets_up_to_now = 1 def push(self, can_message, first_packet=False): """ @@ -320,17 +320,17 @@ \return: None if the packet is not completed, otherwise returns the complete packet """ if first_packet: - self.__message = can_message - self.__number_of_can_packets_needed = DenaliMessage.getTotalPackets(can_message) - self.__number_of_can_packets_up_to_now = 1 + self.message = can_message + self.number_of_can_packets_needed = DenaliMessage.get_total_packets(can_message) + self.number_of_can_packets_up_to_now = 1 else: - self.__message += can_message - self.__number_of_can_packets_up_to_now += 1 + self.message += can_message + self.number_of_can_packets_up_to_now += 1 - if self.__number_of_can_packets_up_to_now == self.__number_of_can_packets_needed: - return_message = self.__message - self.__message = None + if self.number_of_can_packets_up_to_now == self.number_of_can_packets_needed: + return_message = self.message + self.message = None return return_message else: @@ -339,9 +339,9 @@ class DenaliCanMessenger: START_BYTE = DenaliMessage.START_BYTE - DIALIN_MSG_RESP_TO = 0.1 # number of seconds to wait for a response to a sent command + DIALIN_MSG_RESP_TO = 0.1 # number of seconds to wait for a response to a sent command - def __init__(self, can_interface='can0'): + def __init__(self, can_interface='can0', log_level="debug"): """ DenaliCanMessenger constructor @@ -350,63 +350,71 @@ \returns DialityCanMessenger object """ - self.__bus = can.interfaces.socketcan.SocketcanBus(channel=can_interface) - self.__listener_buffer = can.BufferedReader() - self.__notifier = can.Notifier(self.__bus, [self.__listener_buffer]) + self.bus = can.interfaces.socketcan.SocketcanBus(channel=can_interface) + self.listener_buffer = can.BufferedReader() + self.notifier = can.Notifier(self.bus, [self.listener_buffer]) - self.__sendPacketRequestID = -1 - self.__sendEvent = threading.Event() + self.send_packet_request_id = -1 + self.send_event = threading.Event() - self.__longMessageBuilders = {} - self.__longMsgChannelIDSet = set() + self.long_message_builders = {} + self.long_msg_channel_id_set = set() - self.__dialinMessageList = None - self.__lastSentMessage = None - self.__dialinCommandResponseMessage = None - self.__dialinResponseChannelID = -1 + self.messages = None + self.last_sent_message = None + self.command_response_message = None + self.response_channel_id = -1 - self.__run = False + self.run = False - self.__sync_response_dictionary = {} + self.sync_response_dictionary = {} + numeric_level = getattr(logging, log_level.upper(), None) + logging.basicConfig(format='%(asctime)s,%(msecs)d %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s', + filename="DialIn.log", + datefmt='%m-%d-%Y:%H:%M:%S', + level=numeric_level) # DEBUG, INFO, WARNING, ERROR, CRITICAL - if self.__bus is not None: - self.__serialListenerThread = threading.Thread(target=self.__listener, daemon=True) + if self.bus is not None: + self.serial_listener_thread = threading.Thread(target=self.listener, daemon=True) else: - self.__serialListenerThread = None - print("Can connection is not valid") + self.serial_listener_thread = None + print_and_log("Can connection is not valid") def start(self): """ starts listening to the can interface. """ - if self.__bus is None: - print("Cannot start can listener.") + if self.bus is None: + print_and_log("Cannot start can listener.") return else: - self.__run = True - self.__serialListenerThread.start() - print("Can listener has started.") + self.run = True + if self.serial_listener_thread is not None: + self.serial_listener_thread.start() + print_and_log("Can listener has started.") + else: + print_and_log("Cannot start listener...") def stop(self): """ - stop listening the can interface + Stop listening the can interface """ - self.__run = False - print("\nCan listener has stopped.") + self.run = False + print_and_log("\nCan listener has stopped.") - def __listener(self): + def listener(self): """ - listens for diality message on the can interface passed during construction. - + Listens for diality message on the can interface passed during construction. """ - while self.__run: + while self.run: - message = self.__listener_buffer.get_message(0.0) + message = self.listener_buffer.get_message(0.0) + print_and_log("Message = {}".format(message)) if message is not None: @@ -416,76 +424,76 @@ channel_id = message.arbitration_id message_length = can_data[DenaliMessage.PAYLOAD_LENGTH_INDEX] - # TEST CODE - REMOVE - #print(str(time.time())+" " + str(channel_id) + " " + str(can_data)) + print_and_log(str(time.time()) + " " + str(channel_id) + " " + str(can_data), log_level="info") # if we are building a long message, then proceed to push it to the channel dictionary - if channel_id in self.__longMsgChannelIDSet: - self.__dialinMessageList = self.__longMessageBuilders[channel_id].push(can_data) + if channel_id in self.long_msg_channel_id_set: + self.messages = self.long_message_builders[channel_id].push(can_data) elif can_data[0] == DenaliMessage.START_BYTE and \ message_length <= DenaliMessage.PAYLOAD_LENGTH_FIRST_PACKET: # This is a short packet # This is the first time that we are building a message - self.__dialinMessageList = can_data # deliver the packet + self.messages = can_data # deliver the packet elif can_data[0] == self.START_BYTE and \ message_length > DenaliMessage.PAYLOAD_LENGTH_FIRST_PACKET: # Long packet start # We are starting to build a long message, include it in the lonMsgChannelIDSet - self.__longMsgChannelIDSet.add(channel_id) + self.long_msg_channel_id_set.add(channel_id) - if channel_id not in self.__longMessageBuilders.keys(): # if we don't have a builder. Create it! - self.__longMessageBuilders[channel_id] = LongDenaliMessageBuilder(can_data) - self.__dialinMessageList = None + if channel_id not in self.long_message_builders.keys(): # if we don't have a builder. Create it! + self.long_message_builders[channel_id] = LongDenaliMessageBuilder(can_data) + self.messages = None else: # if we do have a builder. This is the first time -# self.__dialinMessageList = self.__longMessageBuilders[channel_id].push(can_data, first_packet=True) - self.__longMessageBuilders[channel_id].push(can_data, first_packet=True) - self.__dialinMessageList = None + # self.messages = self.long_message_builders[channel_id].push(can_data, first_packet=True) + self.long_message_builders[channel_id].push(can_data, first_packet=True) + self.messages = None # Do we have a complete (long or short) Denali Message? - if self.__dialinMessageList is not None: - message_valid = True #assume true for now, set to false if CRC check fails below - complete_dialin_message = DenaliMessage.buildBasicMessage(channel_id=channel_id, - message=self.__dialinMessageList) - dialin_msg_id = DenaliMessage.getMessageID(complete_dialin_message) - dialin_ch_id = DenaliMessage.getChannelID(complete_dialin_message) + if self.messages is not None: + message_valid = True # assume true for now, set to false if CRC check fails below + complete_dialin_message = DenaliMessage.build_basic_message(channel_id=channel_id, + message=self.messages) + dialin_msg_id = DenaliMessage.get_message_id(complete_dialin_message) + dialin_ch_id = DenaliMessage.get_channel_id(complete_dialin_message) - if dialin_ch_id in self.__longMsgChannelIDSet: + if dialin_ch_id in self.long_msg_channel_id_set: # We need to remove channel ID from the long message set - self.__longMsgChannelIDSet.remove(dialin_ch_id) + self.long_msg_channel_id_set.remove(dialin_ch_id) # Need to verify CRC at this point - if DenaliMessage.verifyCRC(complete_dialin_message) is False: + if DenaliMessage.verify_crc(complete_dialin_message) is False: # if verify is False, let's drop (ignore) this message message_valid = False dialin_ch_id = None dialin_msg_id = None - sys.stderr.write("Incorrect CRC, received message: {}, crc: {}, calculated crc: {}\n".format( - self.__dialinMessageList, DenaliMessage.getCRC(complete_dialin_message), - DenaliMessage.crc8(self.__dialinMessageList))) + sys.stderr.write( + "Incorrect CRC, received message: {}, crc: {}, calculated crc: {}\n".format( + self.messages, DenaliMessage.get_crc(complete_dialin_message), + DenaliMessage.crc8(self.messages))) if message_valid == True: # We first check if this is a response to a send request that is pending - if dialin_msg_id == self.__sendPacketRequestID: + if dialin_msg_id == self.send_packet_request_id: - self.__dialinCommandResponseMessage = complete_dialin_message - self.__sendEvent.set() - self.__sendPacketRequestID = -1 + self.command_response_message = complete_dialin_message + self.send_event.set() + self.send_packet_request_id = -1 # If it is not, this is a publication message and we need to call it's register function - elif dialin_ch_id in self.__sync_response_dictionary.keys() and \ - dialin_msg_id 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[dialin_ch_id][dialin_msg_id](complete_dialin_message) + self.sync_response_dictionary[dialin_ch_id][dialin_msg_id](complete_dialin_message) # Done with this message, let's get the next one - self.__dialinMessageList = None + self.messages = None - else: #no new packets in receive buffer + else: # no new packets in receive buffer # We have received nothing, let's sleep 1 msec and let's check again sleep(0.01) - def registerReceivingPublicationFunction(self, channel_id, message_id, function): + def register_receiving_publication_function(self, channel_id, message_id, function): """ assign a function with packet parameter to an sync request id, e.g., def function(packet). @@ -496,12 +504,12 @@ """ # 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({message_id: function}) + if channel_id in self.sync_response_dictionary.keys(): + 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] = {message_id: function} + self.sync_response_dictionary[channel_id] = {message_id: function} def send(self, built_message, time_out=DIALIN_MSG_RESP_TO): """ @@ -517,21 +525,20 @@ # keep trying to send message until we get a response while msg_sent is not True: - self.__lastSentMessage = built_message + self.last_sent_message = built_message - channel_id = DenaliMessage.getChannelID(built_message) + channel_id = DenaliMessage.get_channel_id(built_message) padded_can_message_array = built_message['message'] - self.__sendPacketRequestID = DenaliMessage.getMessageID(built_message) + self.send_packet_request_id = DenaliMessage.get_message_id(built_message) # A message can be longer than 8 bytes, so we need to split it # into 8 bytes packets. - number_of_packets = DenaliMessage.getTotalPackets(padded_can_message_array) + number_of_packets = DenaliMessage.get_total_packets(padded_can_message_array) # We are sending one message at a time on CAN - for n in range(number_of_packets): packet = padded_can_message_array[n * DenaliMessage.PACKET_LENGTH: (n + 1) * DenaliMessage.PACKET_LENGTH] @@ -541,34 +548,56 @@ data=packet, is_extended_id=False) - #print(packet) - self.__bus.send(packet, 0) # 0.1) - #sleep(0.01) + self.logger.debug(packet) + # input("Press enter to send...") + self.bus.send(packet, 0) # 0.1) # Sending - self.__dialinCommandResponseMessage = None + self.command_response_message = None # After all message has been sent, we clear a flag - self.__sendEvent.clear() + self.send_event.clear() # At this point, we sleep until the system times out or flag is set - self.__sendEvent.wait(time_out) + self.send_event.wait(time_out) - if self.__dialinCommandResponseMessage is not None: + if self.command_response_message is not None: msg_sent = True elif time_out == 0: msg_sent = True else: - #msg_sent = False - print("No response. Re-sending message.") + # msg_sent = False + print_and_log("No response. Re-sending message.") # We are ready to send again. Reset request ID appropriately - self.__sendPacketRequestID = -1 + self.send_packet_request_id = -1 # This value is None or it has a message depending of the listener - return self.__dialinCommandResponseMessage + return self.command_response_message +def print_and_log(message, log_level="debug"): + """ + Prints and logs a message + + \param message: The message to print and log + \param log_level: The logging level, indicates the severity of the message + + \returns: None + """ + print(message) + if log_level == "debug": + logging.debug(message) + elif log_level == "info": + logging.info(message) + elif log_level == "warning": + logging.warning(message) + elif log_level == "error": + logging.error(message) + elif log_level == "critical": + logging.critical(message) + + def tst_print_received_packet(message, sync=False): channel_id = message[0] message[0] = DenaliMessage.START_BYTE @@ -577,12 +606,12 @@ if sync: introduction = "Sync " + introduction - print(introduction, message, " in channel: ", channel_id) + print_and_log(introduction, message, " in channel: ", channel_id) def tst_print_to_screen(message): if message is None: - print("Timeout!!!") + print_and_log("Timeout!!!") else: tst_print_received_packet(message) @@ -592,39 +621,38 @@ def tst_print_sending_dg_board(message): - print("Sending to board: ", message['message'], " in channel: ", message['channel_id']) + print_and_log("Sending to board: ", message['message'], " in channel: ", message['channel_id']) def tst_print_sending_dg_sim(message): - print("Sending to DG simulator: ", message['message'], " in channel", message['channel_id'], end=" ---> ") + print_and_log("Sending to DG simulator: ", message['message'], " in channel", message['channel_id'], end=" ---> ") -if __name__ == "__main__": - test_messenger = DenaliCanMessenger() - test_channel_id = DenaliChannels.ui_to_hd_ch_id +def tst_dg(log_level): + test_messenger = DenaliCanMessenger(log_level=log_level) test_received_channel_id = DenaliChannels.hd_to_ui_ch_id test_received_message_id = 0x100 - test_messenger.registerReceivingPublicationFunction(test_received_channel_id, test_received_message_id, - tst_function_for_sync) + test_messenger.register_receiving_publication_function(test_received_channel_id, test_received_message_id, + tst_function_for_sync) test_dg_simulator_received_channel_id = DenaliChannels.dialin_to_dg_ch_id test_dg_simulator_sync_msg_id = 0x05 test_dg_simulator_msg_id = 0x03 - test_messenger.registerReceivingPublicationFunction(test_dg_simulator_received_channel_id, - test_dg_simulator_sync_msg_id, - tst_function_for_sync) + test_messenger.register_receiving_publication_function(test_dg_simulator_received_channel_id, + test_dg_simulator_sync_msg_id, + tst_function_for_sync) test_messenger.start() - test_msg = DenaliMessage.buildMessage(channel_id=1000, - message_id=0x01, - payload=[1]) - test_dg_msg = DenaliMessage.buildMessage(channel_id=test_dg_simulator_received_channel_id, - message_id=test_dg_simulator_msg_id, - payload=[]) + test_msg = DenaliMessage.build_message(channel_id=1000, + message_id=0x01, + payload=[1]) + test_dg_msg = DenaliMessage.build_message(channel_id=test_dg_simulator_received_channel_id, + message_id=test_dg_simulator_msg_id, + payload=[]) sleep(3.0) tst_print_sending_dg_board(test_msg) @@ -645,3 +673,21 @@ tst_print_sending_dg_sim(test_dg_msg) test_response = test_messenger.send(test_dg_msg) tst_print_to_screen(test_response) + + +def tst_can(): + test_messenger = DenaliCanMessenger() + test_messenger.start() + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Dial-In Core Can Protocol") + parser.add_argument("--test-dg", action="store_true") + parser.add_argument("--log-level", default="debug") + args = parser.parse_args() + + if args.test_dg: + tst_dg(args.log_level) + + if len(sys.argv) < 2: + parser.print_help() Index: DialysateGenerator.py =================================================================== diff -u -r76a013b309517d69b64ec4b74778715595a046bc -rf1a95e42324e7f6da895039e4863db6af49bf0d2 --- DialysateGenerator.py (.../DialysateGenerator.py) (revision 76a013b309517d69b64ec4b74778715595a046bc) +++ DialysateGenerator.py (.../DialysateGenerator.py) (revision f1a95e42324e7f6da895039e4863db6af49bf0d2) @@ -16,6 +16,7 @@ from DialityCoreCanProtocol import * from time import sleep +import unittest """ \mainpage Dialin API @@ -42,68 +43,68 @@ MSG_ID_LOAD_CELL_B1_OVERRIDE = 0xA007 MSG_ID_LOAD_CELL_B2_OVERRIDE = 0xA008 - def __init__(self, can__interface="can0"): + def __init__(self, can_interface="can0"): """ - DG constructor using can bus + DG constructor using can bus - \param can__interface: string with can bus name, e.g. "can0" + \param can_interface: string with can bus name, 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') - dg_object = DG(can__interface='can0') or - dg_object = DG('can0') """ # Create listener - self.__can_interface = DenaliCanMessenger(can_interface=can__interface) - self.__can_interface.registerReceivingPublicationFunction(channel_id=DenaliChannels.dg_sync_broadcast_ch_id, - message_id=self.DG_MSG_ID_BROADCAST, - function=( + self.can_interface = DenaliCanMessenger(can_interface=can_interface) + self.can_interface.register_receiving_publication_function(channel_id=DenaliChannels.dg_sync_broadcast_ch_id, + message_id=self.DG_MSG_ID_BROADCAST, + function=( lambda message: print(".", end='', flush=True))) - self.__can_interface.start() + self.can_interface.start() def fill(self, start_or_stop='start'): """ - request the DG board to 'start' or to 'stop' fill + Request the DG board to 'start' or to 'stop' fill - \param start_or_stop is a string indicating which action to take, e.g., 'start' or 'stop' + \param start_or_stop is a string indicating which action to take, e.g., 'start' or 'stop' - \returns True if ran the command, False otherwise, returns None if timeout + \returns True if ran the command, False otherwise, returns None if timeout """ payload = [1] if start_or_stop == 'start' else [0] - msg = DenaliMessage.buildMessage(channel_id=DenaliChannels.hd_to_dg_ch_id, - message_id=self.DG_MSG_ID_FILL_COMMAND, - payload=payload) + msg = DenaliMessage.build_message(channel_id=DenaliChannels.hd_to_dg_ch_id, + message_id=self.DG_MSG_ID_FILL_COMMAND, + payload=payload) # Send message - received_msg = self.__can_interface.send(msg) - returnValue = None + received_msg = self.can_interface.send(msg) + return_value = None if received_msg is not None: - returnValue = True if DenaliMessage.getPayload(received_msg)[0] == 1 else False + return_value = True if DenaliMessage.get_payload(received_msg)[0] == 1 else False - return returnValue + return return_value def CmdLoadCellA1Override(self, reset, adc_raw): """ - Constructs and sends the load cell A1 override command + Constructs and sends the load cell A1 override command - \param reset: integer - 1 to reset a previous override, 0 to override - \param adc_raw: unsigned int - raw adc value. 0.0894 per gram. 1000 ml = 11,186 - \returns 1 if successful, zero otherwise + \param reset: integer - 1 to reset a previous override, 0 to override + \param adc_raw: unsigned int - raw adc value. 0.0894 per gram. 1000 ml = 11,186 + \returns 1 if successful, zero otherwise - TODO: This is built based on HD but needs more infrastructure made for DG before being operational + TODO: This is built based on HD but needs more infrastructure made for DG before being operational """ rst = self.outer_instance.integer2ByteArray(reset) cur = self.outer_instance.float2ByteArray(adc_raw) payload = rst + cur - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_LOAD_CELL_A1_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_LOAD_CELL_A1_OVERRIDE, + payload=payload) print("override load cell A1 raw adc value") @@ -128,22 +129,22 @@ def CmdLoadCellA2Override(self, reset, adc_raw): """ - Constructs and sends the load cell A2 override command + Constructs and sends the load cell A2 override command - \param reset: integer - 1 to reset a previous override, 0 to override - \param adc_raw: unsigned int - raw adc value. 0.0894 per gram. 1000 ml = 11,186 - \returns 1 if successful, zero otherwise + \param reset: integer - 1 to reset a previous override, 0 to override + \param adc_raw: unsigned int - raw adc value. 0.0894 per gram. 1000 ml = 11,186 + \returns 1 if successful, zero otherwise - TODO: This is built based on HD but needs more infrastructure made for DG before being operational + TODO: This is built based on HD but needs more infrastructure made for DG before being operational """ rst = self.outer_instance.integer2ByteArray(reset) cur = self.outer_instance.float2ByteArray(adc_raw) payload = rst + cur - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_LOAD_CELL_A2_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_LOAD_CELL_A2_OVERRIDE, + payload=payload) print("override load cell A2 raw adc value") @@ -168,22 +169,22 @@ def CmdLoadCellB1Override(self, reset, adc_raw): """ - Constructs and sends the load cell B1 override command + Constructs and sends the load cell B1 override command - \param reset: integer - 1 to reset a previous override, 0 to override - \param adc_raw: unsigned int - raw adc value. 0.0894 per gram. 1000 ml = 11,186 - \returns 1 if successful, zero otherwise + \param reset: integer - 1 to reset a previous override, 0 to override + \param adc_raw: unsigned int - raw adc value. 0.0894 per gram. 1000 ml = 11,186 + \returns 1 if successful, zero otherwise - TODO: This is built based on HD but needs more infrastructure made for DG before being operational + TODO: This is built based on HD but needs more infrastructure made for DG before being operational """ rst = self.outer_instance.integer2ByteArray(reset) cur = self.outer_instance.float2ByteArray(adc_raw) payload = rst + cur - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_LOAD_CELL_B1_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_LOAD_CELL_B1_OVERRIDE, + payload=payload) print("override load cell B1 raw adc value") @@ -208,22 +209,22 @@ def CmdLoadCellB2Override(self, reset, adc_raw): """ - Constructs and sends the load cell B2 override command + Constructs and sends the load cell B2 override command - \param reset: integer - 1 to reset a previous override, 0 to override - \param adc_raw: unsigned int - raw adc value. 0.0894 per gram. 1000 ml = 11,186 - \returns 1 if successful, zero otherwise + \param reset: integer - 1 to reset a previous override, 0 to override + \param adc_raw: unsigned int - raw adc value. 0.0894 per gram. 1000 ml = 11,186 + \returns 1 if successful, zero otherwise - TODO: This is built based on HD but needs more infrastructure made for DG before being operational + TODO: This is built based on HD but needs more infrastructure made for DG before being operational """ rst = self.outer_instance.integer2ByteArray(reset) cur = self.outer_instance.float2ByteArray(adc_raw) payload = rst + cur - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_LOAD_CELL_B2_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_LOAD_CELL_B2_OVERRIDE, + payload=payload) print("override load cell B2 raw adc value") @@ -246,27 +247,24 @@ return False -def test_dg_start(): - dg = DG() - sleep(2) - resp = dg.fill('start') - test_passed = isinstance(resp, bool) +class Test(unittest.TestCase): - if test_passed: - print("DG started and DG response is {}".format(test_passed)) + # @unittest.skip("Skipping dg_start.") + def test_dg_start(self): + dg = DG() + sleep(2) + success = dg.fill("start") + self.assertTrue(success) - assert test_passed + # @unittest.skip("Skipping dg_start_stop.") + def test_dg_start_stop(self): + dg = DG() + sleep(2) + success = dg.fill("start") + self.assertTrue(success) + sleep(2) + success = dg.fill('stop') + self.assertTrue(success) - -def test_dg_stop(): - dg = DG() - sleep(1) - dg.fill('start') - sleep(2) - resp = dg.fill('stop') - test_passed = isinstance(resp, bool) - - if test_passed: - print("DG started/stopped and DG response is {}".format(test_passed)) - - assert test_passed +if __name__ == '__main__': + unittest.main(verbosity=2) Index: HD_DialOutFlow.py =================================================================== diff -u -re0254e59354475c1e7c95ac4c0ff033a33d98fd7 -rf1a95e42324e7f6da895039e4863db6af49bf0d2 --- HD_DialOutFlow.py (.../HD_DialOutFlow.py) (revision e0254e59354475c1e7c95ac4c0ff033a33d98fd7) +++ HD_DialOutFlow.py (.../HD_DialOutFlow.py) (revision f1a95e42324e7f6da895039e4863db6af49bf0d2) @@ -15,7 +15,7 @@ PAUSE = 2 -class HD_DialOut: +class HDDialOut: """ Encapsulates command for testing dialout flow module. """ @@ -34,14 +34,14 @@ def __init__(self, can_interface): """ - Constructor for the HD_Dialout class + Constructor for the HDDialOut class \param can_interface: reference to DenaliMessenger """ self.__can_interface = can_interface - self.__can_interface.registerReceivingPublicationFunction(channel_id=DenaliChannels.hd_sync_broadcast_ch_id, - message_id=self.MSG_ID_DIALYSATE_UF_DATA, - function=self.receiveDialysateUFDataHandler) + self.__can_interface.register_receiving_publication_function(channel_id=DenaliChannels.hd_sync_broadcast_ch_id, + message_id=self.MSG_ID_DIALYSATE_UF_DATA, + function=self.receiveDialysateUFDataHandler) ## DialOutBroadcast a dictionary storing latest broadcast values of the following keys: # state, target_volume, measured_volume, pwm, motor_current, motor_speed. self.DialOutBroadcast = {'target_volume': 0, @@ -70,15 +70,15 @@ if new_state in self.DIALOUT_STATES: payload = [new_state.value] - msg = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_SET_DIALOUT_FLOW_STATE, - payload=payload) + msg = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_SET_DIALOUT_FLOW_STATE, + payload=payload) received_msg = self.__can_interface.send(msg) else: print("Argument to setUFState method are incorrect", file=sys.stderr) if received_msg is not None: - return_value = True if DenaliMessage.getPayload(received_msg)[0] == 1 else False + return_value = True if DenaliMessage.get_payload(received_msg)[0] == 1 else False return return_value @@ -100,16 +100,16 @@ payload += list(rx_time_min.to_bytes(2, byteorder=DenaliMessage.BYTE_ORDER, signed=False)) payload += list(rx_flow_rate.to_bytes(2, byteorder=DenaliMessage.BYTE_ORDER, signed=False)) - msg = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_SET_DIALOUT_FLOW_RX, - payload=payload) + msg = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_SET_DIALOUT_FLOW_RX, + payload=payload) received_msg = self.__can_interface.send(msg) print(received_msg) else: print("Arguments to setUFRx are incorrect", file=sys.stderr) if received_msg is not None: - return_value = True if DenaliMessage.getPayload(received_msg)[0] == 1 else False + return_value = True if DenaliMessage.get_payload(received_msg)[0] == 1 else False return return_value @@ -120,7 +120,7 @@ \return: None """ - payload = DenaliMessage.getPayload(message) + payload = DenaliMessage.get_payload(message) state_num = int.from_bytes(bytearray(payload[0:2]), byteorder=DenaliMessage.BYTE_ORDER, signed=True) self.DialOutBroadcast['state'] = DialOutStates(state_num).name Index: HemodialysisDevice.py =================================================================== diff -u -rdc9c24e034cd5882cd437899199cc9c0834ef8c6 -rf1a95e42324e7f6da895039e4863db6af49bf0d2 --- HemodialysisDevice.py (.../HemodialysisDevice.py) (revision dc9c24e034cd5882cd437899199cc9c0834ef8c6) +++ HemodialysisDevice.py (.../HemodialysisDevice.py) (revision f1a95e42324e7f6da895039e4863db6af49bf0d2) @@ -41,7 +41,7 @@ \details For example: - hd_object = HD(can__interface='can0') or + hd_object = HD(can_interface='can0') or hd_object = HD('can0') """ # Create listener @@ -95,9 +95,9 @@ \returns 1 if logged in, 0 if log in failed """ - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_LOGIN_TO_HD, - payload=list(map(int, map(ord, self.HD_LOGIN_PASSWORD)))) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_LOGIN_TO_HD, + payload=list(map(int, map(ord, self.HD_LOGIN_PASSWORD)))) print("login") @@ -126,9 +126,9 @@ \returns 1 if successful, zero otherwise """ - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_MSG, - payload=msg) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_MSG, + payload=msg) print("insert HD message") @@ -180,9 +180,9 @@ sta = self.outer_instance.integer2ByteArray(state) payload = rst + sta - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_OFF_BUTTON_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_OFF_BUTTON_OVERRIDE, + payload=payload) print("override off button") @@ -218,9 +218,9 @@ sta = self.outer_instance.integer2ByteArray(state) payload = rst + sta - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_STOP_BUTTON_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_STOP_BUTTON_OVERRIDE, + payload=payload) print("override stop button") @@ -333,14 +333,14 @@ # register function to handle HD response to UF change requests if can_interface is not None: channel_id = DenaliChannels.hd_to_ui_ch_id - can_interface.registerReceivingPublicationFunction(channel_id, self.MSG_ID_UF_SETTINGS_CHANGE_RESPONSE_FROM_HD, - self.handlerUFChangeResponseFunction) - can_interface.registerReceivingPublicationFunction(channel_id, self.MSG_ID_TREATMENT_DURATION_SETTING_CHANGE_RESPONSE_FROM_HD, - self.handlerTreatmentDurationChangeResponseFunction) - can_interface.registerReceivingPublicationFunction(channel_id, self.MSG_ID_BLOOD_DIALYSATE_FLOW_SETTING_CHANGE_RESPONSE_FROM_HD, - self.handlerBloodAndDialysateChangeResponseFunction) - can_interface.registerReceivingPublicationFunction(channel_id, self.MSG_ID_HD_TREATMENT_PARAMS_RANGES, - self.handlerTreatmentParamRangesFunction) + can_interface.register_receiving_publication_function(channel_id, self.MSG_ID_UF_SETTINGS_CHANGE_RESPONSE_FROM_HD, + self.handlerUFChangeResponseFunction) + can_interface.register_receiving_publication_function(channel_id, self.MSG_ID_TREATMENT_DURATION_SETTING_CHANGE_RESPONSE_FROM_HD, + self.handlerTreatmentDurationChangeResponseFunction) + can_interface.register_receiving_publication_function(channel_id, self.MSG_ID_BLOOD_DIALYSATE_FLOW_SETTING_CHANGE_RESPONSE_FROM_HD, + self.handlerBloodAndDialysateChangeResponseFunction) + can_interface.register_receiving_publication_function(channel_id, self.MSG_ID_HD_TREATMENT_PARAMS_RANGES, + self.handlerTreatmentParamRangesFunction) # initialize variables that will be populated by treatment parameter ranges message self.MinTreatmentDurationMin = 0 @@ -509,8 +509,8 @@ payload = None - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_UI_CHECKIN_WITH_HD) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_UI_CHECKIN_WITH_HD) print("Sending UI checkin w/ HD") @@ -529,9 +529,9 @@ """ payload = self.outer_instance.integer2ByteArray(cmd) - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_UF_PAUSE_RESUME_REQUEST, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_UF_PAUSE_RESUME_REQUEST, + payload=payload) if cmd == self.UF_CMD_PAUSE: str_cmd = "pause" @@ -557,9 +557,9 @@ self.UFChangeResponse = None # build command message volume = self.outer_instance.float2ByteArray(vol * self.LITER_TO_ML_CONVERSION_FACTOR) - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_UF_SETTINGS_CHANGE_REQUEST_BY_USER, - payload=volume) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_UF_SETTINGS_CHANGE_REQUEST_BY_USER, + payload=volume) print("Sending UF settings change request.") @@ -584,9 +584,9 @@ volume = self.outer_instance.float2ByteArray(vol * self.LITER_TO_ML_CONVERSION_FACTOR) adjust = self.outer_instance.integer2ByteArray(adj) payload = volume + adjust - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_UF_SETTINGS_CHANGE_REQUEST_BY_USER, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_UF_SETTINGS_CHANGE_REQUEST_BY_USER, + payload=payload) print("Sending UF settings change request.") @@ -612,9 +612,9 @@ min = self.outer_instance.integer2ByteArray(tm) ufRate = self.outer_instance.float2ByteArray(rate) payload = resp + volume + min + ufRate - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_UF_SETTINGS_CHANGE_CONFIRMED_BY_USER, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_UF_SETTINGS_CHANGE_CONFIRMED_BY_USER, + payload=payload) print("Sending UF settings change confirmation.") @@ -633,9 +633,9 @@ """ payload = self.outer_instance.integer2ByteArray(timeMin) - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_TREATMENT_DURATION_SETTING_CHANGE_REQUEST, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_TREATMENT_DURATION_SETTING_CHANGE_REQUEST, + payload=payload) print("Sending treatment duration setting change request.") @@ -657,9 +657,9 @@ bld = self.outer_instance.integer2ByteArray(bloodFlow) dial = self.outer_instance.integer2ByteArray(dialFlow) payload = bld + dial - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_BLOOD_DIALYSATE_FLOW_SETTING_CHANGE_REQUEST_BY_USER, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_BLOOD_DIALYSATE_FLOW_SETTING_CHANGE_REQUEST_BY_USER, + payload=payload) print("Sending blood & dialysate flow rate settings change request.") @@ -704,9 +704,9 @@ tsk = self.outer_instance.integer2ByteArray(task) payload = rst + sta + tsk - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_WD_CHECKIN_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_WD_CHECKIN_OVERRIDE, + payload=payload) print("override watchdog task check-in state") @@ -780,17 +780,17 @@ if can_interface is not None: channel_id = DenaliChannels.hd_alarm_broadcast_ch_id msg_id = self.MSG_ID_HD_ALARMS_PUBLISHED_STATUS - can_interface.registerReceivingPublicationFunction(channel_id, msg_id, - self.handlerAlarmsStatusSyncFunction) + can_interface.register_receiving_publication_function(channel_id, msg_id, + self.handlerAlarmsStatusSyncFunction) channel_id = DenaliChannels.hd_alarm_broadcast_ch_id msg_id = self.MSG_ID_HD_ALARM_ACTIVATE - can_interface.registerReceivingPublicationFunction(channel_id, msg_id, - self.handlerAlarmActivateFunction) + can_interface.register_receiving_publication_function(channel_id, msg_id, + self.handlerAlarmActivateFunction) channel_id = DenaliChannels.hd_alarm_broadcast_ch_id msg_id = self.MSG_ID_HD_ALARM_CLEAR - can_interface.registerReceivingPublicationFunction(channel_id, msg_id, - self.handlerAlarmClearFunction) + can_interface.register_receiving_publication_function(channel_id, msg_id, + self.handlerAlarmClearFunction) # composite alarm status based on latest HD alarm status broadcast message self.alarmsState = 0 @@ -866,9 +866,9 @@ alm = self.outer_instance.integer2ByteArray(alarm) payload = rst + sta + alm - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_ALARM_STATE_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_ALARM_STATE_OVERRIDE, + payload=payload) print("override alarm state") @@ -905,9 +905,9 @@ alm = self.outer_instance.integer2ByteArray(alarm) payload = rst + ms + alm - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_ALARM_TIME_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_ALARM_TIME_OVERRIDE, + payload=payload) print("override alarm time since activated") @@ -950,9 +950,9 @@ pat = self.outer_instance.integer2ByteArray(pattern) payload = rst + pat - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_ALARM_LAMP_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_ALARM_LAMP_OVERRIDE, + payload=payload) print("override alarm lamp pattern") @@ -1012,8 +1012,8 @@ if can_interface is not None: channel_id = DenaliChannels.hd_sync_broadcast_ch_id msg_id = self.MSG_ID_RTC_EPOCH - can_interface.registerReceivingPublicationFunction(channel_id, msg_id, - self.handlerRTCEpoch) + can_interface.register_receiving_publication_function(channel_id, msg_id, + self.handlerRTCEpoch) self.RTCEpoch = 0 def handlerRTCEpoch(self, message): @@ -1042,9 +1042,9 @@ year = self.outer_instance.integer2ByteArray(years) payload = sec + min + hour + day + month + year - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_SET_RTC_DATE_TIME, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_SET_RTC_DATE_TIME, + payload=payload) print("Setting time and date to RTC") @@ -1056,8 +1056,8 @@ print(received_message) #str_res = str(flow) print("Time and Date in RTC set to seconds: " + str(sec) + " minutes: " + str(min) + " hours: " + - str(hour) + " days: " + str(day) + " months: " + str(month) + " years: " + str(year) + - str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) + str(hour) + " days: " + str(day) + " months: " + str(month) + " years: " + str(year) + + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) # response payload is OK or not OK return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] else: @@ -1111,8 +1111,8 @@ if can_interface is not None: channel_id = DenaliChannels.hd_sync_broadcast_ch_id msg_id = self.MSG_ID_HD_BLOOD_FLOW_PUBLISHED_DATA - can_interface.registerReceivingPublicationFunction(channel_id, msg_id, - self.handlerBloodFlowSyncFunction) + can_interface.register_receiving_publication_function(channel_id, msg_id, + self.handlerBloodFlowSyncFunction) self.TargetBloodFlowRate = 0 self.MeasuredBloodFlowRate = 0.0 @@ -1171,9 +1171,9 @@ flo = self.outer_instance.integer2ByteArray(flow) payload = rst + flo - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_BLOOD_FLOW_SET_RATE_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_BLOOD_FLOW_SET_RATE_OVERRIDE, + payload=payload) print("override blood flow set point") @@ -1209,9 +1209,9 @@ flo = self.outer_instance.float2ByteArray(flow) payload = rst + flo - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_BLOOD_FLOW_MEAS_RATE_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_BLOOD_FLOW_MEAS_RATE_OVERRIDE, + payload=payload) print("override measured blood flow") @@ -1247,9 +1247,9 @@ spd = self.outer_instance.float2ByteArray(speed) payload = rst + spd - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_BLOOD_PUMP_MC_MEAS_SPEED_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_BLOOD_PUMP_MC_MEAS_SPEED_OVERRIDE, + payload=payload) print("override measured blood pump motor controller speed") @@ -1284,9 +1284,9 @@ cur = self.outer_instance.float2ByteArray(curr) payload = rst + cur - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_BLOOD_PUMP_MC_MEAS_CURRENT_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_BLOOD_PUMP_MC_MEAS_CURRENT_OVERRIDE, + payload=payload) print("override measured blood pump motor controller current") @@ -1322,9 +1322,9 @@ spd = self.outer_instance.float2ByteArray(speed) payload = rst + spd - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_BLOOD_PUMP_MEAS_SPEED_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_BLOOD_PUMP_MEAS_SPEED_OVERRIDE, + payload=payload) print("override measured blood pump speed") @@ -1360,9 +1360,9 @@ spd = self.outer_instance.float2ByteArray(speed) payload = rst + spd - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_BLOOD_PUMP_ROTOR_MEAS_SPEED_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_BLOOD_PUMP_ROTOR_MEAS_SPEED_OVERRIDE, + payload=payload) print("override measured blood pump rotor speed") @@ -1397,9 +1397,9 @@ mis = self.outer_instance.integer2ByteArray(ms) payload = rst + mis - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_BLOOD_FLOW_PUBLISH_INTERVAL_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_BLOOD_FLOW_PUBLISH_INTERVAL_OVERRIDE, + payload=payload) print("override blood flow broadcast interval") @@ -1468,8 +1468,8 @@ if can_interface is not None: channel_id = DenaliChannels.hd_sync_broadcast_ch_id msg_id = self.MSG_ID_HD_DIAL_IN_FLOW_PUBLISHED_DATA - can_interface.registerReceivingPublicationFunction(channel_id, msg_id, - self.handlerDialysateInletFlowSyncFunction) + can_interface.register_receiving_publication_function(channel_id, msg_id, + self.handlerDialysateInletFlowSyncFunction) self.TargetDialysateInletFlowRate = 0 self.MeasuredDialysateInletFlowRate = 0.0 @@ -1524,9 +1524,9 @@ flo = self.outer_instance.integer2ByteArray(flow) payload = rst + flo - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_DIAL_IN_FLOW_SET_RATE_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_IN_FLOW_SET_RATE_OVERRIDE, + payload=payload) print("override dialysate flow set point") @@ -1562,9 +1562,9 @@ flo = self.outer_instance.float2ByteArray(flow) payload = rst + flo - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_DIAL_IN_FLOW_MEAS_RATE_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_IN_FLOW_MEAS_RATE_OVERRIDE, + payload=payload) print("override measured dialysate flow") @@ -1600,9 +1600,9 @@ spd = self.outer_instance.float2ByteArray(speed) payload = rst + spd - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_DIAL_IN_PUMP_MC_MEAS_SPEED_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_IN_PUMP_MC_MEAS_SPEED_OVERRIDE, + payload=payload) print("override measured dialysate inlet pump motor controller speed") @@ -1637,9 +1637,9 @@ cur = self.outer_instance.float2ByteArray(curr) payload = rst + cur - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_DIAL_IN_PUMP_MC_MEAS_CURRENT_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_IN_PUMP_MC_MEAS_CURRENT_OVERRIDE, + payload=payload) print("override measured dialysate inlet pump motor controller current") @@ -1675,9 +1675,9 @@ spd = self.outer_instance.float2ByteArray(speed) payload = rst + spd - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_DIAL_IN_PUMP_MEAS_SPEED_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_IN_PUMP_MEAS_SPEED_OVERRIDE, + payload=payload) print("override measured dialysate inlet pump speed") @@ -1713,9 +1713,9 @@ spd = self.outer_instance.float2ByteArray(speed) payload = rst + spd - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_DIAL_IN_PUMP_ROTOR_MEAS_SPEED_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_IN_PUMP_ROTOR_MEAS_SPEED_OVERRIDE, + payload=payload) print("override measured dialysate inlet pump rotor speed") @@ -1750,9 +1750,9 @@ mis = self.outer_instance.integer2ByteArray(ms) payload = rst + mis - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_DIAL_IN_FLOW_PUBLISH_INTERVAL_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_IN_FLOW_PUBLISH_INTERVAL_OVERRIDE, + payload=payload) print("override dialysate inlet flow broadcast interval") @@ -1823,8 +1823,8 @@ if can_interface is not None: channel_id = DenaliChannels.hd_sync_broadcast_ch_id msg_id = self.MSG_ID_HD_DIAL_OUT_FLOW_PUBLISHED_DATA - can_interface.registerReceivingPublicationFunction(channel_id, msg_id, - self.handlerDialysateOutletFlowSyncFunction) + can_interface.register_receiving_publication_function(channel_id, msg_id, + self.handlerDialysateOutletFlowSyncFunction) self.ReferenceDialysateOutletUFVolume = 0.0 self.MeasuredDialysateOutletUFVolume = 0.0 @@ -1879,9 +1879,9 @@ vol = self.outer_instance.float2ByteArray(refVol) payload = rst + vol - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_DIAL_OUT_UF_REF_VOLUME_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_OUT_UF_REF_VOLUME_OVERRIDE, + payload=payload) print("override UF reference volume with " + str(refVol) + "mL.") @@ -1917,9 +1917,9 @@ vol = self.outer_instance.float2ByteArray(measVol) payload = rst + vol - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_DIAL_OUT_UF_MEAS_VOLUME_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_OUT_UF_MEAS_VOLUME_OVERRIDE, + payload=payload) print("override measured UF volume with " + str(measVol) + " mL.") @@ -1955,9 +1955,9 @@ spd = self.outer_instance.float2ByteArray(speed) payload = rst + spd - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MeasuredDialysateOutletPumpMCSpeed, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MeasuredDialysateOutletPumpMCSpeed, + payload=payload) print("override measured dialysate outlet pump motor controller speed to " + str(spd) + " RPM.") @@ -1992,9 +1992,9 @@ cur = self.outer_instance.float2ByteArray(curr) payload = rst + cur - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_DIAL_OUT_PUMP_MC_MEAS_CURRENT_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_OUT_PUMP_MC_MEAS_CURRENT_OVERRIDE, + payload=payload) print("override measured dialysate outlet pump motor controller current") @@ -2030,9 +2030,9 @@ spd = self.outer_instance.float2ByteArray(speed) payload = rst + spd - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_DIAL_OUT_PUMP_MEAS_SPEED_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_OUT_PUMP_MEAS_SPEED_OVERRIDE, + payload=payload) print("override measured dialysate outlet pump speed to " + str(speed) + " RPM.") @@ -2068,9 +2068,9 @@ spd = self.outer_instance.float2ByteArray(speed) payload = rst + spd - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_DIAL_OUT_PUMP_ROTOR_MEAS_SPEED_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_OUT_PUMP_ROTOR_MEAS_SPEED_OVERRIDE, + payload=payload) print("override measured dialysate outlet pump rotor speed to " + str(speed) + " RPM.") @@ -2105,9 +2105,9 @@ mis = self.outer_instance.integer2ByteArray(ms) payload = rst + mis - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_DIAL_OUT_FLOW_PUBLISH_INTERVAL_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_OUT_FLOW_PUBLISH_INTERVAL_OVERRIDE, + payload=payload) print("override dialysate outlet flow broadcast interval to " + str(ms) + " ms.") @@ -2150,9 +2150,9 @@ sen = self.outer_instance.integer2ByteArray(sensor) payload = rst + spd + sen - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_DIAL_OUT_LOAD_CELL_WEIGHT_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_OUT_LOAD_CELL_WEIGHT_OVERRIDE, + payload=payload) print("override measured load cell weight to " + str(weight) + " grams for load cell # " + str(sensor)) @@ -2191,9 +2191,9 @@ r2bb = self.outer_instance.float2ByteArray(r2b) payload = r1pb + r1bb + r2pb + r2bb - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_LOAD_CELL_READINGS, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_LOAD_CELL_READINGS, + payload=payload) print("measured load cell weights set.") @@ -2243,11 +2243,11 @@ if can_interface is not None: channel_id = DenaliChannels.hd_sync_broadcast_ch_id msg_id = self.MSG_ID_HD_TREATMENT_TIME_PUBLISHED_DATA - can_interface.registerReceivingPublicationFunction(channel_id, msg_id, - self.handlerTreatmentTimeSyncFunction) + can_interface.register_receiving_publication_function(channel_id, msg_id, + self.handlerTreatmentTimeSyncFunction) msg_id = self.MSG_ID_HD_TREATMENT_STATE_PUBLISHED_DATA - can_interface.registerReceivingPublicationFunction(channel_id, msg_id, - self.handlerTreatmentStateSyncFunction) + can_interface.register_receiving_publication_function(channel_id, msg_id, + self.handlerTreatmentStateSyncFunction) self.TreatmentTimePrescribed = 0 self.TreatmentTimeElapsed = 0 @@ -2341,8 +2341,8 @@ if can_interface is not None: channel_id = DenaliChannels.hd_sync_broadcast_ch_id msg_id = self.MSG_ID_HD_PRESSURE_OCCLUSION_DATA - can_interface.registerReceivingPublicationFunction(channel_id, msg_id, - self.handlerPresOcclSyncFunction) + can_interface.register_receiving_publication_function(channel_id, msg_id, + self.handlerPresOcclSyncFunction) self.arterialPressure = 0 self.venousPressure = 0.0 @@ -2390,9 +2390,9 @@ prs = self.outer_instance.float2ByteArray(pres) payload = rst + prs - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_PRESSURE_ARTERIAL_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_PRESSURE_ARTERIAL_OVERRIDE, + payload=payload) print("override measured arterial pressure") @@ -2424,7 +2424,7 @@ # # payload = seq1 + zero + seq2 + zero + seq3 + zero + seq4 + zero + seq5 # - # message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, + # message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, # message_id=6, # payload=payload) # @@ -2446,9 +2446,9 @@ prs = self.outer_instance.float2ByteArray(pres) payload = rst + prs - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_PRESSURE_VENOUS_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_PRESSURE_VENOUS_OVERRIDE, + payload=payload) print("override measured venous pressure") @@ -2482,9 +2482,9 @@ occ = self.outer_instance.float2ByteArray(occl) payload = rst + occ - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_OCCLUSION_BLOOD_PUMP_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_OCCLUSION_BLOOD_PUMP_OVERRIDE, + payload=payload) print("override measured blood pump occlusion pressure") @@ -2519,9 +2519,9 @@ occ = self.outer_instance.float2ByteArray(occl) payload = rst + occ - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_OCCLUSION_DIAL_IN_PUMP_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_OCCLUSION_DIAL_IN_PUMP_OVERRIDE, + payload=payload) print("override measured dialysate inlet pump occlusion pressure") @@ -2556,9 +2556,9 @@ occ = self.outer_instance.float2ByteArray(occl) payload = rst + occ - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_OCCLUSION_DIAL_OUT_PUMP_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_OCCLUSION_DIAL_OUT_PUMP_OVERRIDE, + payload=payload) print("override measured dialysate outlet pump occlusion pressure") @@ -2592,9 +2592,9 @@ mis = self.outer_instance.integer2ByteArray(ms) payload = rst + mis - message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, - message_id=self.MSG_ID_HD_PRES_OCCL_SEND_INTERVAL_OVERRIDE, - payload=payload) + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_PRES_OCCL_SEND_INTERVAL_OVERRIDE, + payload=payload) print("override pressure/occlusion broadcast interval") Index: Miscellaneous/DG_Firmware_Simulator.py =================================================================== diff -u -r02d0551b15b9bd9824b83041d2d8ce11367872c8 -rf1a95e42324e7f6da895039e4863db6af49bf0d2 --- Miscellaneous/DG_Firmware_Simulator.py (.../DG_Firmware_Simulator.py) (revision 02d0551b15b9bd9824b83041d2d8ce11367872c8) +++ Miscellaneous/DG_Firmware_Simulator.py (.../DG_Firmware_Simulator.py) (revision f1a95e42324e7f6da895039e4863db6af49bf0d2) @@ -5,14 +5,14 @@ # Building response message -response_msg = DenaliMessage.buildMessage(channel_id=DenaliChannels.dg_to_hd_ch_id, - message_id=1000, - payload=[1]) +response_msg = DenaliMessage.build_message(channel_id=DenaliChannels.dg_to_hd_ch_id, + message_id=1000, + payload=[1]) # Building Publication message -publication_msg = DenaliMessage.buildMessage(channel_id=DenaliChannels.dg_sync_broadcast_ch_id, - message_id=0x7100, - payload=[1, 2, 3, 4, 5]) +publication_msg = DenaliMessage.build_message(channel_id=DenaliChannels.dg_sync_broadcast_ch_id, + message_id=0x7100, + payload=[1, 2, 3, 4, 5]) print("") print("o -> response to fill command") @@ -26,9 +26,9 @@ # Register response command for the DG -dialin_messenger.registerReceivingPublicationFunction(channel_id=DenaliChannels.ui_to_hd_ch_id, - message_id=1000, - function=respondToCommand) +dialin_messenger.register_receiving_publication_function(channel_id=DenaliChannels.ui_to_hd_ch_id, + message_id=1000, + function=respondToCommand) dialin_messenger.start() Index: setup_virtual_can.sh =================================================================== diff -u --- setup_virtual_can.sh (revision 0) +++ setup_virtual_can.sh (revision f1a95e42324e7f6da895039e4863db6af49bf0d2) @@ -0,0 +1,15 @@ +#!/bin/bash +sudo ifconfig vcan0 down +sudo ifconfig vcan1 down +sudo ip link delete dev vcan0 +sudo ip link delete dev vcan1 + +sudo ip link add dev vcan0 type vcan +sudo ip link add dev vcan1 type vcan + +sudo ip link set vcan0 up +sudo ifconfig vcan0 txqueuelen 10000 + +sudo ip link set vcan1 up +sudo ifconfig vcan1 txqueuelen 10000 +