Index: dialin/squish/denaliMessages.py
===================================================================
diff -u -r87cf0bc784212d2608c58d1388b37396aa0a4656 -rccc07090d6993ade7fc1d9ea12e7601ca6d9a9ef
--- dialin/squish/denaliMessages.py	(.../denaliMessages.py)	(revision 87cf0bc784212d2608c58d1388b37396aa0a4656)
+++ dialin/squish/denaliMessages.py	(.../denaliMessages.py)	(revision ccc07090d6993ade7fc1d9ea12e7601ca6d9a9ef)
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 ###########################################################################
 #
 # Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved.
@@ -7,8 +8,8 @@
 #
 # @file denaliMessages.py
 #
-# @author (last) Peter Lucia
-# @date (last) 09-Jul-2020
+# @author (last) Behrouz NematiPour
+# @date (last) 20-Oct-2020
 # @author (original) Peter Lucia
 # @date (original) 09-Jul-2020
 #
@@ -21,211 +22,355 @@
 from dialin.squish import messageBuilder
 
 
+class txStates:
+    # Saline states
+    SALINE_BOLUS_STATE_IDLE                 = 0 # No saline bolus delivery is in progress
+    SALINE_BOLUS_STATE_WAIT_FOR_PUMPS_STOP  = 1 # Wait for pumps to stop before starting bolus
+    SALINE_BOLUS_STATE_IN_PROGRESS          = 2 # A saline bolus delivery is in progress
+    SALINE_BOLUS_STATE_MAX_DELIVERED        = 3 # Maximum saline bolus volume reached - no more saline bolus deliveries allowed
+    
+    # UF states
+    # UI only cares about the actual state and _NOT could be any other state
+    UF_PAUSED_STATE_NOT      = 0
+    UF_PAUSED_STATE          = 1
+    
+    # Sub Mode
+    # UI only cares about the actual state and _NOT could be any other state
+    TREATMENT_DIALYSIS_STATE_NOT = 0
+    TREATMENT_DIALYSIS_STATE     = 1 
+
+
 class EResponse:
     Rejected = 0
     Accepted = 1
 
 
 class GuiActionType:
-    Unknown = 0
-    PowerOff = 1
-    KeepAlive = 7
-    BloodFlow = 5
-    DialysateInletFlow = 8
-    DialysateOutletFlow = 11
-    TreatmentTime = 13
-    PowerOffBroadcast = 14
+    Unknown                 =     0
+    PowerOff                =     1
+    KeepAlive               =     7
+    BloodFlow               =     5
+    DialysateInletFlow      =     8
+    DialysateOutletFlow     =    11
+    TreatmentTime           =    13
+    PowerOffBroadcast       =    14
 
-    AlarmStatus = 2
-    AlarmTriggered = 3
-    AlarmCleared = 4
+    AlarmStatus             =     2
+    AlarmTriggered          =     3
+    AlarmCleared            =     4
 
-    PressureOcclusion = 9
+    PressureOcclusion       =     9
 
-    DGDrainPumpData = 36
-    DGHeatersData = 44
-    LoadCellReadings = 12
-    DGPressuresData = 32
-    TemperatureSensors = 45
+    DGDrainPumpData         =    36
+    DGHeatersData           =    44
+    LoadCellReadings        =    12
+    DGPressuresData         =    32
+    TemperatureSensors      =    45
+    
+    CanBUSFaultCount        =  2457
+    HDDebugText             = 0xFFF1
+    DGDebugText             = 0xFFF2
 
-    CanBUSFaultCount = 2457
-    HDDebugText = 0xFFF1
-    DGDebugText = 0xFFF2
+    AdjustBloodDialysateReq =    23
+    AdjustBloodDialysateRsp =    24
 
-    AdjustBloodDialysateReq = 23
-    AdjustBloodDialysateRsp = 24
+    AdjustDurationReq       =    22
+    AdjustDurationRsp       =    27
 
-    AdjustDurationReq = 22
-    AdjustDurationRsp = 27
-
-    AdjustUltrafiltrationStateReq = 16  # Req and Rsp are the same in this specific message
-
-    AdjustUltrafiltrationEditReq = 17
-    AdjustUltrafiltrationEditRsp = 19
-
+    AdjustUltrafiltrationStateReq   = 16 # Req and Rsp are the same in this specific message
+    AdjustUltrafiltrationEditReq    = 17
+    AdjustUltrafiltrationEditRsp    = 19
     AdjustUltrafiltrationConfirmReq = 21
     AdjustUltrafiltrationConfirmRsp = 46
 
-    TreatmentRanges = 26
+    TreatmentRanges         =    26
 
-    String = 65279
+    String                  = 65279
+    Acknow                  = 65535
+    AcknowGeneric           =     0 # Generic Acknowledgment is not a unique message ID and inherits its Id from the actual message. Zero is a placeholder
 
-    Acknow = 65535
 
-    AcknowGeneric = 0  # Generic Acknowledgment is not a unique message ID and inherits its Id from the actual message. Zero is a placeholder
-
-
 def send_acknowledge_HD():
+    """
+    the acknowledge from HD
+    :return: none
+    """
     subprocess.call(['cansend', 'can0', '020#A5.01.00.FF.FF.00.19.00'])
 
 
 def send_acknowledge_UI():
+    """
+    the acknowledge from UI
+    :return: none
+    """
     subprocess.call(['cansend', 'can0', '100#A5.01.00.FF.FF.00.19.00'])
 
 
 def send_CheckIn_DG():
+    """
+    check-in (keep alive) message from DG
+    :return: none
+    """
     subprocess.call(['cansend', 'can0', '010#A5.01.00.06.00.00.76.00'])
 
 
 def show_PowerOffDialog():
+    """
+    the message from HD to UI to show the power off dialog
+    :return: none
+    """
     subprocess.call(['cansend', 'can0', '020#A5.01.00.01.00.01.00.38'])
 
 
 def hide_PowerOffDialog():
+    """
+    the message from HD to UI to hide the power off dialog
+    :return: none
+    """
     subprocess.call(['cansend', 'can0', '020#A5.01.00.01.00.01.01.09'])
 
 
 def show_PowerOffNotificationDialog():
+    """
+    the message from HD to UI to shew the shutting down notipication box
+    :return: none
+    """
     subprocess.call(['cansend', 'can0', '040#A5.01.00.0E.00.00.24.00'])
 
 
 def show_PowerOffRejectionDialog():
+    """
+    the message from HD to UI to show the power off dialog
+    :return: none
+    """
     subprocess.call(['cansend', 'can0', '020#A5.01.00.01.00.01.02.5A'])
 
 
-##################################################################################################
-# After each multi-frame message put a 100ms sleep, time.sleep(0.1)                              #
-# it seems it's needed otherwise the test will check a value which has not been received yet.    #
-##################################################################################################
 def waitForMessageToBeSent():
-    time.sleep(0.050)  # 50ms
+    """
+    After each multi-frame message put a 100ms sleep, time.sleep(0.1)                              #
+    it seems it's needed otherwise the test will check a value which has not been received yet.    #
+    :return: none
+    """
+    time.sleep(0.050) # 50ms
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def buildHDDebugText(vText):
+    """
+    the debug text message from HD builder method
+    :param vText: (str) the debug text
+    :return: none
+    """
     len = 40
-    txt = messageBuilder.textToByte(vText, len)  # + 1 null term
-    msg = messageBuilder.buildMessage(GuiActionType.HDDebugText, 1 * (len + 1), False, txt)
+    txt = messageBuilder.textToByte(vText, len) # + 1 null term
+    msg = messageBuilder.buildMessage( GuiActionType.HDDebugText, 1 * (len + 1), False, txt)
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-def setHDDebugText(vText):
+def setHDDebugText  (vText):
+    """
+    the debug text message from HD setter/sender method
+    :param vText: (str) the debug text
+    :return: none
+    """
     frames = buildHDDebugText(vText)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '020#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def buildDGDebugText(vText):
+    """
+    the debug text message from DG builder method
+    :param vText: (str) the debug text
+    :return: none
+    """
     len = 40
-    txt = messageBuilder.textToByte(vText, len)  # + 1 null term
-    msg = messageBuilder.buildMessage(GuiActionType.DGDebugText, 1 * (len + 1), False, txt)
+    txt = messageBuilder.textToByte(vText, len) # + 1 null term
+    msg = messageBuilder.buildMessage( GuiActionType.DGDebugText, 1 * (len + 1), False, txt)
 
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-def setDGDebugText(vText):
+def setDGDebugText  (vText):
+    """
+    the debug text message from DG setter/sender method
+    :param vText: (str) the debug text
+    :return: none
+    """
     frames = buildDGDebugText(vText)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '070#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-def buildSetTreatmentParamRanges(vMinTreatmentDuration, vMaxTreatmentDuration, vMinUFVolume, vMaxUFVolume,
