Index: firmware/App/Services/FPGA.c
===================================================================
diff -u -r2cc4f0cfc6512c942864d7d302cef5df375a2081 -r1eb1085dfc954ba2b2dd7eb7fc66ea8486100a99
--- firmware/App/Services/FPGA.c	(.../FPGA.c)	(revision 2cc4f0cfc6512c942864d7d302cef5df375a2081)
+++ firmware/App/Services/FPGA.c	(.../FPGA.c)	(revision 1eb1085dfc954ba2b2dd7eb7fc66ea8486100a99)
@@ -20,8 +20,9 @@
 #include "sci.h"
 #include "sys_dma.h"
 
-#include "FPGA.h"
 #include "Comm.h"
+#include "Compatible.h"
+#include "FPGA.h"
 #include "SystemCommMessages.h"
 #include "Utilities.h"
 
@@ -81,11 +82,24 @@
 #define FPGA_AIRTRAP_LEVEL_LOW_MASK     0x0008                  ///< Bit mask for air trap lower level sensor.
 #define FPGA_AIRTRAP_LEVEL_HIGH_MASK    0x0004                  ///< Bit mask for air trap upper level sensor.
 
-#define FPGA_FLUIDLEAK_STATE_MASK       0x0040                  ///< Bit mask for fluid leak detector.
-#define FPGA_ADA_INPUT_STATUS_MASK      0x0001                  ///< Bit mask for arterial air bubble detector input status.
-#define FPGA_ADV_INPUT_STATUS_MASK      0x0002                  ///< Bit mask for venous air bubble detector input status.
-#define FPGA_BLOOD_LEAK_STATUS_MASK     0x1000                  ///< Bit mask for blood leak detector status.
+#define FPGA_FLUID_LEAK_STATE_MASK      0x0040                  ///< Bit mask for fluid leak detector.
 
+#define FPGA_BLOOD_LEAK_STATUS_MASK     0x1000                  ///< Bit mask for blood leak detector.
+#define FPGA_BLOOD_LEAK_ZERO_STATE_MASK 0x2000                  ///< Bit mask for blood leak detector zero.
+#define FPGA_BLOOD_LEAK_ZERO_CMD        0x02                    ///< Bit for blood leak detector zero command.
+#define FPGA_BLOOD_LEAK_SELF_TEST_CMD   0x01                    ///< Bit for blood leak detector self test command.
+
+#define FPGA_ADA_BUBBLE_STATUS_MASK     0x0001                  ///< Bit mask for arterial air bubble detector input status.
+#define FPGA_ADV_BUBBLE_STATUS_MASK     0x0002                  ///< Bit mask for venous air bubble detector input status.
+#define FPGA_ADA_BUBBLE_SELF_TEST_CMD   0x04                    ///< Bit for arterial air bubble detector self-test command.
+#define FPGA_ADV_BUBBLE_SELF_TEST_CMD   0x08                    ///< Bit for venous air bubble detector self-test command.
+
+#define FPGA_PBO_TEMP_DIVISOR           2047.0                  ///< Used in conversion of PBo temperature reading to deg C.
+#define FPGA_PBO_TEMP_GAIN              200.0                   ///< Used in conversion of PBo temperature reading to deg C.
+#define FPGA_PBO_TEMP_OFFSET            50.0                    ///< Used in conversion of PBo temperature reading to deg C.
+
+#define FPGA_ALARM_AUDIO_VOLUME_SHIFT   3                       ///< Shift alarm audio volume 3 bits to left before writing to register.
+
 // FPGA Sensors Record
 #pragma pack(push,1)
 /// Record structure for FPGA header read.
@@ -104,7 +118,7 @@
 } FPGA_HEADER_T;    // Read only on FPGA
 
 /// Record structure for FPGA continuous priority reads.
