###########################################################################
#
# Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved.
#
# THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN
# WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER.
#
# @file treatment.py
#
# @author (last) Peter Lucia
# @date (last) 06-Aug-2020
# @author (original) Peter Lucia
# @date (original) 02-Apr-2020
#
############################################################################
import struct
from ..protocols.CAN import (DenaliMessage,
                             DenaliChannels)
from ..utils.base import _AbstractSubSystem, _publish
from ..utils.conversions import integer_to_bytearray, float_to_bytearray
from logging import Logger


class HDTreatment(_AbstractSubSystem):
    """

    Hemodialysis Delivery (HD) Dialin API sub-class for treatment related commands.

    """

    # treatment message IDs
    MSG_ID_HD_TREATMENT_TIME_PUBLISHED_DATA = 0x000D
    MSG_ID_HD_TREATMENT_STATE_PUBLISHED_DATA = 0x000F
    MSG_ID_HD_SET_TREATMENT_PARAMETER = 0x802D

    # Treatment Parameter IDs
    HD_TREATMENT_PARAMETER_BLOOD_FLOW = 0
    HD_TREATMENT_PARAMETER_DIALYSATE_FLOW = 1
    HD_TREATMENT_PARAMETER_TREATMENT_DURATION = 2
    HD_TREATMENT_PARAMETER_HEPARIN_PRE_STOP_TIME = 3
    HD_TREATMENT_PARAMETER_SALINE_BOLUS_VOLUME = 4
    HD_TREATMENT_PARAMETER_ACID_CONCENTRATE = 5
    HD_TREATMENT_PARAMETER_BICARB_CONCENTRATE = 6
    HD_TREATMENT_PARAMETER_DIALYZER_TYPE = 7
    HD_TREATMENT_PARAMETER_BP_MEAS_INTERVAL = 8
    HD_TREATMENT_PARAMETER_RINSEBACK_FLOW_RATE = 9
    HD_TREATMENT_PARAMETER_ART_PRESSURE_LOW_LIMIT = 10
    HD_TREATMENT_PARAMETER_ART_PRESSURE_HIGH_LIMIT = 11
    HD_TREATMENT_PARAMETER_VEN_PRESSURE_LOW_LIMIT = 12
    HD_TREATMENT_PARAMETER_VEN_PRESSURE_HIGH_LIMIT = 13
    HD_TREATMENT_PARAMETER_HEPARIN_DISPENSE_RATE = 14
    HD_TREATMENT_PARAMETER_HEPARIN_BOLUS_VOLUME = 15
    HD_TREATMENT_PARAMETER_DIALYSATE_TEMPERATURE = 16
    HD_TREATMENT_PARAMETER_UF_VOLUME = 17

    # Dialyzer Type IDs
    DIALYZER_TYPE_NIPRO_ELISIO_H_17 = 0
    DIALYZER_TYPE_NIPRO_ELISIO_H_19 = 1
    DIALYZER_TYPE_FRESENIUS_OPTIFLUX_F160NRE = 2
    DIALYZER_TYPE_FRESENIUS_OPTIFLUX_F180NRE = 3

    # Acid Concentrate IDs
    ACID_CONC_TYPE_FRESENIUS_08_1251_1 = 0
    ACID_CONC_TYPE_FRESENIUS_08_2251_0 = 1
    ACID_CONC_TYPE_FRESENIUS_08_3251_9 = 2

    # Bicarbonate Concentrate IDs
    BICARB_CONC_TYPE_FRESENIUS_CENTRISOL = 0

    # treatment time broadcast message field positions
    START_POS_TIME_PRES = DenaliMessage.PAYLOAD_START_INDEX
    END_POS_TIME_PRES = START_POS_TIME_PRES + 4
    START_POS_TIME_ELAPSED = END_POS_TIME_PRES
    END_POS_TIME_ELAPSED = START_POS_TIME_ELAPSED + 4
    START_POS_TIME_REMAINING = END_POS_TIME_ELAPSED
    END_POS_TIME_REMAINING = START_POS_TIME_REMAINING + 4

    # treatment state broadcast message field positions
    START_POS_TREATMENT_STATE = DenaliMessage.PAYLOAD_START_INDEX
    END_POS_TREATMENT_STATE = START_POS_TREATMENT_STATE + 4
    START_POS_UF_STATE = END_POS_TREATMENT_STATE
    END_POS_UF_STATE = START_POS_UF_STATE + 4
    START_POS_SALINE_BOLUS_IN_PROGRESS = END_POS_UF_STATE
    END_POS_SALINE_BOLUS_IN_PROGRESS = START_POS_SALINE_BOLUS_IN_PROGRESS + 4

    def __init__(self, can_interface, logger: Logger):
        """
        HDTreatment constructor
        """

        super().__init__()
        self.can_interface = can_interface
        self.logger = logger

        if self.can_interface is not None:
            channel_id = DenaliChannels.hd_sync_broadcast_ch_id
            msg_id = self.MSG_ID_HD_TREATMENT_TIME_PUBLISHED_DATA
            self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                       self._handler_treatment_time_sync)
            msg_id = self.MSG_ID_HD_TREATMENT_STATE_PUBLISHED_DATA
            self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                       self._handler_treatment_state_sync)

        self.treatment_time_prescribed = 0
        self.treatment_time_elapsed = 0
        self.treatment_time_remaining = 0
        self.treatment_state = 0
        self.treatment_uf_state = 0
        self.saline_bolus_in_progress = False

    def get_treatment_time_prescribed(self):
        """
        Gets the prescribed treatment time

        @return: The prescribed treatment time
        """
        return self.treatment_time_prescribed

    def get_treatment_time_elapsed(self):
        """
        Gets the elapsed treatment time

        @return: The elapsed treatment time
        """
        return self.treatment_time_elapsed

    def get_treatment_time_remaining(self):
        """
        Gets the remaining treatment time

        @return: The remaining treatment time
        """
        return self.treatment_time_remaining

    def get_treatment_state(self):
        """
        Gets the treatment state

        @return: The treatment state
        """
        return self.treatment_state

    def get_treatment_uf_state(self):
        """
        Gets the treatment uf state

        @return: The treatment uf state
        """
        return self.treatment_uf_state

    def get_saline_bolus_in_progress(self):
        """
        Returns whether saline bolus is in progress

        @return: True if saline bolus is in progress, False otherwise
        """
        return self.saline_bolus_in_progress

    @_publish([
        "treatment_time_prescribed",
        "treatment_time_elapsed",
        "treatment_time_remaining"
    ])
    def _handler_treatment_time_sync(self, message):
        """
        Handles published treatment time data messages.  treatment time data are captured
        for reference.

        @param message: published treatment time data message
        @return: None
        """

        tot = struct.unpack('i', bytearray(
            message['message'][self.START_POS_TIME_PRES:self.END_POS_TIME_PRES]))
        ela = struct.unpack('i', bytearray(
            message['message'][self.START_POS_TIME_ELAPSED:self.END_POS_TIME_ELAPSED]))
        rem = struct.unpack('i', bytearray(
            message['message'][self.START_POS_TIME_REMAINING:self.END_POS_TIME_REMAINING]))

        self.treatment_time_prescribed = tot[0]
        self.treatment_time_elapsed = ela[0]
        self.treatment_time_remaining = rem[0]

    @_publish([
        "treatment_state",
        "treatment_uf_state",
        "saline_bolus_in_progress"
    ])
    def _handler_treatment_state_sync(self, message):
        """
        Handles published treatment state data messages.  treatment state data are captured
        for reference.

        @param message: published treatment state data message
        @return: none
        """

        tst = struct.unpack('i', bytearray(
            message['message'][self.START_POS_TREATMENT_STATE:self.END_POS_TREATMENT_STATE]))
        ufs = struct.unpack('i', bytearray(
            message['message'][self.START_POS_UF_STATE:self.END_POS_UF_STATE]))
        bol = struct.unpack('i', bytearray(
            message['message'][self.START_POS_SALINE_BOLUS_IN_PROGRESS:self.END_POS_SALINE_BOLUS_IN_PROGRESS]))

        self.treatment_state = tst[0]
        self.treatment_uf_state = ufs[0]
        if bol[0] == 1:
            self.saline_bolus_in_progress = True
        else:
            self.saline_bolus_in_progress = False

    def cmd_set_treatment_param_blood_flow_rate(self, flow):
        """
        Constructs and sends the set blood flow rate treatment parameter command.
        This will only set the treatment parameter setting.  It will not immediately
        set the blood pump on with this set point.
        Constraints:
            Must be logged into HD.
            Flow must be positive integer and should be between 100 and 500 mL/min

        @param flow:  integer - set blood flow rate (in mL/min)
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_BLOOD_FLOW)
        flo = integer_to_bytearray(flow)
        payload = par + flo

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting blood flow rate")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_flo = str(flow)
            print("Blood flow rate parameter set to " + str_flo + " mL/min: " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_treatment_param_dialysate_flow_rate(self, flow):
        """
        Constructs and sends the set dialysate flow rate treatment parameter command.
        This will only set the treatment parameter setting.  It will not immediately
        set the dialysate inlet pump on with this set point.
        Constraints:
            Must be logged into HD.
            Flow must be positive integer and should be between 100 and 600 mL/min

        @param flow:  integer - set blood flow rate (in mL/min)
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_DIALYSATE_FLOW)
        flo = integer_to_bytearray(flow)
        payload = par + flo

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting dialysate flow rate")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_flo = str(flow)
            print("Dialysate flow rate parameter set to " + str_flo + " mL/min: " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_treatment_param_duration(self, duration):
        """
        Constructs and sends the set treatment duration parameter command.
        Constraints:
            Must be logged into HD.
            Duration must be positive integer and should be between 60 and 480 min

        @param duration:  integer - set treatment duration (in min)
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_TREATMENT_DURATION)
        dur = integer_to_bytearray(duration)
        payload = par + dur

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting treatment duration")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_dur = str(duration)
            print("Treatment duration parameter set to " + str_dur + " min: " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_heparin_pre_stop_time(self, pre_stop):
        """
        Constructs and sends the set Heparin pre-stop time parameter command.
        Constraints:
            Must be logged into HD.
            Pre-stop time for Heparin must be positive integer and should be between 0 and 120 min

        @param pre_stop:  integer - set Heparin pre-stop time (in min)
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_HEPARIN_PRE_STOP_TIME)
        sto = integer_to_bytearray(pre_stop)
        payload = par + sto

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting Heparin pre-stop time")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_sto = str(pre_stop)
            print("Heparin pre-stop time parameter set to " + str_sto + " min: " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_saline_bolus_volume(self, volume):
        """
        Constructs and sends the set saline bolus volume parameter command.
        Constraints:
            Must be logged into HD.
            Volume must be positive integer and should be between 0 and 300 mL

        @param volume:  integer - set saline bolus volume (in mL)
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_SALINE_BOLUS_VOLUME)
        vol = integer_to_bytearray(volume)
        payload = par + vol

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting saline bolus volume")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_vol = str(volume)
            print("Saline bolus volume parameter set to " + str_vol + " mL: " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_acid_concentrate(self, acid):
        """
        Constructs and sends the set acid concentrate parameter command.
        Constraints:
            Must be logged into HD.
            Acid ID must be positive integer and should be between 0 and 2 (see below)
                ACID_CONC_TYPE_FRESENIUS_08_1251_1 = 0
                ACID_CONC_TYPE_FRESENIUS_08_2251_0 = 1
                ACID_CONC_TYPE_FRESENIUS_08_3251_9 = 2

        @param acid:  integer - set acid concentrate type
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_ACID_CONCENTRATE)
        acd = integer_to_bytearray(acid)
        payload = par + acd

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting acid concentrate parameter")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_acd = str(acid)
            print("Acid concentrate parameter set to " + str_acd + ": " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_bicarb_concentrate(self, bicarb):
        """
        Constructs and sends the set bicarbonate concentrate parameter command.
        Constraints:
            Must be logged into HD.
            Bicarb ID must be positive integer and should be between 0 and 0 (see below)
                BICARB_CONC_TYPE_FRESENIUS_CENTRISOL = 0

        @param bicarb:  integer - set bicarbonate concentrate type
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_BICARB_CONCENTRATE)
        bic = integer_to_bytearray(bicarb)
        payload = par + bic

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting bicarbonate concentrate parameter")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_bic = str(bicarb)
            print("Bicarbonate concentrate parameter set to " + str_bic + ": " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_dialyzer_type(self, dialyzer):
        """
        Constructs and sends the set dialyzer type parameter command.
        Constraints:
            Must be logged into HD.
            Dialyzer ID must be positive integer and should be between 0 and 3 (see below)
                DIALYZER_TYPE_NIPRO_ELISIO_H_17 = 0
                DIALYZER_TYPE_NIPRO_ELISIO_H_19 = 1
                DIALYZER_TYPE_FRESENIUS_OPTIFLUX_F160NRE = 2
                DIALYZER_TYPE_FRESENIUS_OPTIFLUX_F180NRE = 3

        @param dialyzer:  integer - set dialyzer type
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_DIALYZER_TYPE)
        dia = integer_to_bytearray(dialyzer)
        payload = par + dia

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting dialyzer type parameter")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_dia = str(dialyzer)
            print("Dialyzer type parameter set to " + str_dia + ": " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_bp_measurement_interval(self, intvl):
        """
        Constructs and sends the set blood pressure measurement interval parameter command.
        Constraints:
            Must be logged into HD.
            Interval must be positive integer and should be between 0 and 60 min

        @param intvl:  integer - set blood pressure measurement interval (in min)
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_BP_MEAS_INTERVAL)
        bpi = integer_to_bytearray(intvl)
        payload = par + bpi

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting BP measurement interval parameter")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_bpi = str(intvl)
            print("BP measurement interval parameter set to " + str_bpi + ": " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_rinseback_flow_rate(self, flow):
        """
        Constructs and sends the set rinseback flow rate parameter command.
        Constraints:
            Must be logged into HD.
            Flow must be positive integer and should be between 50 and 175 mL/min

        @param flow:  integer - set rinseback flow rate (in mL/min)
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_RINSEBACK_FLOW_RATE)
        flo = integer_to_bytearray(flow)
        payload = par + flo

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting rinseback flow rate parameter")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_flo = str(flow)
            print("Rinseback flow rate parameter set to " + str_flo + ": " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_arterial_pressure_low_alarm_limit(self, pres):
        """
        Constructs and sends the set arterial pressure lower alarm limit parameter command.
        Constraints:
            Must be logged into HD.
            Pressure must be integer and should be between -300 and +200 mmHg

        @param pres:  integer - set arterial pressure lower alarm limit (in mmHg)
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_ART_PRESSURE_LOW_LIMIT)
        pre = integer_to_bytearray(pres)
        payload = par + pre

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting arterial pressure lower alarm limit parameter")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_pre = str(pres)
            print("Arterial pressure lower alarm limit parameter set to " + str_pre + ": " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_arterial_pressure_high_alarm_limit(self, pres):
        """
        Constructs and sends the set arterial pressure upper alarm limit parameter command.
        Constraints:
            Must be logged into HD.
            Pressure must be integer and should be between -300 and +200 mmHg

        @param pres:  integer - set arterial pressure upper alarm limit (in mmHg)
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_ART_PRESSURE_HIGH_LIMIT)
        pre = integer_to_bytearray(pres)
        payload = par + pre

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting arterial pressure upper alarm limit parameter")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_pre = str(pres)
            print("Arterial pressure upper alarm limit parameter set to " + str_pre + ": " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_venous_pressure_low_alarm_limit(self, pres):
        """
        Constructs and sends the set venous pressure lower alarm limit parameter command.
        Constraints:
            Must be logged into HD.
            Pressure must be integer and should be between -100 and +600 mmHg

        @param pres:  integer - set venous pressure lower alarm limit (in mmHg)
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_VEN_PRESSURE_LOW_LIMIT)
        pre = integer_to_bytearray(pres)
        payload = par + pre

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting venous pressure lower alarm limit parameter")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_pre = str(pres)
            print("Venous pressure lower alarm limit parameter set to " + str_pre + ": " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_venous_pressure_high_alarm_limit(self, pres):
        """
        Constructs and sends the set venous pressure upper alarm limit parameter command.
        Constraints:
            Must be logged into HD.
            Pressure must be integer and should be between -100 and +600 mmHg

        @param pres:  integer - set venous pressure upper alarm limit (in mmHg)
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_VEN_PRESSURE_HIGH_LIMIT)
        pre = integer_to_bytearray(pres)
        payload = par + pre

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting venous pressure upper alarm limit parameter")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_pre = str(pres)
            print("Venous pressure upper alarm limit parameter set to " + str_pre + ": " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_heparin_dispense_rate(self, rate):
        """
        Constructs and sends the set Heparin dispense rate parameter command.
        Constraints:
            Must be logged into HD.
            Rate must be floating point value and should be between 0 and 1.0 mL/hr

        @param rate:  float - set Heparin dispense rate (in mL/hr)
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_HEPARIN_DISPENSE_RATE)
        rat = float_to_bytearray(rate)
        payload = par + rat

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting Heparin dispense rate parameter")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_rat = str(rate)
            print("Heparin dispense rate parameter set to " + str_rat + ": " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_heparin_bolus_volume(self, volume):
        """
        Constructs and sends the set Heparin bolus volume parameter command.
        Constraints:
            Must be logged into HD.
            Volume must be floating point value and should be between 0 and 2.0 mL

        @param volume:  float - set Heparin bolus volume (in mL)
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_HEPARIN_BOLUS_VOLUME)
        vol = float_to_bytearray(volume)
        payload = par + vol

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting Heparin bolus volume parameter")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_vol = str(volume)
            print("Heparin bolus volume parameter set to " + str_vol + ": " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_dialysate_tempeature(self, temp):
        """
        Constructs and sends the set dialysate temperature parameter command.
        Constraints:
            Must be logged into HD.
            Temperature must be floating point value and should be between 35.0 and 38.0 deg C

        @param temp:  float - set dialysate temperature (in deg C)
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_DIALYSATE_TEMPERATURE)
        tmp = float_to_bytearray(temp)
        payload = par + tmp

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting dialysate temperature parameter")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_tmp = str(temp)
            print("Dialysate temperature parameter set to " + str_tmp + ": " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_set_ultrafiltration_volume(self, volume):
        """
        Constructs and sends the set ultrafiltration volume parameter command.
        Constraints:
            Must be logged into HD.
            Volume must be floating point value and should be between 0.0 and 8.0L

        @param volume:  float - set ultrafiltration volume (in L)
        @return: 1 if successful, zero otherwise
        """

        par = integer_to_bytearray(self.HD_TREATMENT_PARAMETER_UF_VOLUME)
        vol = float_to_bytearray(volume)
        payload = par + vol

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_SET_TREATMENT_PARAMETER,
                                              payload=payload)

        print("setting ultrafiltration volume parameter")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            # print(received_message)
            str_vol = str(volume)
            print("Ultrafiltration volume parameter set to " + str_vol + ": " +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False