-                                 vMinDialysateFlowRate, vMaxDialysateFlowRate):
+def buildSetTreatmentParamRanges(vMinTreatmentDuration, vMaxTreatmentDuration, vMinUFVolume, vMaxUFVolume, vMinDialysateFlowRate, vMaxDialysateFlowRate):
+    """
+    the Treatment adjustment param ranges data message builder method
+     | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description                            | #1:(U32)                 | #2:(U32)                 | #3:(F32)                               | #4:(F32)                               | #5:(U32)                       | #6:(U32)                       |
+     |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:                           |:--:                      |:--:                      |:--:                                    |:--:                                    |:--:                            |:--:                            |
+     |0x1A00| 0x020  | 6   | 1/60 Hz| Y   | HD  | UI  | Treatment adjustment param ranges Data | \ref Data::mDuration_Min | \ref Data::mDuration_Max | \ref Data::mUltrafiltration_Volume_Min | \ref Data::mUltrafiltration_Volume_Max | \ref Data::mDialysate_Flow_Min | \ref Data::mDialysate_Flow_Max |
+    :param vMinTreatmentDuration: (int) Min Treatment Duration
+    :param vMaxTreatmentDuration: (int) Max Treatment Duration
+    :param vMinUFVolume: (float) Min UF Volume
+    :param vMaxUFVolume: (float) Max UF Volume
+    :param vMinDialysateFlowRate: (int) Min Dialysate Flow Rate
+    :param vMaxDialysateFlowRate: (int) Max Dialysate Flow Rate
+    :return: (str) built message frame(s)
+    """
     msg = messageBuilder.buildMessage(GuiActionType.TreatmentRanges, 4 * 6, True,
-                                      utils.toI32(vMinTreatmentDuration),
-                                      utils.toI32(vMaxTreatmentDuration),
-                                      utils.toF32(vMinUFVolume),
-                                      utils.toF32(vMaxUFVolume),
-                                      utils.toI32(vMinDialysateFlowRate),
-                                      utils.toI32(vMaxDialysateFlowRate)
-                                      )
+        utils.toI32(vMinTreatmentDuration),
+        utils.toI32(vMaxTreatmentDuration),
+        utils.toF32(vMinUFVolume         ),
+        utils.toF32(vMaxUFVolume         ),
+        utils.toI32(vMinDialysateFlowRate),
+        utils.toI32(vMaxDialysateFlowRate)
+    )
     return messageBuilder.toFrames(msg)
 
 
-def setTreatmentParamRanges(vMinTreatmentDuration, vMaxTreatmentDuration, vMinUFVolume, vMaxUFVolume,
-                            vMinDialysateFlowRate, vMaxDialysateFlowRate):
-    frames = buildSetTreatmentParamRanges(vMinTreatmentDuration, vMaxTreatmentDuration, vMinUFVolume, vMaxUFVolume,
-                                          vMinDialysateFlowRate, vMaxDialysateFlowRate)
+def setTreatmentParamRanges(vMinTreatmentDuration, vMaxTreatmentDuration, vMinUFVolume, vMaxUFVolume, vMinDialysateFlowRate, vMaxDialysateFlowRate):
+    """
+    the Treatment adjustment param ranges data message setter/sender method
+    :param vMinTreatmentDuration: (int) Min Treatment Duration
+    :param vMaxTreatmentDuration: (int) Max Treatment Duration
+    :param vMinUFVolume: (float) Min UF Volume
+    :param vMaxUFVolume: (float) Max UF Volume
+    :param vMinDialysateFlowRate: (int) Min Dialysate Flow Rate
+    :param vMaxDialysateFlowRate: (int) Max Dialysate Flow Rate
+    :return: none
+    """
+    frames = buildSetTreatmentParamRanges(vMinTreatmentDuration, vMaxTreatmentDuration, vMinUFVolume, vMaxUFVolume, vMinDialysateFlowRate, vMaxDialysateFlowRate)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '020#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
 def buildSetTreatmentBloodFlowRate(vFlowSetPt, vMeasFlow, vRotSpd, vMotSpd, vMCSpd, vMCCurr, vPWM):
+    """
+    the Blood Flow Data message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description     | #1:(S32)                 | #2:(F32)                 | #3:(F32)               | #4:(F32)               | #5:(F32)                  | #6:(F32)                    | #7:(F32)                 |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:    |:--:                      |:--:                      |:--:                    |:--:                    |:--:                       |:--:                         |:--:                      |
+    |0x0500| 0x040  | 7   | 1 Hz   | N   | HD  | All | Blood Flow Data | \ref Data::mFlowSetPoint | \ref Data::mMeasuredFlow | \ref Data::mRotorSpeed | \ref Data::mMotorSpeed | \ref Data::mMotorCtlSpeed | \ref Data::mMotorCtlCurrent | \ref Data::mPWMDutyCycle |
+    :param vFlowSetPt: (signed int) Flow Set Point
+    :param vMeasFlow: (float) Measured Flow
+    :param vRotSpd: (float) Rot Speed
+    :param vMotSpd: (float) Motor Speed
+    :param vMCSpd: (float) MC Speed
+    :param vMCCurr: (float) MC Current
+    :param vPWM: (float) PWM
+    :return: (str) built message frame(s)
+    """
     msg = messageBuilder.buildMessage(GuiActionType.BloodFlow, 4 * 7, False,
-                                      utils.toI32(vFlowSetPt),
-                                      utils.toF32(vMeasFlow),
-                                      utils.toF32(vRotSpd),
-                                      utils.toF32(vMotSpd),
-                                      utils.toF32(vMCSpd),
-                                      utils.toF32(vMCCurr),
-                                      utils.toF32(vPWM)
-                                      )
+        utils.toI32(vFlowSetPt  ),
+        utils.toF32(vMeasFlow   ),
+        utils.toF32(vRotSpd     ),
+        utils.toF32(vMotSpd     ),
+        utils.toF32(vMCSpd      ),
+        utils.toF32(vMCCurr     ),
+        utils.toF32(vPWM        )
+    )
     return messageBuilder.toFrames(msg)
 
 
 def setTreatmentBloodFlowRate(vFlowSetPt, vMeasFlow, vRotSpd, vMotSpd, vMCSpd, vMCCurr, vPWM):
+    """
+    the Blood Flow Data message setter/sender method
+    :param vFlowSetPt: (signed int) Flow Set Point
+    :param vMeasFlow: (float) Measured Flow
+    :param vRotSpd: (float) Rot Speed
+    :param vMotSpd: (float) Motor Speed
+    :param vMCSpd: (float) MC Speed
+    :param vMCCurr: (float) MC Current
+    :param vPWM: (float) PWM
+    :return: none
+    """
     frames = buildSetTreatmentBloodFlowRate(vFlowSetPt, vMeasFlow, vRotSpd, vMotSpd, vMCSpd, vMCCurr, vPWM)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '040#{}'.format(frame)])
     waitForMessageToBeSent()
+    
 
-
 def buildSetTreatmentDialysateFlowRate(vFlowSetPt, vMeasFlow, vRotSpd, vMotSpd, vMCSpd, vMCCurr, vPWM):
+    """
+    the Dialysate Flow Data message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description         | #1:(S32)      | #2:(F32)      | #3:(F32)    | #4:(F32)    | #5:(F32)       | #6:(F32)         | #7:(F32)      |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:        |:--:           |:--:           |:--:         |:--:         |:--:            |:--:              |:--:           |
+    |0x0800| 0x040  | 7   | 1 Hz   | N   | HD  | All | Dialysate Flow Data | mFlowSetPoint | mMeasuredFlow | mRotorSpeed | mMotorSpeed | mMotorCtlSpeed | mMotorCtlCurrent | mPWMDutyCycle |
+    :param vFlowSetPt: (signed int) Flow Set Point
+    :param vMeasFlow: (float) Measured Flow
+    :param vRotSpd: (float) Rot Speed
+    :param vMotSpd: (float) Motor Speed
+    :param vMCSpd: (float) MC Speed
+    :param vMCCurr: (float) MC Current
+    :param vPWM: (float) PWM
+    :return: (str) built message frame(s)
+    """
     msg = messageBuilder.buildMessage(GuiActionType.DialysateInletFlow, 4 * 7, False,
-                                      utils.toI32(vFlowSetPt),
-                                      utils.toF32(vMeasFlow),
-                                      utils.toF32(vRotSpd),
-                                      utils.toF32(vMotSpd),
-                                      utils.toF32(vMCSpd),
-                                      utils.toF32(vMCCurr),
-                                      utils.toF32(vPWM)
-                                      )
+        utils.toI32(vFlowSetPt),
+        utils.toF32(vMeasFlow),
+        utils.toF32(vRotSpd),
+        utils.toF32(vMotSpd),
+        utils.toF32(vMCSpd),
+        utils.toF32(vMCCurr),
+        utils.toF32(vPWM)
+    )
     return messageBuilder.toFrames(msg)
 
 
 def setTreatmentDialysateFlowRate(vFlowSetPt, vMeasFlow, vRotSpd, vMotSpd, vMCSpd, vMCCurr, vPWM):
+    """
+    the Dialysate Flow Data message setter/sender method
+    :param vFlowSetPt: (signed int) Flow Set Point
+    :param vMeasFlow: (float) Measured Flow
+    :param vRotSpd: (float) Rot Speed
+    :param vMotSpd: (float) Motor Speed
+    :param vMCSpd: (float) MC Speed
+    :param vMCCurr: (float) MC Current
+    :param vPWM: (float) PWM
+    :return: none
+    """
     frames = buildSetTreatmentDialysateFlowRate(vFlowSetPt, vMeasFlow, vRotSpd, vMotSpd, vMCSpd, vMCCurr, vPWM)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '040#{}'.format(frame)])
     waitForMessageToBeSent()
 
-
+    
 def buildTreatmentAdjustBloodDialysateResponse(vAccepted, vReason, vBloodRate, vDialysate):
