/************************************************************************** * * Copyright (c) 2020-2022 Diality Inc. - All Rights Reserved. * * THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN * WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. * * @file Common.h * * @author (last) Dara Navaei * @date (last) 21-Sep-2022 * * @author (original) Sean * @date (original) 04-Feb-2020 * ***************************************************************************/ #ifndef __COMMON_H__ #define __COMMON_H__ #include "hal_stdtypes.h" /** * @defgroup CommonHeader CommonHeader * @brief Provides commonly used definitions and macros. * * @addtogroup CommonHeader * @{ */ // ********** public definitions ********** // **** Types **** typedef float F32; ///< 32-bit floating point type typedef double F64; ///< 64-bit floating point type typedef long long S64; ///< 64-bit signed integer type typedef unsigned int U32; ///< 32-bit unsigned integer type typedef int S32; ///< 32-bit signed integer type typedef unsigned short U16; ///< 16-bit unsigned integer type typedef short S16; ///< 16-bit signed integer type typedef unsigned char U08; ///< 8-bit unsigned integer type typedef unsigned int BOOL; ///< 32-bit boolean type typedef unsigned char BYTE; ///< 8-bit byte type /// List of pin signal states. typedef enum Pin_Signal_States { PIN_SIGNAL_LOW = 0, ///< Low signal level PIN_SIGNAL_HIGH, ///< High signal level NUM_OF_PIN_SIGNAL_STATES ///< Number of pin signal states } PIN_SIGNAL_STATE_T; /// List of self-test status. typedef enum Self_Test_Status { SELF_TEST_STATUS_IN_PROGRESS = 0, ///< Self test is in progress SELF_TEST_STATUS_PASSED, ///< Self test has passed SELF_TEST_STATUS_FAILED, ///< Self test has failed NUM_OF_SELF_TEST_STATUS ///< Number of self-test status } SELF_TEST_STATUS_T; /// List of 2-way states. typedef enum Two_Way_States { STATE_CLOSED = 0, ///< Closed state STATE_OPEN, ///< Open state NUM_OF_OPN_CLS_STATES ///< Number of 2-way states } OPN_CLS_STATE_T; /// List of motor directions. typedef enum Motor_Directions { MOTOR_DIR_FORWARD = 0, ///< Motor direction is forward MOTOR_DIR_REVERSE, ///< Motor direction is reverse NUM_OF_MOTOR_DIRECTIONS ///< Number of motor directions } MOTOR_DIR_T; /// List of pump control modes. typedef enum Pump_Control_Modes { PUMP_CONTROL_MODE_CLOSED_LOOP = 0, ///< Pump controlled based on set point and feedback PUMP_CONTROL_MODE_OPEN_LOOP, ///< Pump controlled to set PWM duty cycle NUM_OF_PUMP_CONTROL_MODES ///< Number of pump control modes } PUMP_CONTROL_MODE_T; // **** Common Definitions **** #define NEARLY_INFINITY 1.0E20 ///< Value that is nearly infinity. #define NEARLY_ZERO 0.00000001F ///< Value that is nearly zero. Used for floating point zero comparisons (e.g. divide by zero checks) #define HEX_64_K 0x10000 ///< 64K (65536 in decimal) #define HEX_32_BIT_FULL_SCALE 0xFFFFFFFF ///< 32-bit full scale value #define MASK_OFF_MSB 0x00FF ///< Bits to mask off the most significant byte of a 2-byte word #define MASK_OFF_LSB 0xFF00 ///< Bits to mask off the least significant byte of a 2-byte word #define MASK_OFF_MSW 0x0000FFFF ///< Bits to mask off the most significant 2-byte word of a 4-byte word #define MASK_OFF_LSW 0xFFFF0000 ///< Bits to mask off the least significant 2-byte word of a 4-byte word #define MASK_OFF_U32_MSB 0x00FFFFFF ///< Bits to mask off the most significant byte word of a 4-byte word #define MASK_OFF_U32_LSB 0xFFFFFF00 ///< Bits to mask off the least significant byte of a 4-byte word #define MASK_OFF_U32_MSBS 0x000000FF ///< Bits to mask off all but the least significant byte of a 4-byte word #define SHIFT_8_BITS_FOR_BYTE_SHIFT 8 ///< Number of bits to shift in order to shift a byte #define SHIFT_16_BITS_FOR_WORD_SHIFT 16 ///< Number of bits to shift in order to shift 2 bytes #define SHIFT_24_BITS 24 ///< Number of bits to shift in order to shift 3 bytes #define MASK_OFF_NIBBLE_LSB 0xF0 ///< Bits to mask off the least significant nibble of a byte #define MASK_OFF_NIBBLE_MSB 0x0F ///< Bits to mask off the most significant nibble of a byte #define MAX_DOUBLE_DIGIT_DECIMAL 99U ///< Maximum value for a decimal byte #define MAX_SINGLE_DIGIT_DECIMAL 9U ///< Maximum value for a decimal nibble #define SHIFT_BITS_BY_4 4U ///< Number of bits to shift in order to shift a nibble #define SHIFT_BITS_BY_31 31 ///< Shift bits by 31 #define FLOAT_TO_INT_ROUNDUP_OFFSET 0.5F ///< Offset to add to a floating point value for rounding rounding when converting to integer #define ML_PER_LITER 1000 ///< Number of milliliters in a liter #define MA_PER_AMP 1000 ///< Number of milliamps in an amp #define MS_PER_SECOND 1000 ///< Number of milliseconds in a second #define US_PER_SECOND 1000000 ///< Number of microseconds in a millisecond #define SEC_PER_MIN 60 ///< Number of seconds in a minute #define FRACTION_TO_PERCENT_FACTOR 100.0F ///< Percentage factor (100) #define MIN_PER_HOUR 60 ///< Number of minutes in an hour #define PI 3.1415927F ///< PI #define SECONDS_IN_A_DAY 86400 ///< Number of seconds in a day #define BITS_8_FULL_SCALE 256 ///< Full scale range for 8 bit ADC or DAC #define BITS_10_FULL_SCALE 1024 ///< Full scale range for 10 bit ADC or DAC #define BITS_12_FULL_SCALE 4096 ///< Full scale range for 12 bit ADC or DAC #define BITS_14_FULL_SCALE 16384 ///< Full scale range for 14 bit ADC or DAC #define BITS_16_FULL_SCALE 65536 ///< Full scale range for 16 bit ADC or DAC #define BITS_24_FULL_SCALE 16777216 ///< Full scale range for 24 bit ADC or DAC #define HALF 0.5F ///< Half // **** Common Macros **** #define FLOAT_TO_INT_WITH_ROUND(f) ((f) < 0.0F ? (S32)((f) - FLOAT_TO_INT_ROUNDUP_OFFSET) : (S32)((f) + FLOAT_TO_INT_ROUNDUP_OFFSET)) ///< Macro converts a floating point value to an integer #define CAP(v, u) ((v) > (u) ? (u) : (v)) ///< Macro caps a value to a maximum #define RANGE(v, l, u) ((v) > (u) ? (u) : ((v) < (l) ? (l) : (v))) ///< Macro enforces a range on a value #define INC_WRAP(v, l, u) ((v) >= (u) ? (l) : ((v) + 1)) ///< Macro increments a value and wraps to a minimum when a maximum is reached #define DEC_WRAP(v, l, u) ((v) <= (l) ? (u) : ((v) - 1)) ///< Macro decrements a value and wraps to a maximum when a minimum is reached #define INC_CAP(v, u) ((v) >= (u) ? (u) : ((v) + 1)) ///< Macro increments a value but does not allow to exceed a maximum #define MAX(a, b) ((a) < (b) ? (b) : (a)) ///< Macro enforces a maximum on a value #define MIN(a, b) ((a) > (b) ? (b) : (a)) ///< Macro enforces a minimum on a value #define GET_LSB_OF_WORD(w) ((U08)((w) & MASK_OFF_MSB)) ///< Macro returns the least signficant byte of a 2-byte word #define GET_MSB_OF_WORD(w) ((U08)(((w) >> SHIFT_8_BITS_FOR_BYTE_SHIFT) & MASK_OFF_MSB)) ///< Macro returns the most signficant byte of a 2-byte word #define GET_LSW_OF_LONG(l) ((U16)((l) & MASK_OFF_MSW)) ///< Macro returns the least signficant 2-byte word of a 4-byte word #define GET_MSW_OF_LONG(l) ((U16)(((l) >> SHIFT_16_BITS_FOR_WORD_SHIFT) & MASK_OFF_MSW)) ///< Macro returns the most signficant 2-byte word of a 4-byte word #define MAKE_WORD_OF_BYTES(h, l) ((((U16)(h) << SHIFT_8_BITS_FOR_BYTE_SHIFT) & MASK_OFF_LSB) | ((U16)(l) & MASK_OFF_MSB)) ///< Macro merges two bytes into a 2-byte word #define MAKE_LONG_OF_WORDS(h, l) ((((U32)(h) << SHIFT_16_BITS_FOR_WORD_SHIFT) & MASK_OFF_LSW) | ((U32)(l) & MASK_OFF_MSW)) ///< Macro merges two 2-byte words into a 4-byte word #define GET_TOGGLE(v, l, h) ((v) == (l) ? (h) : (l)) ///< Macro toggles a value #define BIT_BY_POS(p) (1U << (p)) ///< Macro returns a bit mask for a bit of given position #define RAD2DEG(r) ((r) * 180.0F / PI) ///< Macro converts radians to degrees /// Macro to set a specific alarm with 1 piece of unsigned 32-bit alarm data. #define SET_ALARM_WITH_1_U32_DATA(a,d1) { \ ALARM_DATA_T dat1; \ dat1.dataType = ALARM_DATA_TYPE_U32; \ dat1.data.uInt.data = (U32)(d1); \ activateAlarm1Data( a, dat1 ); \ } /// Macro to set a specific alarm with 1 piece of floating point alarm data. #define SET_ALARM_WITH_1_F32_DATA(a,d1) { \ ALARM_DATA_T dat1; \ dat1.dataType = ALARM_DATA_TYPE_F32; \ dat1.data.flt.data = (F32)(d1); \ activateAlarm1Data( a, dat1 ); \ } /// Macro to set a specific alarm with 2 pieces of unsigned 32-bit alarm data. #define SET_ALARM_WITH_2_U32_DATA(a,d1,d2) { \ ALARM_DATA_T dat1; \ ALARM_DATA_T dat2; \ dat1.dataType = ALARM_DATA_TYPE_U32; \ dat1.data.uInt.data = (U32)(d1); \ dat2.dataType = ALARM_DATA_TYPE_U32; \ dat2.data.uInt.data = (U32)(d2); \ activateAlarm2Data( a, dat1, dat2 ); \ } /// Macro to set a specific alarm with 2 pieces of floating point alarm data. #define SET_ALARM_WITH_2_F32_DATA(a,d1,d2) { \ ALARM_DATA_T dat1; \ ALARM_DATA_T dat2; \ dat1.dataType = ALARM_DATA_TYPE_F32; \ dat1.data.flt.data = (F32)(d1); \ dat2.dataType = ALARM_DATA_TYPE_F32; \ dat2.data.flt.data = (F32)(d2); \ activateAlarm2Data( a, dat1, dat2 ); \ } /// Record structure for unsigned integer event data. typedef struct { U32 data; ///< Event data of unsigned integer type. } EVENT_DATA_U32_T; /// Record structure for signed integer event data. typedef struct { S32 data; ///< Event data of signed integer type. } EVENT_DATA_S32_T; /// Record structure for floating point event data. typedef struct { F32 data; ///< Event data of floating point type. } EVENT_DATA_F32_T; /// Record structure for boolean event data. typedef struct { BOOL data; ///< Event data of boolean type. } EVENT_DATA_BOOL_T; /// Record structure for event data of any supported type. typedef union { EVENT_DATA_U32_T uInt; ///< Event data of unsigned integer type. EVENT_DATA_S32_T sInt; ///< Event data of signed integer type. EVENT_DATA_F32_T flt; ///< Event data of floating point type. EVENT_DATA_BOOL_T bln; ///< Event data of boolean type. } EVENT_DATAS_T; /// Event data types list. typedef enum Event_Data_Types { EVENT_DATA_TYPE_NONE = 0, ///< No data given. EVENT_DATA_TYPE_U32 = 1, ///< Event data is unsigned 32-bit integer type. EVENT_DATA_TYPE_S32 = 2, ///< Event data is signed 32-bit integer type. EVENT_DATA_TYPE_F32 = 3, ///< Event data is 32-bit floating point type. EVENT_DATA_TYPE_BOOL = 4, ///< Event data is 32-bit boolean type. NUM_OF_EVENT_DATA_TYPES ///< Total number of event data types. } EVENT_DATA_TYPES_T; /// Record structure for event data including the data type to aid in interpretation. typedef struct { EVENT_DATA_TYPES_T dataType; ///< The type of event data provided. EVENT_DATAS_T data; ///< The event data of specified type. } EVENT_DATA_T; /// Macro to set a specific alarm with 2 pieces of unsigned 32-bit alarm data. #define SEND_EVENT_WITH_2_U32_DATA(e,d1,d2) { \ EVENT_DATA_T dat1; \ EVENT_DATA_T dat2; \ dat1.dataType = EVENT_DATA_TYPE_U32; \ dat1.data.uInt.data = (U32)(d1); \ dat2.dataType = EVENT_DATA_TYPE_U32; \ dat2.data.uInt.data = (U32)(d2); \ sendEvent( e, dat1, dat2 ); \ } /// Macro to set a specific alarm with 2 pieces of floating point alarm data. #define SEND_EVENT_WITH_2_F32_DATA(e,d1,d2) { \ EVENT_DATA_T dat1; \ EVENT_DATA_T dat2; \ dat1.dataType = EVENT_DATA_TYPE_F32; \ dat1.data.flt.data = (F32)(d1); \ dat2.dataType = EVENT_DATA_TYPE_F32; \ dat2.data.flt.data = (F32)(d2); \ sendEvent( e, dat1, dat2 ); \ } // **** Common Broadcast Data **** #pragma pack(push,1) /// Heaters data structure. typedef struct { F32 mainPrimayHeaterDC; ///< Main primary heater DC F32 smallPrimaryHeaterDC; ///< Small primary heater DC F32 trimmerHeaterDC; ///< Trimmer heater DC F32 primaryTargetTemp; ///< Primary heater target temperature F32 trimmerTargetTemp; ///< Trimmer heater target temperature U32 primaryHeaterState; ///< Primary heater state U32 trimmerHeaterState; ///< Trimmer heater state F32 primaryEfficiency; ///< Primary heater efficiency F32 primaryCalcTargetTemp; ///< Primary heater calculated target temperature F32 trimmerCalcCurrentTemp; ///< Trimmer heater calculated current temperature } HEATERS_DATA_T; /// Temperature sensors data. typedef struct { F32 inletPrimaryHeater; ///< Inlet primary heater temperature sensor F32 heatDisinfect; ///< Heat Disinfect temperature sensor F32 outletPrimaryHeater; ///< Outlet primary heater temperature sensor F32 conductivitySensor1; ///< Conductivity sensor 1 temperature sensor F32 conductivitySensor2; ///< Conductivity sensor 2 temperature sensor F32 outletRedundant; ///< Outlet redundant temperature sensor F32 inletDialysate; ///< Inlet dialysate temperature sensor F32 primaryHeaterThermocouple; ///< Primary heaters thermocouple sensor F32 trimmerHeaterThermocouple; ///< Trimmer heater thermocouple sensor F32 priamyHeaterColdjunction; ///< Primary heaters cold junction temperature sensor F32 trimmerHeaterColdjunction; ///< Trimmer heater cold junction temperature sensor F32 primaryHeaterInternal; ///< Primary heaters internal temperature (calculated from thermocouple and cold junction) F32 trimmerHeaterInternal; ///< Trimmer heater internal temperature (calculated from thermocouple and cold junction) F32 fpgaBoard; ///< FPGA board temperature sensor F32 loadCellA1B1; ///< Load cell A1/B1 temperature sensor F32 loadCellA2B2; ///< Load cell A2/B2 temperature sensor F32 internalTHDORTD; ///< THDo RTD channel temperature sensor F32 internalTDIRTD; ///< TDI RTD channel temperature sensor F32 interalTHDRTD; ///< THd RTD channel temperature sensor F32 internalCondSnsrTemp; ///< Conductivity Sensor internal temperature sensor } TEMPERATURE_SENSORS_DATA_T; /// Loadcell measurements struct. typedef struct { F32 loadCellA1inGram; ///< Loadcell A1 measurement in gram F32 loadCellA2inGram; ///< Loadcell A2 measurement in gram F32 loadCellB1inGram; ///< Loadcell B1 measurement in gram F32 loadCellB2inGram; ///< Loadcell B2 measurement in gram } LOAD_CELL_DATA_T; #pragma pack(pop) // **** VectorCAST Definitions **** #ifdef _VECTORCAST_ #define _enable_IRQ() #define _disable_IRQ() #define _enable_FIQ() #endif // include alarm mgmt header so any module can trigger an alarm #include "AlarmMgmt.h" // include Message definitions header for access to system message IDs #include "MsgDefs.h" // include test support definitions and macros #include "TestSupport.h" /**@}*/ #endif