-typedef struct  // TODO - add all sensor readings to this structure per FPGA register map
+typedef struct
 {
     U08 errorCountProcessor;                    ///< Reg 256.  TBD.
     U08 errorCountPC;                           ///< Reg 257.  TBD.
@@ -135,7 +149,7 @@
     U32 adc1Channel0;                           ///< Reg 292.  ADC1 channel 0 data.
     U32 adc1Channel1;                           ///< Reg 296.  ADC1 channel 1 data.
     U32 bloodFlowSoundSpeedData;                ///< Reg 300.  Blood flow sensor - sound speed data.
-    U32 bloodFlowAccFlowData;                   ///< Reg 304.  Blood flow sensor - accumualted flow data.
+    U32 bloodFlowAccFlowData;                   ///< Reg 304.  Blood flow sensor - accumulated flow data.
     F32 bloodFlowSignalStrength;                ///< Reg 308.  Blood flow sensor - signal strength.
     U08 adc1SequenceCount;                      ///< Reg 312.  ADC1 round robin channel sequence count.
     U08 adc1ErrorCount;                         ///< Reg 313.  ADC1 error count.
@@ -154,7 +168,7 @@
     U16 dialInPumpHallSensorCount;              ///< Reg 336.  Dialysate inlet pump hall sensor count.
     U16 dialOutPumpHallSensorCount;             ///< Reg 338.  Dialysate outlet pump hall sensor count.
     U32 dialysateFlowSoundSpeedData;            ///< Reg 340.  Dialysate flow sensor - sound speed data.
-    U32 dialysateFlowAccFlowData;               ///< Reg 344.  Dialysate flow sensor - accumualted flow data.
+    U32 dialysateFlowAccFlowData;               ///< Reg 344.  Dialysate flow sensor - accumulated flow data.
     F32 dialysateFlowSignalStrength;            ///< Reg 348.  Dialysate flow sensor - signal strength.
     U16 fan1PulseTime;                          ///< Reg 352.  Fan 1 pulse time in 2.5 uSec resolution.  0xFFFF if fan RPM < 500 RPM.
     U16 fan2PUlseTime;                          ///< Reg 354.  Fan 2 pulse time in 2.5 uSec resolution.  0xFFFF if fan RPM < 500 RPM.
@@ -170,13 +184,15 @@
     U16 VDiPWMTarget;                           ///< Reg 374.  PWM target duty cycle for VDi pinch valve.
     U16 VDoPWMTarget;                           ///< Reg 376.  PWM target duty cycle for VDo pinch valve.
     U16 VSparePWMTarget;                        ///< Reg 378.  PWM target duty cycle for Vspare pinch valve.
-    U16 SyringePumpStatus;                      ///< Reg 380.  Syringe pump status register
-    U16 SyringePumpEncStatus;                   ///< Reg 382.  Syringe pump encoder status
-    U32 SyringePumpEncPosition;                 ///< Reg 384.  Syringe pump encoder position
-    U16 sPumpAdcDataReadChannel0;               ///< Reg 388.
-    U16 sPumpAdcDataReadCh1;                    ///< Reg 390.
-    U16 sPumpAdcDataReadCh2;                    ///< Reg 392.
-    U16 sPumpAdcDataReadCh3;                    ///< Reg 394.
+    U08 syringePumpStatus;                      ///< Reg 380.  Syringe pump status register.
+    U08 syringePumpADCReadCounter;              ///< Reg 381.  Syringe pump ADC read counter.
+    U08 syringePumpADCandDACStatus;             ///< Reg 382.  Syringe pump ADC and DAC status register.
+    U08 syringePumpEncoderStatus;               ///< Reg 383.  Syringe pump encoder status register.
+    U32 syringePumpEncPosition;                 ///< Reg 384.  Syringe pump encoder position
+    U16 syringePumpAdcDataReadCh0;              ///< Reg 388.  Syringe pump ADC channel 0 register (10 bit).
+    U16 syringePumpAdcDataReadCh1;              ///< Reg 390.  Syringe pump ADC channel 1 register (10 bit).
+    U16 syringePumpAdcDataReadCh2;              ///< Reg 392.  Syringe pump ADC channel 2 register (10 bit).
+    U16 syringePumpAdcDataReadCh3;              ///< Reg 394.  Syringe pump ADC channel 3 register (10 bit).
     U16 VBASpeed;                               ///< Reg 396.  VBA pinch valve speed (Register VAUX0)
     U16 VBVSpeed;                               ///< Reg 398.  VBV pinch valve speed (Register VAUX1)
     U16 VBVCurrent;                             ///< Reg 400.  VBV pinch valve current (Register VAUX2)
@@ -185,12 +201,13 @@
     U16 VDiSpeed;                               ///< Reg 406.  VDi pinch valve current (Register VAUX9)
     U16 VDoSpeed;                               ///< Reg 408.  VDo pinch valve speed (Register VAUX10)
     U16 VDiCurrent;                             ///< Reg 410.  VDi pinch valve current (Register VAUX11)
-    U16 VSpareSpeed;                            ///< Reg 412.  VSpare speed (Register VAUX5)
-    U16 VSpareCurrent;                          ///< Reg 414.  VSpare current (Register VAUX13)
+    U16 fpgaBoardTemperature;                   ///< Reg 412.  FPGA board temperature.
+    U16 VAUX13;                                 ///< Reg 414.  Register VAUX13.
+    U16 fpgaTimerCount_ms;                      ///< Reg 416.  Internal FPGA timer count in ms.
 } FPGA_SENSORS_T;
 
 /// Record structure for FPGA continuous priority writes.
-typedef struct  // TODO - add all actuator set points to this structure per FPGA register map
+typedef struct
 {
     U08 fpgaSensorTest;                         ///< Reg 11.  Blood leak and bubble detector sensor test register.
     U16 fpgaPIDControl;                         ///< Reg 12.  Valve PID enables.
@@ -204,12 +221,16 @@
     U16 VDiPWMFixed;                            ///< Reg 28.  VDi PWM set to fixed current by setting fixed PWM duty cycle.  Range 750 to 4250.  < 2500 is reverse direction.
     U16 VDoPWMFixed;                            ///< Reg 30.  VDo PWM set to fixed current by setting fixed PWM duty cycle.  Range 750 to 4250.  < 2500 is reverse direction.
     U16 VSparePWMFixed;                         ///< Reg 32.  Vspare PWM set to fixed current by setting fixed PWM duty cycle.  Range 750 to 4250.  < 2500 is reverse direction.
-    U08 AlarmControl;                           ///< Reg 34.  Alarm (audio) control register.
+    U08 alarmControl;                           ///< Reg 34.  Alarm (audio) control register.
+    U08 syringePumpControl;                     ///< Reg 35.  Syringe pump control register.
+    U32 syringePumpStepToggleTime;              ///< Reg 36.  Syringe pump step time toggle register.  Sets time between step toggle which dictates stepper motor speed.
+    U16 syringePumpDACOut;                      ///< Reg 40.  Syringe pump DAC output level (12-bit).
+    U08 syringePumpADCandDACControl;            ///< Reg 42.  Syringe pump ADC and DAC control register.
 } FPGA_ACTUATORS_T;
 
 // TODO clean up the struct
 /// Record structure for FPGA async (as needed) reads.