+    """
+    the Blood/dialysate rate change Response message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description                          | #1:(U32)             | #2:(U32)           | #3:(U32)              | #4:(U32)                  |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:                         |:--:                  |:--:                |:--:                   |:--:                       |
+    |0x1800| 0x020  | 6   | Rsp    | Y   | HD  | UI  | Blood/dialysate rate change Response | \ref Data::mAccepted | \ref Data::mReason | \ref Data::mBloodRate | \ref Data::mDialysateRate |
+    :param vAccepted: (int) boolean accept/reject response
+    :param vReason: (int) rejection reason
+    :param vBloodRate: (int) Blood Flow Rate
+    :param vDialysate: (int) Dialysate Flow Rate
+    :return: (str) built message frame(s)
+    """
     msg = messageBuilder.buildMessage(GuiActionType.AdjustBloodDialysateRsp, 4 * 4, True,
-                                      utils.toI32(vAccepted),
-                                      utils.toI32(vReason),
-                                      utils.toI32(vBloodRate),
-                                      utils.toI32(vDialysate)
-                                      )
+        utils.toI32(vAccepted),
+        utils.toI32(vReason),
+        utils.toI32(vBloodRate),
+        utils.toI32(vDialysate)
+    )
     return messageBuilder.toFrames(msg)
 
 
 def sendTreatmentAdjustBloodDialysateResponse(vAccepted, vReason, vBloodRate, vDialysate):
+    """
+    the Blood/dialysate rate change Response message setter/sender method
+    :param vAccepted: (int) boolean accept/reject response
+    :param vReason: (int) rejection reason
+    :param vBloodRate: (int) Blood Flow Rate
+    :param vDialysate: (int) Dialysate Flow Rate
+    :return: none
+    """
     frames = buildTreatmentAdjustBloodDialysateResponse(vAccepted, vReason, vBloodRate, vDialysate)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
@@ -234,16 +379,35 @@
 
 
 def buildTreatmentAdjustDurationResponse(vAccepted, vReason, vDuration, vUltrafiltration):
+    """
+    the Treatment Duration change Response message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description                        | #1:(U32)             | #2:(U32)           | #3:(U32)             | #5:(F32)             |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:                       |:--:                  |:--:                |:--:                  |:--:                  |
+    |0x1B00| 0x020  | 6   | Rsp    | Y   | HD  | UI  | Treatment Duration change Response | \ref Data::mAccepted | \ref Data::mReason | \ref Data::mDuration | \ref Data::mUFVolume |
+    :param vAccepted: (int) boolean accept/reject response
+    :param vReason: (int) rejection reason
+    :param vDuration: (int) Treatment Duration
+    :param vUltrafiltration: (float) Ultrafiltration Volume
+    :return: (str) built message frame(s)
+    """
     msg = messageBuilder.buildMessage(GuiActionType.AdjustDurationRsp, 4 * 4, True,
-                                      utils.toI32(vAccepted),
-                                      utils.toI32(vReason),
-                                      utils.toI32(vDuration),
-                                      utils.toF32(vUltrafiltration)
-                                      )
+        utils.toI32(vAccepted),
+        utils.toI32(vReason),
+        utils.toI32(vDuration),
+        utils.toF32(vUltrafiltration)
+    )
     return messageBuilder.toFrames(msg)
 
 
 def sendTreatmentAdjustDurationResponse(vAccepted, vReason, vDuration, vUltrafiltration):
+    """
+    the Treatment Duration change Response message setter/sender method
+    :param vAccepted: (int) boolean accept/reject response
+    :param vReason: (int) rejection reason
+    :param vDuration: (int) Treatment Duration
+    :param vUltrafiltration: (float) Ultrafiltration Volume
+    :return: none
+    """
     frames = buildTreatmentAdjustDurationResponse(vAccepted, vReason, vDuration, vUltrafiltration)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
@@ -252,13 +416,27 @@
 
 
 def buildTreatmentAdjustUltrafiltrationStateResponse(vState):
-    msg = messageBuilder.buildMessage(GuiActionType.AdjustUltrafiltrationStateReq, 1 * 4, False,
-                                      utils.toI32(vState)
-                                      )
+    """
+    the Treatment ultrafiltration adjustment response message builder method
+    | MSG  | CAN ID | M.Box | Type | Ack | Src | Dest | Description              | #1:(U08)  |
+    |:----:|:------:|:-----:|:----:|:---:|:---:|:----:|:-----------:             |:--:       |
+    |0x1000| 0x100  | 9     | Rsp  |  N  | HD  | UI   | Generic response ACK/NAK | mAccepted |
+    :param vState: (-128<int<127) Ultrafiltration State
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage(GuiActionType.AdjustUltrafiltrationStateReq, 1 * 4 , False,
+        utils.toI32(vState)
+    )
     return messageBuilder.toFrames(msg)
 
 
 def setTreatmentAdjustUltrafiltrationStateResponse(vState):
+    """
+    the Treatment ultrafiltration adjustment response message setter/sender method
+    this is actually the Generic response ACK/NAK message
+    :param vState: (-128<int<127) Ultrafiltration State
+    :return: none
+    """
     frames = buildTreatmentAdjustUltrafiltrationStateResponse(vState)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
@@ -267,39 +445,77 @@
 
 
 def setTreatmentAdjustUltrafiltrationAccepted():
-    setTreatmentAdjustUltrafiltrationStateResponse(EResponse.Accepted)
+    """
+    a convenient method for setTreatmentAdjustUltrafiltrationStateResponse which sends accept true
+    :return: none
+    """
+    setTreatmentAdjustUltrafiltrationStateResponse( EResponse.Accepted )
 
 
 def setTreatmentAdjustUltrafiltrationRejected():
-    setTreatmentAdjustUltrafiltrationStateResponse(EResponse.Rejected)
+    """
+    a convenient method for setTreatmentAdjustUltrafiltrationStateResponse which sends accept false
+    :return: none
+    """
+    setTreatmentAdjustUltrafiltrationStateResponse( EResponse.Rejected )
 
 
-def buildTreatmentAdjustUltrafiltrationEditResponse(vAccepted, vReason, vVolume, vDuration, vDurationDiff, vRate,
-                                                    vRateDiff, vRateOld):
-    msg = messageBuilder.buildMessage(GuiActionType.AdjustUltrafiltrationEditRsp, 8 * 4, True,
-                                      utils.toI32(vAccepted),
-                                      utils.toI32(vReason),
-                                      utils.toF32(vVolume),
-                                      utils.toI32(vDuration),
-                                      utils.toI32(vDurationDiff),
-                                      utils.toF32(vRate),
-                                      utils.toF32(vRateDiff),
-                                      utils.toF32(vRateOld)
-                                      )
+def buildTreatmentAdjustUltrafiltrationEditResponse(vAccepted, vReason, vVolume, vDuration, vDurationDiff, vRate, vRateDiff, vRateOld):
+    """
+    the ultrafiltration volume change response message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description             | #1:(U32)             | #2:(U32)           | #1:(U32)             | #2:(U32)           | #3:(F32)           | #4:(U32)             | #5:(F32)         | #6:(U32)                 | #7:(U32)             | #8:(F32)            |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:            |:--:                  |:--:                |:--:                  |:--:                |:--:                |:--:                  |:--:              |:--:                      |:--:                  |:--:                 |
+    |0x1300| 0x020  | 6   | Rsp    | Y   | HD  | UI  | UF Vol. Change Response | \ref Data::mAccepted | \ref Data::mReason | \ref Data::mAccepted | \ref Data::mReason | \ref Data::mVolume | \ref Data::mDuration | \ref Data::mRate | \ref Data::mDurationDiff | \ref Data::mRateDiff | \ref Data::mRateOld |
+    :param vAccepted: (int) boolean accept/reject response
+    :param vReason: (int) rejection reason
+    :param vVolume: (float) Ultrafiltration Volume
+    :param vDuration: (int) Treatment Duration
+    :param vDurationDiff: (int) Duration Difference
+    :param vRate: (float) Ultrafiltration Rate
+    :param vRateDiff: (float) Ultrafiltration Rate Difference
+    :param vRateOld: (float) Ultrafiltration Rate Old
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage(GuiActionType.AdjustUltrafiltrationEditRsp, 8 * 4 , True,
+        utils.toI32(vAccepted),
+        utils.toI32(vReason),
+        utils.toF32(vVolume),
+        utils.toI32(vDuration),
+        utils.toI32(vDurationDiff),
+        utils.toF32(vRate),
+        utils.toF32(vRateDiff),
+        utils.toF32(vRateOld)
+    )
     return messageBuilder.toFrames(msg)
 
 
-def setTreatmentAdjustUltrafiltrationEditResponse(vAccepted, vReason, vVolume, vDuration, vDurationDiff, vRate,
-                                                  vRateDiff, vRateOld):
-    frames = buildTreatmentAdjustUltrafiltrationEditResponse(vAccepted, vReason, vVolume, vDuration, vDurationDiff,
-                                                             vRate, vRateDiff, vRateOld)
+def setTreatmentAdjustUltrafiltrationEditResponse(vAccepted, vReason, vVolume, vDuration, vDurationDiff, vRate, vRateDiff, vRateOld):
+    """
+    the ultrafiltration volume change response message setter/sender method
+    :param vAccepted: (int) boolean accept/reject response
+    :param vReason: (int) rejection reason
+    :param vVolume: (float) Ultrafiltration Volume
+    :param vDuration: (int) Treatment Duration
+    :param vDurationDiff: (int) Duration Difference
+    :param vRate: (float) Ultrafiltration Rate
+    :param vRateDiff: (float) Ultrafiltration Rate Difference
+    :param vRateOld: (float) Ultrafiltration Rate Old
+    :return: none
+    """
+    frames = buildTreatmentAdjustUltrafiltrationEditResponse(vAccepted, vReason, vVolume, vDuration, vDurationDiff, vRate, vRateDiff, vRateOld)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '020#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
 def setTreatmentAdjustUltrafiltrationEditRejected(vReason):