-typedef struct  // TODO - add all sensor readings to this structure per FPGA register map
+typedef struct
 {
     U16 fpgaDieTemp;                            ///< Reg 512.  Internal FPGA die temperature.
     U16 fpgaADCVccVoltage;                      ///< Reg 514.  Internal FPGA Vcc voltage.
@@ -303,7 +324,7 @@
     memset( &fpgaHeader, 0, sizeof(FPGA_HEADER_T) );
     memset( &fpgaSensorReadings, 0, sizeof(FPGA_SENSORS_T) );
     memset( &fpgaActuatorSetPoints, 0, sizeof(FPGA_ACTUATORS_T) );
-    fpgaActuatorSetPoints.AlarmControl = (U08)MIN_ALARM_VOLUME_ATTENUATION << 2;  // Start alarm audio volume at maximum
+    fpgaActuatorSetPoints.alarmControl = (U08)MIN_ALARM_VOLUME_ATTENUATION << 2;  // Start alarm audio volume at maximum
 
     // Initialize fpga comm buffers
     memset( &fpgaWriteCmdBuffer, 0, FPGA_WRITE_CMD_BUFFER_LEN );
@@ -486,8 +507,6 @@
             fpgaState = handleFPGAReceiveHeaderState();
             break;
 
-        // TODO - sensor/ADC init/configuration states
-
         case FPGA_STATE_RCV_ALL_SENSORS:
             fpgaState = handleFPGAReceiveAllSensorsState();
             break;
@@ -515,9 +534,14 @@
     }
 
     // If retries for commands exceeds limit, fault
-    if ( fpgaCommRetryCount > MAX_COMM_ERROR_RETRIES )
+    if ( ( fpgaCommRetryCount > MAX_COMM_ERROR_RETRIES )
+#ifdef _RELEASE_
+         || ( fpgaSensorReadings.errorCountProcessor > MAX_COMM_ERROR_RETRIES ) )
+#else
+         )
+#endif
     {
-        activateAlarmNoData( ALARM_ID_FPGA_COMM_TIMEOUT );
+        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_FPGA_COMM_TIMEOUT, fpgaCommRetryCount, (U32)fpgaSensorReadings.errorCountProcessor )
     }
 
     // Reset comm flags after processing incoming responses
@@ -540,8 +564,6 @@
             fpgaState = handleFPGAReadHeaderState();
             break;
 
-        // TODO - sensor/ADC init/configuration states
-
         case FPGA_STATE_WRITE_ALL_ACTUATORS:
             fpgaState = handleFPGAWriteAllActuatorsState();
             break;
@@ -858,12 +880,28 @@
     // Check FPGA reported correct ID
     if ( FPGA_EXPECTED_ID == fpgaHeader.fpgaId )
     {
-        result = SELF_TEST_STATUS_PASSED;
+        // Check FPGA compatibility w/ firmware
+        if ( fpgaHeader.fpgaRevMajor > MIN_HD_FPGA_MAJOR )
+        {
+            result = SELF_TEST_STATUS_PASSED;
+        }
+        else
+        {
+            if ( ( MIN_HD_FPGA_MAJOR == fpgaHeader.fpgaRevMajor ) && ( fpgaHeader.fpgaRev >= MIN_HD_FPGA_MINOR ) )
+            {
+                result = SELF_TEST_STATUS_PASSED;
+            }
+            else
+            {
+                result = SELF_TEST_STATUS_FAILED;
+                SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_FPGA_POST_TEST_FAILED, (U32)fpgaHeader.fpgaRevMajor, (U32)fpgaHeader.fpgaRev )
+            }
+        }
     }
     else
     {
         result = SELF_TEST_STATUS_FAILED;
-        SET_ALARM_WITH_1_U32_DATA( ALARM_ID_FPGA_POST_TEST_FAILED, (U32)fpgaHeader.fpgaId )
+        SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_FPGA_POST_TEST_FAILED, (U32)fpgaHeader.fpgaId )
     }
 
     return result;