+    """
+    a convenient method for setTreatmentAdjustUltrafiltrationEditResponse which only sends a rejection reason
+    and sends other values all as zero
+    :param vReason: (int) rejection reason
+    :return: none
+    """
     frames = buildTreatmentAdjustUltrafiltrationEditResponse(0, vReason, 0, 0, 0, 0, 0, 0)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
@@ -308,25 +524,52 @@
 
 
 def buildTreatmentAdjustUltrafiltrationConfirmResponse(vAccepted, vReason, vVolume, vDuration, vRate):
-    msg = messageBuilder.buildMessage(GuiActionType.AdjustUltrafiltrationConfirmRsp, 5 * 4, True,
-                                      utils.toI32(vAccepted),
-                                      utils.toI32(vReason),
-                                      utils.toF32(vVolume),
-                                      utils.toI32(vDuration),
-                                      utils.toF32(vRate)
-                                      )
+    """
+    the ultrafiltratin volume Change Confirmation Response message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description                          | #1:(U32)             | #2:(U32)           | #3:(F32)           | #4:(U32)             | #5:(F32)         |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:                         |:--:                  |:--:                |:--:                |:--:                  |:--:              |
+    |0x2E00| 0x020  | 6   | Rsp    | Y   | HD  | UI  | UF Vol. Change Confirmation Response | \ref Data::mAccepted | \ref Data::mReason | \ref Data::mVolume | \ref Data::mDuration | \ref Data::mRate |
+    :param vAccepted: (int) boolean accept/reject response
+    :param vReason: (int) rejection reason
+    :param vVolume: (float) Ultrafiltration Volume
+    :param vDuration: (int) Treatment Duration
+    :param vRate: (float) Ultrafiltration Rate
+    :return:  built message frame(s)
+    """
+    msg = messageBuilder.buildMessage(GuiActionType.AdjustUltrafiltrationConfirmRsp, 5 * 4 , True,
+        utils.toI32(vAccepted),
+        utils.toI32(vReason),
+        utils.toF32(vVolume),
+        utils.toI32(vDuration),
+        utils.toF32(vRate)
+    )
     return messageBuilder.toFrames(msg)
 
 
-def setTreatmentAdjustUltrafiltrationConfirmResponse(vAccepted, vReason, vVolume, vDuration, vRate):
+def setTreatmentAdjustUltrafiltrationConfirmResponse         (vAccepted, vReason, vVolume, vDuration, vRate):
+    """
+    the ultrafiltration volume Change Confirmation Response message setter/sender method
+    :param vAccepted: (int) boolean accept/reject response
+    :param vReason: (int) rejection reason
+    :param vVolume: (float) Ultrafiltration Volume
+    :param vDuration: (int) Treatment Duration
+    :param vRate: (float) Ultrafiltration Rate
+    :return: none
+    """
     frames = buildTreatmentAdjustUltrafiltrationConfirmResponse(vAccepted, vReason, vVolume, vDuration, vRate)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '020#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
-def setTreatmentAdjustUltrafiltrationConfirmRejected(vReason):
+def setTreatmentAdjustUltrafiltrationConfirmRejected         (   vReason         ):
+    """
+    a convenient method for setTreatmentAdjustUltrafiltrationConfirmResponse which only sends a rejection reason
+    and sends other values all as zero
+    :param vReason: (int) rejection reason
+    :return: none
+    """
     frames = buildTreatmentAdjustUltrafiltrationConfirmResponse(0, vReason, 0, 0, 0)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
@@ -335,337 +578,575 @@
 
 
 def buildTreatmentTime(vSecsTotal, vSecsElap, vSecsRem):
+    """
+    the Treatment Time Data message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description         | #1:(U32)            | #2:(U32)            | #3:(U32)              |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:        |:--:                 |:--:                 |:--:                   |
+    |0x0D00| 0x040  | 7   | 1 Hz   | N   | HD  | All | Treatment Time Data | \ref Data::mTotal   | \ref Data::mElapsed | \ref Data::mRemaining |
+    :param vSecsTotal: (int) Treatment Total Duration in Seconds
+    :param vSecsElap: (int) Treatment Total Elapsed Time in Seconds
+    :param vSecsRem: (int) Treatment Remaining Time in Seconds
+    :return: (str) built message frame(s)
+    """
     msg = messageBuilder.buildMessage(GuiActionType.TreatmentTime, 3 * 4, False,
-                                      utils.toI32(vSecsTotal),
-                                      utils.toI32(vSecsElap),
-                                      utils.toI32(vSecsRem)
-                                      )
+        utils.toI32(vSecsTotal),
+        utils.toI32(vSecsElap),
+        utils.toI32(vSecsRem)
+    )
     return messageBuilder.toFrames(msg)
 
 
-def setTreatmentTime(vSecsTotal, vSecsElap, vSecsRem=None):
-    if vSecsRem == None:
+def setTreatmentTime(vSecsTotal, vSecsElap, vSecsRem = None):
+    """
+    the Treatment Time Data message setter/sender method
+    :param vSecsTotal: (int) Treatment Total Duration in Seconds
+    :param vSecsElap: (int) Treatment Total Elapsed Time in Seconds
+    :param vSecsRem: (int) Treatment Remaining Time in Seconds
+    :return: none
+    """
+    if vSecsRem is None:
         vSecsRem = vSecsTotal - vSecsElap
     frames = buildTreatmentTime(vSecsTotal, vSecsElap, vSecsRem)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '040#{}'.format(frame)])
     waitForMessageToBeSent()
 
-
+    
 def buildSetTreatmentUltrafiltration(vRefUFVol, vMeasUFVol, vRotSpd, vMotSpd, vMCSpd, vMCCurr, vPWM):
+    """
+    the Outlet Flow Data message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description      | #1:(F32)             | #2:(F32)              | #3:(F32)               | #4:(F32)               | #5:(F32)                  | #6:(F32)                    | #7:(F32)               |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:     |:--:                  |:--:                   |:--:                    |:--:                    |:--:                       |:--:                         |:--:                    |
+    |0x0B00| 0x040  | 7   | 1 Hz   | N   | HD  | All | Outlet Flow Data | \ref Data::mRefUFVol | \ref Data::mMeasUFVol | \ref Data::mRotorSpeed | \ref Data::mMotorSpeed | \ref Data::mMotorCtlSpeed | \ref Data::mMotorCtlCurrent | \ref Data::mPWMDtCycle |
+    :param vRefUFVol: (float) Ref UF Volume
+    :param vMeasUFVol: (float) Measured UF Volume
+    :param vRotSpd: (float) Rot Speed
+    :param vMotSpd: (float) Motor Speed
+    :param vMCSpd: (float) MC Speed
+    :param vMCCurr: (float) MC Current
+    :param vPWM: (float) PWM
+    :return: (str) built message frame(s)
+    """
     msg = messageBuilder.buildMessage(GuiActionType.DialysateOutletFlow, 4 * 7, False,
-                                      utils.toF32(vRefUFVol),
-                                      utils.toF32(vMeasUFVol),
-                                      utils.toF32(vRotSpd),
-                                      utils.toF32(vMotSpd),
-                                      utils.toF32(vMCSpd),
-                                      utils.toF32(vMCCurr),
-                                      utils.toF32(vPWM)
-                                      )
+        utils.toF32(vRefUFVol),
+        utils.toF32(vMeasUFVol),
+        utils.toF32(vRotSpd),
+        utils.toF32(vMotSpd),
+        utils.toF32(vMCSpd),
+        utils.toF32(vMCCurr),
+        utils.toF32(vPWM)
+    )
     return messageBuilder.toFrames(msg)
 
 
 def setTreatmentUltrafiltration(vRefUFVol, vMeasUFVol, vRotSpd, vMotSpd, vMCSpd, vMCCurr, vPWM):
-    frames = buildSetTreatmentUltrafiltration(vRefUFVol, vMeasUFVol, vRotSpd, vMotSpd, vMCSpd, vMCCurr, vPWM)
+    """
+    the Outlet Flow Data message setter/sender method
+    :param vRefUFVol: (float) Ref UF Volume
+    :param vMeasUFVol: (float) Measured UF Volume
+    :param vRotSpd: (float) Rot Speed
+    :param vMotSpd: (float) Motor Speed
+    :param vMCSpd: (float) MC Speed
+    :param vMCCurr: (float) MC Current
+    :param vPWM: (float) PWM
+    :return: none
+    """
+    frames = buildSetTreatmentUltrafiltration(vRefUFVol, vMeasUFVol, vRotSpd, vMotSpd, vMCSpd, vMCCurr, vPWM    )
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '040#{}'.format(frame)])
     waitForMessageToBeSent()
 
-
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x0009,040,N,HD,All,PressureOcclusionData,(F32)^ArterialPressure,(F32)^VenousPressure,(F32)^BloodPumpOcclusion,(F32)^DialysateInletPumpOcclusion,(F32)^DialysateOutletPumpOcclusion
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-def buildPressureOcclusionData(vArterialPressure, vVenousPressure, vBloodPumpOcclusion, vDialysateInletPumpOcclusion,
-                               vDialysateOutletPumpOcclusion):
-    msg = messageBuilder.buildMessage(0x0009, 4 + 4 + 4 + 4 + 4, False,
-                                      utils.toF32(vArterialPressure),
-                                      utils.toF32(vVenousPressure),
-                                      utils.toF32(vBloodPumpOcclusion),
-                                      utils.toF32(vDialysateInletPumpOcclusion),
-                                      utils.toF32(vDialysateOutletPumpOcclusion))
+    
+def buildPressureOcclusionData(vArterialPressure, vVenousPressure, vBloodPumpOcclusion, vDialysateInletPumpOcclusion, vDialysateOutletPumpOcclusion):
+    """
+    the Pressure/Occlusion Data messages builder mehtod
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description            | #1:(F32)                     | #2:(F32)                   | #3:(F32)                       | #4:(F32)                                | #5:(F32)                                 |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:           |:--:                          |:--:                        |:--:                            |:--:                                     |:--:                                      |
+    |0x0900| 0x040  | 7   | 1 Hz   | N   | HD  | All | PressureOcclusion Data | \ref Data::mArterialPressure | \ref Data::mVenousPressure | \ref Data::mBloodPumpOcclusion | \ref Data::mDialysateInletPumpOcclusion | \ref Data::mDialysateOutletPumpOcclusion |
+    :param vArterialPressure: (float) Arterial Pressure
+    :param vVenousPressure: (float) Venous Pressure
+    :param vBloodPumpOcclusion: (float) Blood Pump Occlusion
+    :param vDialysateInletPumpOcclusion: (float) Dialysate Inlet Pump Occlusion
+    :param vDialysateOutletPumpOcclusion: (float) Dialysate Outlet Pump Occlusion
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x0009, 4+4+4+4+4, False,
+        utils.toF32(vArterialPressure            ),
+        utils.toF32(vVenousPressure              ),
+        utils.toF32(vBloodPumpOcclusion          ),
+        utils.toF32(vDialysateInletPumpOcclusion ),
+        utils.toF32(vDialysateOutletPumpOcclusion))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-def setPressureOcclusionData(vArterialPressure, vVenousPressure, vBloodPumpOcclusion, vDialysateInletPumpOcclusion,
-                             vDialysateOutletPumpOcclusion):
-    frames = buildPressureOcclusionData(vArterialPressure, vVenousPressure, vBloodPumpOcclusion,
-                                        vDialysateInletPumpOcclusion, vDialysateOutletPumpOcclusion)
+def setPressureOcclusionData(vArterialPressure, vVenousPressure, vBloodPumpOcclusion, vDialysateInletPumpOcclusion, vDialysateOutletPumpOcclusion):
+    """
+    the Pressure/Occlusion Data messages setter/sender mehtod
+    :param vArterialPressure: (float) Arterial Pressure
+    :param vVenousPressure: (float) Venous Pressure
+    :param vBloodPumpOcclusion: (float) Blood Pump Occlusion
+    :param vDialysateInletPumpOcclusion: (float) Dialysate Inlet Pump Occlusion
+    :param vDialysateOutletPumpOcclusion: (float) Dialysate Outlet Pump Occlusion
+    :return: none
+    """
+    frames = buildPressureOcclusionData(vArterialPressure, vVenousPressure, vBloodPumpOcclusion, vDialysateInletPumpOcclusion, vDialysateOutletPumpOcclusion)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '040#{}'.format(frame)])
     waitForMessageToBeSent()
 
-
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x001F,080,N,DG,All,DGROPumpData,(U32)^SetPtPressure,(F32)^FlowRate,(F32)^PWM
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    
 def buildDGROPumpData(vSetPtPressure, vFlowRate, vPWM):
-    msg = messageBuilder.buildMessage(0x001F, 4 + 4 + 4, False,
-                                      utils.toI32(vSetPtPressure),
-                                      utils.toF32(vFlowRate),
-                                      utils.toF32(vPWM))
+    """
+    the DG RO Pump Data message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description     | #1:(U32)             | #2:(F32)             | #3:(F32)        |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:    |:--:                  |:--:                  |:--:             |
+    |0x1F00| 0x080  | 8   | 1 Hz   | N   | DG  | All | DG RO Pump Data | \ref Data::mPressure | \ref Data::mFlowRate | \ref Data::mPWM |    :param vSetPtPressure:
+    :param vSetPtPressure: (int) set Point Pressure
+    :param vFlowRate: (float) Flow Rate
+    :param vPWM: (float) PWM
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x001F, 4+4+4, False,
+        utils.toI32(vSetPtPressure),
+        utils.toF32(vFlowRate     ),
+        utils.toF32(vPWM          ))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def setDGROPumpData(vSetPtPressure, vFlowRate, vPWM):
+    """
+    the DG RO Pump Data message setter/sender method
+    :param vSetPtPressure: (int) set Point Pressure
+    :param vFlowRate: (float) Flow Rate
+    :param vPWM: (float) PWM
+    :return: none
+    """
     frames = buildDGROPumpData(vSetPtPressure, vFlowRate, vPWM)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '080#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x0020,080,N,DG,All,DGPressuresData,(F32)^ROInletPSI,(F32)^ROOutletPSI,(F32)^DrainInletPSI,(F32)^DrainOutletPSI
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def buildDGPressuresData(vROInletPSI, vROOutletPSI, vDrainInletPSI, vDrainOutletPSI):
-    msg = messageBuilder.buildMessage(0x0020, 4 + 4 + 4 + 4, False,
-                                      utils.toF32(vROInletPSI),
-                                      utils.toF32(vROOutletPSI),
-                                      utils.toF32(vDrainInletPSI),
-                                      utils.toF32(vDrainOutletPSI))
+    """
+    the DG Pressures Data message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description       | #1:(F32)               | #2:(F32)                | #3:(F32)                  | #4:(F32)                   |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:      |:--:                    |:--:                     |:--:                       |:--:                        |
+    |0x2000| 0x080  | 8   | 1 Hz   | N   | DG  | All | DG Pressures Data | \ref Data::mROInletPSI | \ref Data::mROOutletPSI | \ref Data::mDrainInletPSI | \ref Data::mDrainOutletPSI |
+    :param vROInletPSI: (float) RO Inlet PSI
+    :param vROOutletPSI: (float) RO Outlet PSI
+    :param vDrainInletPSI: (float) Drain Inlet PSI
+    :param vDrainOutletPSI: (float) Drain Outlet PSI
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x0020, 4+4+4+4, False,
+        utils.toF32(vROInletPSI    ),
+        utils.toF32(vROOutletPSI   ),
+        utils.toF32(vDrainInletPSI ),
+        utils.toF32(vDrainOutletPSI))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def setDGPressuresData(vROInletPSI, vROOutletPSI, vDrainInletPSI, vDrainOutletPSI):
+    """
+    the DG Pressures Data message setter/sender method
+    :param vROInletPSI: (float) RO Inlet PSI
+    :param vROOutletPSI: (float) RO Outlet PSI
+    :param vDrainInletPSI: (float) Drain Inlet PSI
+    :param vDrainOutletPSI: (float) Drain Outlet PSI
+    :return: none
+    """
     frames = buildDGPressuresData(vROInletPSI, vROOutletPSI, vDrainInletPSI, vDrainOutletPSI)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '080#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x0024,080,N,DG,All,DGDrainPumpData,(U32)^SetPtRPM,(U32)^DACValue
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def buildDGDrainPumpData(vSetPtRPM, vDACValue):
-    msg = messageBuilder.buildMessage(0x0024, 4 + 4, False,
-                                      utils.toI32(vSetPtRPM),
-                                      utils.toI32(vDACValue))
+    """
+    the DG Drain Pump Data message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description        | #1:(U32)        | #2:(U32)        |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:       |:--:             |:--:             |
+    |0x2400| 0x080  | 8   | 1 Hz   | N   | DG  | All | DG Drain Pump Data | \ref Data::mRPM | \ref Data::mDAC |
+    :param vSetPtRPM: (int) Set Point RPM
+    :param vDACValue: (int) DAC Value
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x0024, 4+4, False,
+        utils.toI32(vSetPtRPM),
+        utils.toI32(vDACValue))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def setDGDrainPumpData(vSetPtRPM, vDACValue):
+    """
+    the DG Drain Pump Data message setter/sender method
+    :param vSetPtRPM: (int) Set Point RPM
+    :param vDACValue: (int) DAC Value
+    :return: none
+    """
     frames = buildDGDrainPumpData(vSetPtRPM, vDACValue)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '080#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x0027,080,N,DG,All,DGOperationMode,(U32)^DGOpMode
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def buildDGOperationMode(vDGOpMode):
-    msg = messageBuilder.buildMessage(0x0027, 4, False,
-                                      utils.toI32(vDGOpMode))
+    """
+    the DG Operation Mode Data message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description            | #1:(U32)           |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:           |:--:                |
+    |0x2700| 0x080  | 8   | 1 Hz   | N   | DG  | All | DG Operation Mode Data | \ref Data::mOpMode |
+    :param vDGOpMode: (int) DG Operation Mode
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x0027, 4, False,
+        utils.toI32(vDGOpMode))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def setDGOperationMode(vDGOpMode):
+    """
+    the DG Operation Mode Data message setter/sender method
+    :param vDGOpMode: (int) DG Operation Mode
+    :return: none
+    """
     frames = buildDGOperationMode(vDGOpMode)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '080#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x0028,080,N,DG,All,DGReservoirData,(U32)^ActiveReservoir,(U32)^FillToVolML,(U32)^DrainToVolML
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def buildDGReservoirData(vActiveReservoir, vFillToVolML, vDrainToVolML):
-    msg = messageBuilder.buildMessage(0x0028, 4 + 4 + 4, False,
-                                      utils.toI32(vActiveReservoir),
-                                      utils.toI32(vFillToVolML),
-                                      utils.toI32(vDrainToVolML))
+    """
+    the DG Reservoir Data message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description       | #1:(U32)                    | #2:(U32)              | #3:(U32)               |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:      |:--:                         |:--:                   |:--:                    |
+    |0x2800| 0x080  | 8   | 1 Hz   | N   | DG  | All | DG Reservoir Data | \ref Data::mActiveReservoir | \ref Data::mFillToVol | \ref Data::mDrainToVol |
+    :param vActiveReservoir: (int) Active Reservoir
+    :param vFillToVolML: (int) Fill To Volume ML
+    :param vDrainToVolML: (int) Drain To Vol ML
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x0028, 4+4+4, False,
+        utils.toI32(vActiveReservoir),
+        utils.toI32(vFillToVolML    ),
+        utils.toI32(vDrainToVolML   ))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def setDGReservoirData(vActiveReservoir, vFillToVolML, vDrainToVolML):
+    """
+    the DG Reservoir Data message setter/sender method
+    :param vActiveReservoir: (int) Active Reservoir
+    :param vFillToVolML: (int) Fill To Volume ML
+    :param vDrainToVolML: (int) Drain To Vol ML
+    :return: none
+    """
     frames = buildDGReservoirData(vActiveReservoir, vFillToVolML, vDrainToVolML)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '080#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x002A,080,N,DG,All,DGValvesStates,(U16)^ValvesStates
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def buildDGValvesStates(vValvesStates):
-    msg = messageBuilder.buildMessage(0x002A, 2, False,
-                                      utils.toI16(vValvesStates))
+    """
+    the DG Valves States Data message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description           | #1:(U16)            |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:          |:--:                 |
+    |0x2A00| 0x080  | 8   | 2 Hz   | N   | DG  | All | DG Valves States Data | \ref Data::mStates  |
+    :param vValvesStates: (int)Valves states
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x002A, 2, False,
+        utils.toI16(vValvesStates))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def setDGValvesStates(vValvesStates):
+    """
+    the DG Valves States Data message setter/sender method
+    :param vValvesStates: (int)Valves states
+    :return: none
+    """
     frames = buildDGValvesStates(vValvesStates)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '080#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x002C,080,N,DG,All,DGHeatersData,(U32)^MainPriMaryDC,(U32)^SmallPrimaryDC,(U32)^TrimmerDC
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def buildDGHeatersData(vMainPriMaryDC, vSmallPrimaryDC, vTrimmerDC):
-    msg = messageBuilder.buildMessage(0x002C, 4 + 4 + 4, False,
-                                      utils.toI32(vMainPriMaryDC),
-                                      utils.toI32(vSmallPrimaryDC),
-                                      utils.toI32(vTrimmerDC))
+    """
+    the DG Heaters Data message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description     | #1:(U32)                  | #2:(U32)                   | #3:(U32)              |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:    |:--:                       |:--:                        |:--:                   |
+    |0x2C00| 0x080  | 8   | 2 Hz   | N   | DG  | All | DG Heaters Data | \ref Data::mMainPrimaryDC | \ref Data::mSmallPrimaryDC | \ref Data::mTrimmerDC |
+    :param vMainPriMaryDC: (int) Main PriMary DC
+    :param vSmallPrimaryDC: (int) Small Primary DC
+    :param vTrimmerDC: (int) Trimmer DC
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x002C, 4+4+4, False,
+        utils.toI32(vMainPriMaryDC ),
+        utils.toI32(vSmallPrimaryDC),
+        utils.toI32(vTrimmerDC     ))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def setDGHeatersData(vMainPriMaryDC, vSmallPrimaryDC, vTrimmerDC):
+    """
+    the DG Heaters Data message setter/sender method
+    :param vMainPriMaryDC: (int) Main PriMary DC
+    :param vSmallPrimaryDC: (int) Small Primary DC
+    :param vTrimmerDC: (int) Trimmer DC
+    :return: none
+    """
     frames = buildDGHeatersData(vMainPriMaryDC, vSmallPrimaryDC, vTrimmerDC)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '080#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x000C,080,N,DG,All,DGLoadCellReadingsData,(F32)^Rs1Prim,(F32)^Rs1Bkup,(F32)^Rs2Prim,(F32)^Rs2Bkup
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def buildDGLoadCellReadingsData(vRs1Prim, vRs1Bkup, vRs2Prim, vRs2Bkup):
-    msg = messageBuilder.buildMessage(0x000C, 4 + 4 + 4 + 4, False,
-                                      utils.toF32(vRs1Prim),
-                                      utils.toF32(vRs1Bkup),
-                                      utils.toF32(vRs2Prim),
-                                      utils.toF32(vRs2Bkup))
+    """
+    the DG Load Cell Readings Data message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description                | #1:(F32)                   | #2:(F32)                   | #3:(F32)                   | #4:(F32)                   |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:               |:--:                        |:--:                        |:--:                        |:--:                        |
+    |0x0C00| 0x080  | 8   | 10 Hz  | N   | DG  | All | DG Load Cell Readings Data | \ref Data::mReservoir1Prim | \ref Data::mReservoir1Bkup | \ref Data::mReservoir2Prim | \ref Data::mReservoir2Bkup |
+    :param vRs1Prim: (float) Reservoir 1 Primary
+    :param vRs1Bkup: (float) Reservoir 1 Backup
+    :param vRs2Prim: (float) Reservoir 2 Primary
+    :param vRs2Bkup: (float) Reservoir 2 Backup
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x000C, 4+4+4+4, False,
+        utils.toF32(vRs1Prim),
+        utils.toF32(vRs1Bkup),
+        utils.toF32(vRs2Prim),
+        utils.toF32(vRs2Bkup))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def setDGLoadCellReadingsData(vRs1Prim, vRs1Bkup, vRs2Prim, vRs2Bkup):
+    """
+    the DG Load Cell Readings Data message setter/sender method
+    :param vRs1Prim: (float) Reservoir 1 Primary
+    :param vRs1Bkup: (float) Reservoir 1 Backup
+    :param vRs2Prim: (float) Reservoir 2 Primary
+    :param vRs2Bkup: (float) Reservoir 2 Backup
+    :return: none
+    """
     frames = buildDGLoadCellReadingsData(vRs1Prim, vRs1Bkup, vRs2Prim, vRs2Bkup)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '080#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x002D,080,N,DG,All,DGTemperaturesData,(F32)^InletPrimaryHeater,(F32)^OutletPrimaryHeater,(F32)^ConductivitySensor1,(F32)^ConductivitySensor2,(F32)^OutletRedundancy,(F32)^InletDialysate,(F32)^PrimaryHeaterThermocouple,(F32)^TrimmerHeaterThermocouple,(F32)^PrimaryHeaterColdJunction,(F32)^TrimmerHeaterColdJunction,(F32)^PrimaryHeaterInternalTemperature,(F32)^TrimmerHeaterInternalTemperature
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-def buildDGTemperaturesData(vInletPrimaryHeater, vOutletPrimaryHeater, vConductivitySensor1, vConductivitySensor2,
-                            vOutletRedundancy, vInletDialysate, vPrimaryHeaterThermocouple, vTrimmerHeaterThermocouple,
-                            vPrimaryHeaterColdJunction, vTrimmerHeaterColdJunction, vPrimaryHeaterInternalTemperature,
-                            vTrimmerHeaterInternalTemperature):
-    msg = messageBuilder.buildMessage(0x002D, 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, False,
-                                      utils.toF32(vInletPrimaryHeater),
-                                      utils.toF32(vOutletPrimaryHeater),
-                                      utils.toF32(vConductivitySensor1),
-                                      utils.toF32(vConductivitySensor2),
-                                      utils.toF32(vOutletRedundancy),
-                                      utils.toF32(vInletDialysate),
-                                      utils.toF32(vPrimaryHeaterThermocouple),
-                                      utils.toF32(vTrimmerHeaterThermocouple),
-                                      utils.toF32(vPrimaryHeaterColdJunction),
-                                      utils.toF32(vTrimmerHeaterColdJunction),
-                                      utils.toF32(vPrimaryHeaterInternalTemperature),
-                                      utils.toF32(vTrimmerHeaterInternalTemperature))
+def buildDGTemperaturesData(vInletPrimaryHeater, vOutletPrimaryHeater, vConductivitySensor1, vConductivitySensor2, vOutletRedundancy, vInletDialysate, vPrimaryHeaterThermocouple, vTrimmerHeaterThermocouple, vPrimaryHeaterColdJunction, vTrimmerHeaterColdJunction, vPrimaryHeaterInternalTemperature, vTrimmerHeaterInternalTemperature):
+    """
+    the DG Temperatures Data message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description          | #1:(F32)                       | #2:(F32)                        | #3:(F32)                        |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:         |:--:                            |:--:                             |:--:                             |
+    |0x2D00| 0x080  | 8   | 2 Hz   | N   | DG  | All | DG Temperatures Data | \ref Data::mInletPrimaryHeater | \ref Data::mOutletPrimaryHeater | \ref Data::mConductivitySensor1 |
+
+    | #4:(F32)                        | #5:(F32)                     | #6:(F32)                   | #7:(F32)                              | #8:(F32)                              |
+    |:--:                             |:--:                          |:--:                        |:--:                                   |:--:                                   |
+    | \ref Data::mConductivitySensor2 | \ref Data::mOutletRedundancy | \ref Data::mInletDialysate | \ref Data::mPrimaryHeaterThermoCouple | \ref Data::mTrimmerHeaterThermoCouple |
+
+    |  #9:(F32)                              | #10:(F32)                             | #11:(F32)                         | #12:(F32)                         |
+    | :--:                                   |:--:                                   |:--:                               |:--:                               |
+    |  \ref Data::mPrimaryHeaterColdJunction | \ref Data::mTrimmerHeaterColdJunction | \ref Data::mPrimaryHeaterInternal | \ref Data::mTrimmerHeaterInternal |
+    :param vInletPrimaryHeater: (float) Inlet Primary Heater
+    :param vOutletPrimaryHeater: (float) Outlet Primary Heater
+    :param vConductivitySensor1: (float) Conductivity Sensor 1
+    :param vConductivitySensor2: (float) Conductivity Sensor 2
+    :param vOutletRedundancy: (float) Outlet Redundancy
+    :param vInletDialysate: (float) Inlet Dialysate
+    :param vPrimaryHeaterThermocouple: (float) Primary Heater Thermocouple
+    :param vTrimmerHeaterThermocouple: (float) Trimmer Heater Thermocouple
+    :param vPrimaryHeaterColdJunction: (float) Primary Heater ColdJunction
+    :param vTrimmerHeaterColdJunction: (float) Trimmer Heater ColdJunction
+    :param vPrimaryHeaterInternalTemperature: (float) Primary Heater Internal Temperature
+    :param vTrimmerHeaterInternalTemperature: (float) Trimmer HeaterInternal Temperature
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x002D, 4+4+4+4+4+4+4+4+4+4+4+4, False,
+        utils.toF32(vInletPrimaryHeater              ),
+        utils.toF32(vOutletPrimaryHeater             ),
+        utils.toF32(vConductivitySensor1             ),
+        utils.toF32(vConductivitySensor2             ),
+        utils.toF32(vOutletRedundancy                ),
+        utils.toF32(vInletDialysate                  ),
+        utils.toF32(vPrimaryHeaterThermocouple       ),
+        utils.toF32(vTrimmerHeaterThermocouple       ),
+        utils.toF32(vPrimaryHeaterColdJunction       ),
+        utils.toF32(vTrimmerHeaterColdJunction       ),
+        utils.toF32(vPrimaryHeaterInternalTemperature),
+        utils.toF32(vTrimmerHeaterInternalTemperature))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-def setDGTemperaturesData(vInletPrimaryHeater, vOutletPrimaryHeater, vConductivitySensor1, vConductivitySensor2,
-                          vOutletRedundancy, vInletDialysate, vPrimaryHeaterThermocouple, vTrimmerHeaterThermocouple,
-                          vPrimaryHeaterColdJunction, vTrimmerHeaterColdJunction, vPrimaryHeaterInternalTemperature,
-                          vTrimmerHeaterInternalTemperature):
-    frames = buildDGTemperaturesData(vInletPrimaryHeater, vOutletPrimaryHeater, vConductivitySensor1,
-                                     vConductivitySensor2, vOutletRedundancy, vInletDialysate,
-                                     vPrimaryHeaterThermocouple, vTrimmerHeaterThermocouple, vPrimaryHeaterColdJunction,
-                                     vTrimmerHeaterColdJunction, vPrimaryHeaterInternalTemperature,
-                                     vTrimmerHeaterInternalTemperature)
+def setDGTemperaturesData(vInletPrimaryHeater, vOutletPrimaryHeater, vConductivitySensor1, vConductivitySensor2, vOutletRedundancy, vInletDialysate, vPrimaryHeaterThermocouple, vTrimmerHeaterThermocouple, vPrimaryHeaterColdJunction, vTrimmerHeaterColdJunction, vPrimaryHeaterInternalTemperature, vTrimmerHeaterInternalTemperature):
+    """
+    the DG Temperatures Data message setter/sender method
+    :param vInletPrimaryHeater: (float) Inlet Primary Heater
+    :param vOutletPrimaryHeater: (float) Outlet Primary Heater
+    :param vConductivitySensor1: (float) Conductivity Sensor 1
+    :param vConductivitySensor2: (float) Conductivity Sensor 2
+    :param vOutletRedundancy: (float) Outlet Redundancy
+    :param vInletDialysate: (float) Inlet Dialysate
+    :param vPrimaryHeaterThermocouple: (float) Primary Heater Thermocouple
+    :param vTrimmerHeaterThermocouple: (float) Trimmer Heater Thermocouple
+    :param vPrimaryHeaterColdJunction: (float) Primary Heater ColdJunction
+    :param vTrimmerHeaterColdJunction: (float) Trimmer Heater ColdJunction
+    :param vPrimaryHeaterInternalTemperature: (float) Primary Heater Internal Temperature
+    :param vTrimmerHeaterInternalTemperature: (float) Trimmer HeaterInternal Temperature
+    :return: none
+    """
+    frames = buildDGTemperaturesData(vInletPrimaryHeater, vOutletPrimaryHeater, vConductivitySensor1, vConductivitySensor2, vOutletRedundancy, vInletDialysate, vPrimaryHeaterThermocouple, vTrimmerHeaterThermocouple, vPrimaryHeaterColdJunction, vTrimmerHeaterColdJunction, vPrimaryHeaterInternalTemperature, vTrimmerHeaterInternalTemperature)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '080#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x000F,040,N,HD,All,TreatmentStatesData,(U32)^SubMode,(U32)^UFState,(U32)^SalineState
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def buildTreatmentStatesData(vSubMode, vUFState, vSalineState):
-    msg = messageBuilder.buildMessage(0x000F, 4 + 4 + 4, False,
-                                      utils.toI32(vSubMode),
-                                      utils.toI32(vUFState),
-                                      utils.toI32(vSalineState))
+    """
+    the Treatment States Data message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description           | #1:(U32)            | #2:(U32)            | #3:(U32)                |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:          |:--:                 |:--:                 |:--:                     |
+    |0x0F00| 0x040  | 7   | 1 Hz   | N   | HD  | All | Treatment States Data | \ref Data::mSubMode | \ref Data::mUFState | \ref Data::mSalineState |
+    :param vSubMode: (int) Sub-Mode
+    :param vUFState: (int) UF State
+    :param vSalineState: (int) Saline Bolus State
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x000F, 4+4+4, False,
+        utils.toI32(vSubMode    ),
+        utils.toI32(vUFState    ),
+        utils.toI32(vSalineState))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def setTreatmentStatesData(vSubMode, vUFState, vSalineState):
+    """
+    the Treatment States Data message setter/sender method
+    :param vSubMode: (int) Sub-Mode
+    :param vUFState: (int) UF State
+    :param vSalineState: (int) Saline Bolus State
+    :return: none
+    """
     frames = buildTreatmentStatesData(vSubMode, vUFState, vSalineState)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '040#{}'.format(frame)])
     waitForMessageToBeSent()
 
+def setTreatmentStartState():
+    """
+    starting the treatment for user convenience since Tx is not by default running
+    :return: none
+    """
+    setTreatmentStatesData(txStates.TREATMENT_DIALYSIS_STATE, txStates.UF_PAUSED_STATE_NOT, txStates.SALINE_BOLUS_STATE_IDLE)
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x0025,040,N,HD,All,HDOperationModeData,(U32)^OpMode
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
 def buildHDOperationModeData(vOpMode):
-    msg = messageBuilder.buildMessage(0x0025, 4, False,
-                                      utils.toI32(vOpMode))
+    """
+    the HD Operation Mode Data message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description            | #1:(U32)            |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:           |:--:                 |
+    |0x2500| 0x040  | 7   | 1 Hz   | N   | HD  | All | HD Operation Mode Data | \ref Data::mOpMode  |
+    :param vOpMode: (int) Operation Mode
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x0025, 4, False,
+        utils.toI32(vOpMode))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def setHDOperationModeData(vOpMode):
+    """
+    the HD Operation Mode Data message setter/sender method
+    :param vOpMode: (int) Operation Mode
+    :return: none
+    """
     frames = buildHDOperationModeData(vOpMode)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '040#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x002F,040,N,HD,All,TreatmentSalineBolusData,(U32)^Target,(F32)^Cumulitive,(F32)^Delivered
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-def buildTreatmentSalineBolusData(vTarget, vCumulitive, vDelivered):
-    msg = messageBuilder.buildMessage(0x002F, 4 + 4 + 4, False,
-                                      utils.toI32(vTarget),
-                                      utils.toF32(vCumulitive),
-                                      utils.toF32(vDelivered))
+def buildTreatmentSalineBolusData(vTarget, vCumulative, vDelivered):
+    """
+    the Treatment Saline Bolus Data message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description                 | #1:(U32)            | #2:(F32)               | #3:(F32)              |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:                |:--:                 |:--:                    |:--:                   |
+    |0x2F00| 0x040  | 7   | 1 Hz   | N   | HD  | All | Treatment Saline Bolus Data | \ref Data::mTarget  | \ref Data::mCumulative | \ref Data::mDelivered |
+    :param vTarget: (int) Saline Bolus Target Volume
+    :param vCumulative: (float) Saline Bolus Cumulative Volume
+    :param vDelivered: (float) Saline Bolus Delivered Volume
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x002F, 4+4+4, False,
+        utils.toI32(vTarget    ),
+        utils.toF32(vCumulative),
+        utils.toF32(vDelivered ))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-def setTreatmentSalineBolusData(vTarget, vCumulitive, vDelivered):
-    frames = buildTreatmentSalineBolusData(vTarget, vCumulitive, vDelivered)
+def setTreatmentSalineBolusData(vTarget, vCumulative, vDelivered):
+    """
+    the Treatment Saline Bolus Data message setter/sender method
+    :param vTarget: (int) Saline Bolus Target Volume
+    :param vCumulative: (float) Saline Bolus Cumulative Volume
+    :param vDelivered: (float) Saline Bolus Delivered Volume
+    :return: none
+    """
+    frames = buildTreatmentSalineBolusData(vTarget, vCumulative, vDelivered)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '040#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x0014,020,Y,HD,UI,SalineBolusResponse,(U32)^Accepted,(U32)^Reason,(U32)^Target
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def buildSalineBolusResponse(vAccepted, vReason, vTarget):
-    msg = messageBuilder.buildMessage(0x0014, 4 + 4 + 4, True,
-                                      utils.toI32(vAccepted),
-                                      utils.toI32(vReason),
-                                      utils.toI32(vTarget))
+    """
+    the Saline Bolus Response message builder method
+    | MSG | CAN ID | M.Box | Type | Ack | Src | Dest | Description           | #1:(U32)             | #2:(U32)            | #3:(U32)            |
+    |:---:|:------:|:-----:|:----:|:---:|:---:|:----:|:---------------------:|:--------------------:|:-------------------:|:-------------------:|
+    | 20  | 0x020  | 6     | Rsp  | Y   | HD  | UI   | Saline Bolus Response | \ref Data::mAccepted | \ref Data::mReason  | \ref Data::mTarget  |
+    :param vAccepted: (int) boolean accept/reject response
+    :param vReason: (int) rejection reason
+    :param vTarget: (int) Saline Bolus Target Volume
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x0014, 4+4+4, True,
+        utils.toI32(vAccepted),
+        utils.toI32(vReason  ),
+        utils.toI32(vTarget  ))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def setSalineBolusResponse(vAccepted, vReason, vTarget):
+    """
+    the Saline Bolus Response message setter/sender method
+    :param vAccepted: (int) boolean accept/reject response
+    :param vReason: (int) rejection reason
+    :param vTarget: (int) Saline Bolus Target Volume
+    :return: none
+    """
     frames = buildSalineBolusResponse(vAccepted, vReason, vTarget)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