@@ -1063,6 +1101,7 @@
  *          1 - Low priority alarm tone (c e)
  *          2 - Medium priority alarm tone (c f# c)
  *          3 - High priority alarm tone (c f# c - c f#)
+ *          4 - Continuous test tone (e)
  * @param volumeLevel the level of attenuation to command (0..4)
  *          4 - 3 dB gain
  *          3 - 6 dB gain
@@ -1071,25 +1110,24 @@
  *          0 - 15 dB gain
  * @return none
  *************************************************************************/
-void setAlarmAudioState( ALARM_PRIORITY_T state, U32 volumeLevel )
+void setAlarmAudioState( U32 state, U32 volumeLevel )
 {
-    if ( ( state < NUM_OF_ALARM_PRIORITIES ) && ( volumeLevel <= MAX_ALARM_VOLUME_ATTENUATION ) )
-    {
-        U08 audioCmd = (U08)state;
+    U08 audioCmd = (U08)state;
 
-        audioCmd |= ( (U08)volumeLevel << 2 );
-        fpgaActuatorSetPoints.AlarmControl = audioCmd;
+    audioCmd |= ( (U08)volumeLevel << FPGA_ALARM_AUDIO_VOLUME_SHIFT );
+
+    if ( ( state <= NUM_OF_ALARM_PRIORITIES ) && ( volumeLevel <= MAX_ALARM_VOLUME_ATTENUATION ) )
+    {
+        fpgaActuatorSetPoints.alarmControl = audioCmd;
     }
     else
     {
-        U08 audioCmd = (U08)ALARM_PRIORITY_HIGH;
-
-        // Set alarm audio to high priority, max volume for safety since s/w seems to be having trouble setting audio correctly
-        audioCmd |= ( (U08)MIN_ALARM_VOLUME_ATTENUATION << 2 );
-        fpgaActuatorSetPoints.AlarmControl = audioCmd;
         // S/w fault to indicate issue w/ s/w
-        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_FPGA_INVALID_ALARM_AUDIO_PARAM, volumeLevel )
-
+        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_FPGA_INVALID_ALARM_AUDIO_PARAM, (U32)audioCmd )
+        // Set alarm audio to high priority, max volume for safety since s/w seems to be having trouble setting audio correctly
+        audioCmd = (U08)ALARM_PRIORITY_HIGH;
+        audioCmd |= ( (U08)MIN_ALARM_VOLUME_ATTENUATION << FPGA_ALARM_AUDIO_VOLUME_SHIFT );
+        fpgaActuatorSetPoints.alarmControl = audioCmd;
     }
 }
 
@@ -1133,30 +1171,82 @@
 
 /*********************************************************************//**
  * @brief
- * The getFPGADialysateFlow function gets the latest dialysate flow reading.
+ * The getFPGABloodFlowMeterStatus function gets the blood flow meter status.
  * @details Inputs: fpgaSensorReadings
  * @details Outputs: none
- * @return last dialysate flow reading
+ * @return current blood flow meter status
  *************************************************************************/
-F32 getFPGADialysateFlow( void )
+U08 getFPGABloodFlowMeterStatus( void )
 {
-    return fpgaSensorReadings.dialysateFlowLast;
+    return fpgaSensorReadings.bloodFlowMeterDeviceStatus;
 }
 
 /*********************************************************************//**
  * @brief
- * The getFPGABloodFlowMeterStatus function gets the blood flow meter status.
+ * The getFPGABloodFlowFastPacketReadCounter function gets the blood
+ * flow meter fast packet read counter.
  * @details Inputs: fpgaSensorReadings
  * @details Outputs: none
- * @return current blood flow meter status
+ * @return current blood flow meter fast packet read counter
  *************************************************************************/
-U08 getFPGABloodFlowMeterStatus( void )
+U08 getFPGABloodFlowFastPacketReadCounter( void )
 {
-    return fpgaSensorReadings.bloodFlowMeterDeviceStatus;
+    return fpgaSensorReadings.bloodFlowMeterDataPktCount;
 }
 
 /*********************************************************************//**
  * @brief
+ * The getFPGABloodFlowSlowPacketReadCounter function gets the blood
+ * flow meter slow packet read counter.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return current blood flow meter slow packet read counter
+ *************************************************************************/
+U08 getFPGABloodFlowSlowPacketReadCounter( void )
+{
+    return ( fpgaSensorReadings.bloodFlowMeterSlowPktCounts & MASK_OFF_NIBBLE_LSB ) >> SHIFT_BITS_BY_4;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGABloodFlowStatusPacketReadCounter function gets the blood
+ * flow meter status packet read counter.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return current blood flow meter status packet read counter
+ *************************************************************************/
+U08 getFPGABloodFlowStatusPacketReadCounter( void )
+{
+    return ( fpgaSensorReadings.bloodFlowMeterSlowPktCounts & MASK_OFF_NIBBLE_MSB );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGABloodFlowErrorCounter function gets the blood flow meter
+ * error counter.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return current blood flow meter error counter
+ *************************************************************************/
+U08 getFPGABloodFlowErrorCounter( void )
+{
+    return fpgaSensorReadings.bloodFlowMeterErrorCount;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGADialysateFlow function gets the latest dialysate flow reading.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last dialysate flow reading
+ *************************************************************************/
+F32 getFPGADialysateFlow( void )
+{
+    return fpgaSensorReadings.dialysateFlowLast;
+}
+
+/*********************************************************************//**
+ * @brief
  * The getFPGADialysateFlowMeterStatus function gets the dialysate flow meter status.
  * @details Inputs: fpgaSensorReadings
  * @details Outputs: none
@@ -1169,6 +1259,58 @@
 
 /*********************************************************************//**
  * @brief
+ * The getFPGADialysateFlowFastPacketReadCounter function gets the dialysate
+ * flow meter fast packet read counter.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return current dialysate flow meter fast packet read counter
+ *************************************************************************/
+U08 getFPGADialysateFlowFastPacketReadCounter( void )
+{
+    return fpgaSensorReadings.dialysateFlowMeterDataPktCount;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGADialysateFlowSlowPacketReadCounter function gets the dialysate
+ * flow meter slow packet read counter.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return current dialysate flow meter slow packet read counter
+ *************************************************************************/
+U08 getFPGADialysateFlowSlowPacketReadCounter( void )
+{
+    return ( fpgaSensorReadings.dialysateFlowMeterSlowPckCounts & MASK_OFF_NIBBLE_LSB ) >> SHIFT_BITS_BY_4;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGADialysateFlowStatusPacketReadCounter function gets the dialysate
+ * flow meter status packet read counter.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return current dialysate flow meter status packet read counter
+ *************************************************************************/
+U08 getFPGADialysateFlowStatusPacketReadCounter( void )
+{
+    return ( fpgaSensorReadings.dialysateFlowMeterSlowPckCounts & MASK_OFF_NIBBLE_MSB );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGADialysateFlowErrorCounter function gets the dialysate flow meter
+ * error counter.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return current dialysate flow meter error counter
+ *************************************************************************/
+U08 getFPGADialysateFlowErrorCounter( void )
+{
+    return fpgaSensorReadings.dialysateFlowMeterErrorCount;
+}
+
+/*********************************************************************//**
+ * @brief
  * The getFPGABloodPumpHallSensorCount function gets the latest blood pump
  * hall sensor count.  Count is a 16 bit free running counter.  If counter is
  * counting up, indicates motor is running in forward direction.  If counter is
@@ -1187,9 +1329,9 @@
  * @brief
  * The getFPGABloodPumpHallSensorStatus function gets the latest blood pump
  * hall sensor status.
- *    Bit 0 - Derived direction of the blood pump motor (0=Fwd, 1=Rev)
- *    Bit 1 - A direction error was detected in the current hall sensor phase
- *    Bit 2 - A direction error was detected since the last read of this register
+ *    Bit 7 - Derived direction of the blood pump motor (0=Fwd, 1=Rev)
+ *    Bit 6 - Unused
+ *    Bit 5-0 - Direction error count since power-up (rolls over)
  * @details Inputs: fpgaSensorReadings
  * @details Outputs: none
  * @return last blood pump hall sensor status reading.
@@ -1219,9 +1361,9 @@
  * @brief
  * The getFPGADialInPumpHallSensorStatus function gets the latest dialysate inlet pump
  * hall sensor status.
- *    Bit 0 - Derived direction of the dialyste inlet pump motor (0=Fwd, 1=Rev)
- *    Bit 1 - A direction error was detected in the current hall sensor phase
- *    Bit 2 - A direction error was detected since the last read of this register
+ *    Bit 7 - Derived direction of the dialysate inlet pump motor (0=Fwd, 1=Rev)
+ *    Bit 6 - Unused
+ *    Bit 5-0 - Direction error count since power-up (rolls over)
  * @details Inputs: fpgaSensorReadings
  * @details Outputs: none
  * @return last dialysate inlet pump hall sensor status reading.
@@ -1251,9 +1393,9 @@
  * @brief
  * The getFPGADialOutPumpHallSensorStatus function gets the latest dialysate outlet pump
  * hall sensor status.
- *    Bit 0 - Derived direction of the dialysate outlet pump motor (0=Fwd, 1=Rev)
- *    Bit 1 - A direction error was detected in the current hall sensor phase
- *    Bit 2 - A direction error was detected since the last read of this register
+ *    Bit 7 - Derived direction of the dialysate outlet pump motor (0=Fwd, 1=Rev)
+ *    Bit 6 - Unused
+ *    Bit 5-0 - Direction error count since power-up (rolls over)
  * @details Inputs: fpgaSensorReadings
  * @details Outputs: none
  * @return last dialysate outlet pump hall sensor status reading.
@@ -1303,6 +1445,84 @@
 
 /*********************************************************************//**
  * @brief
+ * The getFPGABloodPumpOcclusionReadCounter function gets the latest blood
+ * pump occlusion read counter.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last blood pump occlusion read counter
+ *************************************************************************/
+U08 getFPGABloodPumpOcclusionReadCounter( void )
+{
+    return fpgaSensorReadings.bloodOcclusionReadCount;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGADialInPumpOcclusionReadCounter function gets the latest dialysate
+ * inlet pump occlusion read counter.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last dialysate inlet pump occlusion read counter
+ *************************************************************************/
+U08 getFPGADialInPumpOcclusionReadCounter( void )
+{
+    return fpgaSensorReadings.dialysateInOcclusionReadCount;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGADialOutPumpOcclusionReadCounter function gets the latest dialysate
+ * outlet pump occlusion read counter.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last dialysate outlet pump occlusion read counter
+ *************************************************************************/
+U08 getFPGADialOutPumpOcclusionReadCounter( void )
+{
+    return fpgaSensorReadings.dialysateOutOcclusionReadCount;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGABloodPumpOcclusionErrorCounter function gets the latest blood
+ * pump occlusion error counter.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last blood pump occlusion error counter
+ *************************************************************************/
+U08 getFPGABloodPumpOcclusionErrorCounter( void )
+{
+    return fpgaSensorReadings.bloodOcclusionErrorCount;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGADialInPumpOcclusionErrorCounter function gets the latest dialysate
+ * inlet pump occlusion error counter.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last dialysate inlet pump occlusion error counter
+ *************************************************************************/
+U08 getFPGADialInPumpOcclusionErrorCounter( void )
+{
+    return fpgaSensorReadings.dialysateInOcclusionErrorCount;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGADialOutPumpOcclusionErrorCounter function gets the latest dialysate
+ * outlet pump occlusion error counter.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last dialysate outlet pump occlusion error counter
+ *************************************************************************/
+U08 getFPGADialOutPumpOcclusionErrorCounter( void )
+{
+    return fpgaSensorReadings.dialysateOutOcclusionErrorCount;
+}
+
+/*********************************************************************//**
+ * @brief
  * The getFPGAArterialPressure function gets the latest arterial pressure reading.
  * High byte indicates alarm status for ADC channel.
  * Low 24-bits are channel reading.  Subtract 2^23 from low 24 bits to get
@@ -1318,7 +1538,7 @@
 
 /*********************************************************************//**
  * @brief
- * The getFPGAVenousPressure function gets the venous arterial pressure reading.
+ * The getFPGAVenousPressure function gets the latest venous pressure reading.
  * The high 2 bits are status bits: 00=ok, 01=cmd mode, 10=stale data, 11=diag
  * The low 14 bits are data.  Zero is at 1638.  Values above are positive,
  * below are negative.
@@ -1333,6 +1553,224 @@
 
 /*********************************************************************//**
  * @brief
+ * The getFPGAVenousPressureTemperature function gets the latest venous pressure
+ * sensor temperature reading.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last venous pressure sensor temperature reading
+ *************************************************************************/
+F32 getFPGAVenousPressureTemperature( void )
+{
+    F32 result = ( (F32)fpgaSensorReadings.venousTemperature / FPGA_PBO_TEMP_DIVISOR ) * FPGA_PBO_TEMP_GAIN - FPGA_PBO_TEMP_OFFSET;
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGAVenousPressureReadCounter function gets the latest venous pressure
+ * sensor read counter.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last venous pressure sensor read counter
+ *************************************************************************/
+U08 getFPGAVenousPressureReadCounter( void )
+{
+    return fpgaSensorReadings.venousReadCounter;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The setFPGASyringePumpControlFlags function sets the syringe pump control
+ * register per given bit flags.
+ * @details Inputs: none
+ * @details Outputs: fpgaActuatorSetPoints
+ * @param bitFlags control bit settings for syringe pump
+ * @return none
+ *************************************************************************/
+void setFPGASyringePumpControlFlags( U08 bitFlags )
+{
+    fpgaActuatorSetPoints.syringePumpControl = bitFlags;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The setFPGASyringePumpADCandDACControlFlags function sets the syringe pump
+ * ADC/DAC control register per given bit flags.
+ * @details Inputs: none
+ * @details Outputs: fpgaActuatorSetPoints
+ * @param bitFlags ADC/DAC control bit settings for syringe pump
+ * @return none
+ *************************************************************************/
+void setFPGASyringePumpADCandDACControlFlags( U08 bitFlags )
+{
+    fpgaActuatorSetPoints.syringePumpADCandDACControl = bitFlags;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The setFPGASyringePumpDACOutputLevel function sets the syringe pump force
+ * sensor DAC output level register to a given value.
+ * @details Inputs: none
+ * @details Outputs: fpgaActuatorSetPoints
+ * @param counts level to set syringe pump force sensor DAC to
+ * @return none
+ *************************************************************************/
+void setFPGASyringePumpDACOutputLevel( U16 counts )
+{
+    fpgaActuatorSetPoints.syringePumpDACOut = counts;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The setFPGASyringePumpStepToggleTime function sets the syringe pump stepper
+ * toggle time register to a given period (in uSec).
+ * @details Inputs: none
+ * @details Outputs: fpgaActuatorSetPoints
+ * @param microSeconds toggle the stepper motor at this time interval to set pump speed
+ * @return none
+ *************************************************************************/
+void setFPGASyringePumpStepToggleTime( U32 microSeconds )
+{
+    fpgaActuatorSetPoints.syringePumpStepToggleTime = microSeconds;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGASyringePumpStatus function gets the latest syringe pump status
+ * register reading.  Bit 0 indicates a fault.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last syringe pump status reading
+ *************************************************************************/
+U08 getFPGASyringePumpStatus( void )
+{
+    return fpgaSensorReadings.syringePumpStatus;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGASyringePumpADCReadCounter function gets the latest syringe pump
+ * ADC read counter.  Counter is 8-bit and rolls over when exceeding 255.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last syringe pump ADC read counter
+ *************************************************************************/
+U08 getFPGASyringePumpADCReadCounter( void )
+{
+    return fpgaSensorReadings.syringePumpADCReadCounter;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGASyringePumpADCandDACStatus function gets the latest syringe pump
+ * ADC/DAC status register reading.
+ *    Bit 7 = DAC write and read-back done
+ *    Bit 6 = I2C error on DAC data transfer
+ *    Bit 0..5 = count of I2C errors, rolls over after 63
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last syringe pump ADC/DAC status reading
+ *************************************************************************/
+U08 getFPGASyringePumpADCandDACStatus( void )
+{
+    return fpgaSensorReadings.syringePumpADCandDACStatus;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGASyringePumpEncoderStatus function gets the latest syringe pump
+ * encoder status register reading.
+ *    Bit 7 = direction (0=fwd, 1=rev)
+ *    Bit 0..5 = direction error count (# of errors after power up, rolls over after 63)
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last syringe pump encoder status reading
+ *************************************************************************/
+U08 getFPGASyringePumpEncoderStatus( void )
+{
+    return fpgaSensorReadings.syringePumpEncoderStatus;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGASyringePumpEncoderPosition function gets the latest syringe pump
+ * encoder position reading.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last syringe pump encoder position reading
+ *************************************************************************/
+U32 getFPGASyringePumpEncoderPosition( void )
+{
+    return fpgaSensorReadings.syringePumpEncPosition;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGASyringePumpADCChannel0 function gets the latest syringe pump ADC
+ * channel 0 register reading (syringe pump force sensor).
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last syringe pump ADC channel 0 reading
+ *************************************************************************/
+U16 getFPGASyringePumpADCChannel0( void )
+{
+    return fpgaSensorReadings.syringePumpAdcDataReadCh0;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGASyringePumpADCChannel1 function gets the latest syringe pump ADC
+ * channel 1 register reading (syringe detection switch).
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last syringe pump ADC channel 1 reading
+ *************************************************************************/
+U16 getFPGASyringePumpADCChannel1( void )
+{
+    return fpgaSensorReadings.syringePumpAdcDataReadCh1;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGASyringePumpADCChannel2 function gets the latest syringe pump ADC
+ * channel 2 register reading (syringe pump home position sensor).
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last syringe pump ADC channel 2 reading
+ *************************************************************************/
+U16 getFPGASyringePumpADCChannel2( void )
+{
+    return fpgaSensorReadings.syringePumpAdcDataReadCh2;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGASyringePumpADCChannel3 function gets the latest syringe pump ADC
+ * channel 3 register reading.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last syringe pump ADC channel 3 reading
+ *************************************************************************/
+U16 getFPGASyringePumpADCChannel3( void )
+{
+    return fpgaSensorReadings.syringePumpAdcDataReadCh3;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGATimerCount function gets the latest FPGA timer millisecond count.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return last FPGA timer count
+ *************************************************************************/
+U16 getFPGATimerCount( void )
+{
+    return fpgaSensorReadings.fpgaTimerCount_ms;
+}
+
+/*********************************************************************//**
+ * @brief
  * The getFPGAAccelAxes function gets the accelerometer axis readings.
  * Axis readings are in ADC counts.  0.004 g per LSB.
  * @details Inputs: fpgaSensorReadings
@@ -1404,119 +1842,215 @@
 
 /*********************************************************************//**
  * @brief
- * The getFPGAArterialAirBubbleStatus function gets the latest arterial air
- * bubble detector status.
- * @details Inputs: fpgaSensorReadings
+ * The getDoorState function gets the current state of door switch.
+ * @details Inputs: none
  * @details Outputs: none
- * @return TRUE if air bubble is detected, otherwise FALSE
+ * @return current door state
  *************************************************************************/
-BOOL getFPGAArterialAirBubbleStatus( void )
+OPN_CLS_STATE_T getFPGADoorState( void )
 {
-    U16 const status = fpgaSensorReadings.fpgaGPIO & FPGA_ADA_INPUT_STATUS_MASK;
+    // TODO: Get actual door state from FPGA or GPIO
+    BOOL const status = 0x0;
 
-    return ( 0 == status ? FALSE : TRUE );
+    return ( 0 == status ? STATE_CLOSED : STATE_OPEN );
 }
 
 /*********************************************************************//**
  * @brief
- * The getFPGAVenousAirBubbleStatus function gets the latest venous air
- * bubble detector status.
+ * The setFPGAValvesControlMode function sets the valves control mode.
+ * @details Inputs: fpgaActuatorSetPoints
+ * @details Outputs: fpgaActuatorSetPoints
+ * @param bits : The bits to enable the PID controller of a valve
+ * @return none
+ *************************************************************************/
+void setFPGAValvesControlMode( U16 bits )
+{
+    fpgaActuatorSetPoints.fpgaPIDControl = bits;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getValvesStatus function reads the status of the valves
  * @details Inputs: fpgaSensorReadings
  * @details Outputs: none
- * @return TRUE if air bubble is detected, otherwise FALSE
+ * @return The status of the valves
  *************************************************************************/
-BOOL getFPGAVenousAirBubbleStatus( void )
+U16 getFPGAValvesStatus( void )
 {
-    U16 const status = fpgaSensorReadings.fpgaGPIO & FPGA_ADV_INPUT_STATUS_MASK;
-
-    return ( 0 == status ? FALSE : TRUE );
+    return fpgaSensorReadings.valveStatus;
 }
 
 /*********************************************************************//**
  * @brief
- * The setFPGASensorTest function sets the sensor test output.
- * @details Inputs: fpgaActuatorSetPoints
- * @details Outputs: fpgaActuatorSetPoints
- * @param sensorTest
- * @return none
+ * The noFPGAFluidLeakDetected function returns TRUE if no fluid leak has been
+ * detected (dry) and FALSE if a fluid leak has been detected (wet).
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return noFPGAFluidLeakDetected
  *************************************************************************/
-void setFPGASensorTest( U08 sensorTest )
+BOOL noFPGAFluidLeakDetected( void )
 {
-    fpgaActuatorSetPoints.fpgaSensorTest = sensorTest;
+    U16 noFPGAFluidLeakDetected = fpgaSensorReadings.fpgaGPIO & FPGA_FLUID_LEAK_STATE_MASK;
+
+    return ( 0 == noFPGAFluidLeakDetected ? FALSE : TRUE );
 }
 
 /*********************************************************************//**
  * @brief
- * The getFPGABloodLeakDetectorStatus function gets the latest blood leak
- * detector status.
+ * The noFPGABloodLeakDetected function returns TRUE if no blood leak has been
+ * detected and FALSE if a blood leak has been detected.
  * @details Inputs: fpgaSensorReadings
  * @details Outputs: none
- * @return TRUE if blood leak is detected, otherwise FALSE
+ * @return noFPGABloodLeakDetected
  *************************************************************************/
-BOOL getFPGABloodLeakDetectorStatus( void )
+BOOL noFPGABloodLeakDetected( void )
 {
-    U16 const status = fpgaSensorReadings.fpgaGPIO & FPGA_BLOOD_LEAK_STATUS_MASK;
+    U16 noFPGABloodLeakDetected = fpgaSensorReadings.fpgaGPIO & FPGA_BLOOD_LEAK_STATUS_MASK;
 
-    return ( 0 == status ? FALSE : TRUE );
+    return ( 0 == noFPGABloodLeakDetected ? TRUE : FALSE );
 }
 
 /*********************************************************************//**
  * @brief
- * The getDoorState function gets the current state of door switch.
- * @details Inputs: none
+ * The FPGABloodLeakZeroDetected function returns TRUE if blood leak zeroing has
+ * been detected and FALSE if no blood leak zeroing has been detected.
+ * @details Inputs: fpgaSensorReadings
  * @details Outputs: none
- * @return current door state
+ * @return FPGABloodLeakZeroDetected
  *************************************************************************/
-OPN_CLS_STATE_T getFPGADoorState( void )
+BOOL FPGABloodLeakZeroDetected( void )
 {
-    // TODO: Get actual door state from FPGA or GPIO
-    BOOL const status = 0x0;
+    U16 FPGABloodLeakZeroDetected = fpgaSensorReadings.fpgaGPIO & FPGA_BLOOD_LEAK_ZERO_STATE_MASK;
 
-    return ( 0 == status ? STATE_CLOSED : STATE_OPEN );
+    return ( 0 == FPGABloodLeakZeroDetected ? FALSE : TRUE );
 }
 
 /*********************************************************************//**
  * @brief
- * The setFPGAValvesControlMode function sets the valves control mode.
- * @details Inputs: fpgaActuatorSetPoints
+ * The setFPGABloodLeakZero function sets the Blood Leak detector into
+ * zeroing mode via the FPGA.
+ * @details Inputs: none
  * @details Outputs: fpgaActuatorSetPoints
- * @param bits : The bits to enable the PID controller of a valve
  * @return none
  *************************************************************************/
-void setFPGAValvesControlMode( U16 bits )
+void setFPGABloodLeakZero( void )
 {
-    fpgaActuatorSetPoints.fpgaPIDControl = bits;
+    fpgaActuatorSetPoints.fpgaSensorTest |= FPGA_BLOOD_LEAK_ZERO_CMD;
 }
 
 /*********************************************************************//**
  * @brief
- * The getValvesStatus function reads the status of the valves
+ * The clearFPGABloodLeakZero function clears the Blood Leak detector from
+ * zeroing mode via the FPGA.
  * @details Inputs: fpgaSensorReadings
  * @details Outputs: none
- * @return The status of the valves
+ * @return none
  *************************************************************************/
-U16 getFPGAValvesStatus( void )
+void clearFPGABloodLeakZero( void )
 {
-    return fpgaSensorReadings.valveStatus;
+    fpgaActuatorSetPoints.fpgaSensorTest &= ~FPGA_BLOOD_LEAK_ZERO_CMD;
 }
 
 /*********************************************************************//**
  * @brief
- * The noFluidLeakDetected function returns TRUE if no fluid leak has been
- * detected (dry) and FALSE if a fluid leak has been detected (wet).
+ * The setFPGABloodLeakSelfTest function sets the Blood Leak detector into
+ * self-test mode via the FPGA.
+ * @details Inputs: none
+ * @details Outputs: fpgaActuatorSetPoints
+ * @return: none
+ *************************************************************************/
+void setFPGABloodLeakSelfTest( void )
+{
+    fpgaActuatorSetPoints.fpgaSensorTest |= FPGA_BLOOD_LEAK_SELF_TEST_CMD;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The clearFPGABloodLeakSelfTest function clears the Blood Leak detector from
+ * self-test mode via the FPGA.
  * @details Inputs: fpgaSensorReadings
  * @details Outputs: none
- * @return noFluidLeakDetected
+ * @return none
  *************************************************************************/
-BOOL noFPGAFluidLeakDetected( void )
+void clearFPGABloodLeakSelfTest( void )
 {
-    U16 noFluidLeakDetected = fpgaSensorReadings.fpgaGPIO & FPGA_FLUIDLEAK_STATE_MASK;
+    fpgaActuatorSetPoints.fpgaSensorTest &= ~FPGA_BLOOD_LEAK_SELF_TEST_CMD;
+}
 
-    return ( 0 == noFluidLeakDetected ? FALSE : TRUE );
+/*********************************************************************//**
+ * @brief
+ * The noFPGABubbleDetected function returns TRUE if no air bubble has been
+ * detected and FALSE if an air bubble has been detected.
+ * @details Inputs: fpgaSensorReadings
+ * @details Outputs: none
+ * @return noFPGABubbleDetected
+ *************************************************************************/
+BOOL noFPGABubbleDetected( U32 bubble )
+{
+    U16 noFPGABubbleDetected = 0;
+
+    if ( bubble == ADA )
+    {
+        noFPGABubbleDetected = fpgaSensorReadings.fpgaGPIO & FPGA_ADA_BUBBLE_STATUS_MASK;
+    }
+    else if ( bubble == ADV )
+    {
+        noFPGABubbleDetected = fpgaSensorReadings.fpgaGPIO & FPGA_ADV_BUBBLE_STATUS_MASK;
+    }
+    else
+    {
+        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_HD_INVALID_BUBBLE_ID, bubble )
+    }
+
+    return ( 0 != noFPGABubbleDetected ? TRUE : FALSE );
 }
 
 /*********************************************************************//**
  * @brief
+ * The setFPGABubbleSelfTest function sets the given air bubble detector into
+ * self-test mode via the FPGA.
+ * @details Inputs: none
+ * @details Outputs: fpgaActuatorSetPoints
+ * @return: none
+ *************************************************************************/
+void setFPGABubbleSelfTest( U32 bubble )
+{
+    if ( bubble == ADA )
+    {
+        fpgaActuatorSetPoints.fpgaSensorTest |= FPGA_ADA_BUBBLE_SELF_TEST_CMD;
+    }
+    else if ( bubble == ADV )
+    {
+        fpgaActuatorSetPoints.fpgaSensorTest |= FPGA_ADV_BUBBLE_SELF_TEST_CMD;
+    }
+}
+
+/*********************************************************************//**
+ * @brief
+ * The clearFPGABubbleSelfTest function clears the given air bubble detector
+ * from self-test mode via the FPGA.
+ * @details Inputs: none
+ * @details Outputs: fpgaActuatorSetPoints
+ * @return: none
+ *************************************************************************/
+void clearFPGABubbleSelfTest( U32 bubble )
+{
+    if ( bubble == ADA )
+    {
+        fpgaActuatorSetPoints.fpgaSensorTest &= ~FPGA_ADA_BUBBLE_SELF_TEST_CMD;
+    }
+    else if ( bubble == ADV )
+    {
+        fpgaActuatorSetPoints.fpgaSensorTest &= ~FPGA_ADV_BUBBLE_SELF_TEST_CMD;
+    }
+    else
+    {
+        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_HD_INVALID_BUBBLE_ID, bubble )
+    }
+}
+
+/*********************************************************************//**
+ * @brief
  * The setValveDialyzerInletPosition function sets the position of VDi
  * in counts
  * @details Inputs: fpgaActuatorSetPoints
@@ -1758,6 +2292,30 @@
     return fpgaSensorReadings.VBACurrent;
 }
 
+/*********************************************************************//**
+ * @brief
+ * The getFPGABoardTemperature function reads the FPGA board temperature.
+ * @details Inputs: none
+ * @details Outputs: fpgaSensorReadings
+ * @return Current FPGA board temperature
+ *************************************************************************/
+U16 getFPGABoardTemperature( void )
+{
+    return fpgaSensorReadings.fpgaBoardTemperature;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getFPGAPBAADCTemperature function reads the PBA ADC temperature.
+ * @details Inputs: none
+ * @details Outputs: fpgaSensorReadings
+ * @return PBA ADC temperature
+ *************************************************************************/
+U32 getFPGAPBAADCTemperature( void )
+{
+    return fpgaSensorReadings.adc1Channel1;
+}
+
 #ifdef DEBUG_ENABLED
 /*********************************************************************//**
  * @brief