@@ -674,13 +1155,23 @@
 
 
 def buildCanBUSFaultCount(vCount):
+    """
+    the CANBus fault count message builder method
+    :param vCount: (int) Fault Count
+    :return: (str) built message frame(s)
+    """
     msg = messageBuilder.buildMessage(GuiActionType.CanBUSFaultCount, 4 * 1, False,
-                                      utils.toI32(vCount)
-                                      )
+        utils.toI32(vCount)
+    )
     return messageBuilder.toFrames(msg)
 
 
 def setCanBUSFaultCount(vCount):
+    """
+    the CANBus fault count message setter/sender method
+    :param vCount: (int) Fault Count
+    :return: none
+    """
     frames = buildCanBUSFaultCount(vCount)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
@@ -689,11 +1180,19 @@
 
 
 def buildUnknown():
+    """
+    the unknown message builder method
+    :return: (str) built message frame(s)
+    """
     msg = messageBuilder.buildMessage(GuiActionType.Unknown, 0, False)
     return messageBuilder.toFrames(msg)
 
 
 def sendUnknown_HD():
+    """
+    the unknown message from HD setter/sender method
+    :return: none
+    """
     frames = buildUnknown()
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
@@ -702,6 +1201,10 @@
 
 
 def sendUnknown_DG():
+    """
+    the unknown message from DG setter/sender method
+    :return: none
+    """
     frames = buildUnknown()
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
@@ -710,62 +1213,101 @@
 
 
 def clear_all_alarms():
+    """
+    a convenient method for setAlarmStatus to clear all alarms
+    :return: none
+    """
     setAlarmStatus(0, 0, 0, 0, 0)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x0002,001,N,HD,All,AlarmStatus,(U32)^State,(U32)^Top,(U32)^EscalatesIn,(U32)^MuteTimeout,(U16)^Flags
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def buildAlarmStatus(vState, vTop, vEscalatesIn, vMuteTimeout, vFlags):
-    msg = messageBuilder.buildMessage(0x0002, 4 + 4 + 4 + 4 + 2, False,
-                                      utils.toI32(vState),
-                                      utils.toI32(vTop),
-                                      utils.toI32(vEscalatesIn),
-                                      utils.toI32(vMuteTimeout),
-                                      utils.toI16(vFlags))
+    """
+    the Alarm Status message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description  | #1:(U32)          | #2:(U32)        | #3:(U32)                | #4:(U32)                | #5:(U16)          |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------: |:--:               |:--:             |:--:                     |:--:                     |:--:               |
+    |0x0200| 0x001  | 1   | 1 Hz   | N   | HD  | All | Alarm Status | \ref Data::mState | \ref Data::mTop | \ref Data::mEscalatesIn | \ref Data::mMuteTimeout | \ref Data::mFlags |
+    :param vState: (int) Alarm State
+    :param vTop: (int) Top priority Alaram ID
+    :param vEscalatesIn: (int) Alarm Escalation
+    :param vMuteTimeout: (int) Mute Timeout
+    :param vFlags: (int16) Alarm Flags
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x0002, 4+4+4+4+2, False,
+        utils.toI32(vState      ),
+        utils.toI32(vTop        ),
+        utils.toI32(vEscalatesIn),
+        utils.toI32(vMuteTimeout),
+        utils.toI16(vFlags      ))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def setAlarmStatus(vState, vTop, vEscalatesIn, vMuteTimeout, vFlags):
+    """
+    the Alarm Status message setter/sender method
+    :param vState: (int) Alarm State
+    :param vTop: (int) Top priority Alaram ID
+    :param vEscalatesIn: (int) Alarm Escalation
+    :param vMuteTimeout: (int) Mute Timeout
+    :param vFlags: (int16) Alarm Flags
+    :return: none
+    """
     frames = buildAlarmStatus(vState, vTop, vEscalatesIn, vMuteTimeout, vFlags)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '001#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x0003,001,Y,HD,All,AlarmTriggered,(U32)^AlarmID
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def buildAlarmTriggered(vAlarmID):
-    msg = messageBuilder.buildMessage(0x0003, 4, True,
-                                      utils.toI32(vAlarmID))
+    """
+    the Alarm Triggered message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description     | #1:(U32)            |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:    |:--:                 |
+    |0x0300| 0x001  | 1   | Event  | Y   | HD  | All | Alarm Triggered | \ref Data::mAlarmID |
+    :param vAlarmID: (int) Alarm ID
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x0003, 4, True,
+        utils.toI32(vAlarmID))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def setAlarmTriggered(vAlarmID):
+    """
+    the Alarm Triggered message setter/sender method
+    :param vAlarmID: (int) Alarm ID
+    :return: none
+    """
     frames = buildAlarmTriggered(vAlarmID)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '001#{}'.format(frame)])
     waitForMessageToBeSent()
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-## 0x0004,001,Y,HD,All,AlarmCleared,(U32)^AlarmID
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def buildAlarmCleared(vAlarmID):
-    msg = messageBuilder.buildMessage(0x0004, 4, True,
-                                      utils.toI32(vAlarmID))
+    """
+    the Alarm Cleared message builder method
+    | MSG  | CAN ID | Box | Type   | Ack | Src | Dst | Description   | #1:(U32)            |
+    |:----:|:------:|:---:|:------:|:---:|:---:|:---:|:-----------:  |:--:                 |
+    |0x0400| 0x001  | 1   | Event  | Y   | HD  | All | Alarm Cleared | \ref Data::mAlarmID |
+    :param vAlarmID: (int) Alarm ID
+    :return: (str) built message frame(s)
+    """
+    msg = messageBuilder.buildMessage( 0x0004, 4, True,
+        utils.toI32(vAlarmID))
     return messageBuilder.toFrames(msg)
 
 
-## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 def setAlarmCleared(vAlarmID):
+    """
+    the Alarm Cleared message setter/sender method
+    :param vAlarmID: (int) Alarm ID
+    :return: none
+    """
     frames = buildAlarmCleared(vAlarmID)
     frames = messageBuilder.toCandumpFormat(frames)
     for frame in frames:
         subprocess.call(['cansend', 'can0', '001#{}'.format(frame)])
-    waitForMessageToBeSent()
+    waitForMessageToBeSent()
\ No newline at end of file
Index: dialin/squish/unittests.py
===================================================================
diff -u -r87cf0bc784212d2608c58d1388b37396aa0a4656 -rccc07090d6993ade7fc1d9ea12e7601ca6d9a9ef
--- dialin/squish/unittests.py	(.../unittests.py)	(revision 87cf0bc784212d2608c58d1388b37396aa0a4656)
+++ dialin/squish/unittests.py	(.../unittests.py)	(revision ccc07090d6993ade7fc1d9ea12e7601ca6d9a9ef)
@@ -7,8 +7,8 @@
 #
 # @file unittests.py
 #
-# @author (last) Peter Lucia
-# @date (last) 10-Jul-2020
+# @author (last) Behrouz NematiPour
+# @date (last) 14-Oct-2020
 # @author (original) Peter Lucia
 # @date (original) 09-Jul-2020
 #
@@ -23,12 +23,20 @@
 
 
 def test_python_version():
-    test.compare(sys.version_info.major, 3)
-    test.compare(sys.version_info.minor, 6)
+    """
+    tests the current python version compatibility
+    :return:
+    """
+    test.compare(sys.version_info.major,3)
+    test.compare(sys.version_info.minor,6)
     
     test.compare(sys.version_info.micro in MICRO, True)
 
 def test_crc8():
+    """
+    test case for crc8 method
+    :return:
+    """
     strByte1 = (   "4B 43 09 00 14 00 00"
                 "00 00 00 00 00 00 00 00"
                 "00 00 00 00 00 00 00 00"
@@ -57,6 +65,10 @@
     test.compare(crc.calcCRC8(strByte4, ' '), '7F')
 
 def test_can0():
+    """
+    check if the can0 bus driver presents
+    :return:
+    """
     canid = "can0"
     ipa = "ip a"
     ipa = check_output(ipa, shell=True)