Index: firmware/App/Drivers/ConductivitySensors.c =================================================================== diff -u -r9e6e86f604c8cce7c1704ae55d1e026de3422782 -r325e67dab10f6666702bf0f1256015b31e58de4f --- firmware/App/Drivers/ConductivitySensors.c (.../ConductivitySensors.c) (revision 9e6e86f604c8cce7c1704ae55d1e026de3422782) +++ firmware/App/Drivers/ConductivitySensors.c (.../ConductivitySensors.c) (revision 325e67dab10f6666702bf0f1256015b31e58de4f) @@ -55,7 +55,7 @@ /// Conductivity Sensor Control group typedef struct { - BOOL resetRequested; ///< Flag indicates a reset command for the given conducitvity sensor. + BOOL resetRequested; ///< Flag indicates a reset command for the given conductivity sensor. BOOL initEnable; ///< Flag indicates a enables initialization procedure for the given conductivity sensor. BOOL writeEnable; ///< Flag indicates a enables write transaction for the given conductivity sensor. BOOL readEnable; ///< Flag indicates a enables read transaction for the given conductivity sensor. @@ -83,10 +83,10 @@ // ********** private function prototypes ********** static void checkConductivitySensors( void ); -static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadInitiate( void ); -static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteComplete( void ); -static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteInitiate( void ); -static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadComplete( void ); +static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadInitiate( CONDUCTIVITY_SENSORS_T sensorID ); +static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteComplete( CONDUCTIVITY_SENSORS_T sensorID ); +static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteInitiate( CONDUCTIVITY_SENSORS_T sensorID ); +static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadComplete( CONDUCTIVITY_SENSORS_T sensorID ); /*********************************************************************//** * @brief @@ -97,45 +97,45 @@ *************************************************************************/ void initConductivitySensors( void ) { - U08 i; + CONDUCTIVITY_SENSORS_T sensor; // Initialize override structures for each conductivity sensor - for ( i = 0; i < NUM_OF_CONDUCTIVITY_SENSORS; i++ ) + for ( sensor = FIRST_DD_COND_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) { - currentConductivityReadings[ i ].data = 0.0F; - currentConductivityReadings[ i ].ovData = 0.0F; - currentConductivityReadings[ i ].ovInitData = 0.0F; - currentConductivityReadings[ i ].override = OVERRIDE_RESET; + currentConductivityReadings[ sensor ].data = 0.0F; + currentConductivityReadings[ sensor ].ovData = 0.0F; + currentConductivityReadings[ sensor ].ovInitData = 0.0F; + currentConductivityReadings[ sensor ].override = OVERRIDE_RESET; - currentTemperatureReadings[ i ].data = 0.0F; - currentTemperatureReadings[ i ].ovData = 0.0F; - currentTemperatureReadings[ i ].ovInitData = 0.0F; - currentTemperatureReadings[ i ].override = OVERRIDE_RESET; + currentTemperatureReadings[ sensor ].data = 0.0F; + currentTemperatureReadings[ sensor ].ovData = 0.0F; + currentTemperatureReadings[ sensor ].ovInitData = 0.0F; + currentTemperatureReadings[ sensor ].override = OVERRIDE_RESET; - lastConductivityReadCounter[ i ].data = 0; - lastConductivityReadCounter[ i ].ovData = 0; - lastConductivityReadCounter[ i ].ovInitData = 0; - lastConductivityReadCounter[ i ].override = OVERRIDE_RESET; + lastConductivityReadCounter[ sensor ].data = 0; + lastConductivityReadCounter[ sensor ].ovData = 0; + lastConductivityReadCounter[ sensor ].ovInitData = 0; + lastConductivityReadCounter[ sensor ].override = OVERRIDE_RESET; - lastConductivityErrorCounter[ i ].data = 0; - lastConductivityErrorCounter[ i ].ovData = 0; - lastConductivityErrorCounter[ i ].ovInitData = 0; - lastConductivityErrorCounter[ i ].override = OVERRIDE_RESET; + lastConductivityErrorCounter[ sensor ].data = 0; + lastConductivityErrorCounter[ sensor ].ovData = 0; + lastConductivityErrorCounter[ sensor ].ovInitData = 0; + lastConductivityErrorCounter[ sensor ].override = OVERRIDE_RESET; - conductivitySensorControl[i].initEnable = FALSE; - conductivitySensorControl[i].readAddress = 0; - conductivitySensorControl[i].readComplete = FALSE; - conductivitySensorControl[i].readData = 0; - conductivitySensorControl[i].readEnable = FALSE; - conductivitySensorControl[i].readInProgress = FALSE; - conductivitySensorControl[i].resetRequested = FALSE; - conductivitySensorControl[i].writeAddress = 0; - conductivitySensorControl[i].writeComplete = 0; - conductivitySensorControl[i].writeData = 0; - conductivitySensorControl[i].readExecState = CONDUCTIVITY_READ_INITIATE; - conductivitySensorControl[i].writeExecState = CONDUCTIVITY_WRITE_INITIATE; - conductivitySensorControl[i].writeEnable = FALSE; - conductivitySensorControl[i].writeInProgress = FALSE; + conductivitySensorControl[ sensor ].initEnable = FALSE; + conductivitySensorControl[ sensor ].readAddress = 0; + conductivitySensorControl[ sensor ].readComplete = FALSE; + conductivitySensorControl[ sensor ].readData = 0; + conductivitySensorControl[ sensor ].readEnable = FALSE; + conductivitySensorControl[ sensor ].readInProgress = FALSE; + conductivitySensorControl[ sensor ].resetRequested = FALSE; + conductivitySensorControl[ sensor ].writeAddress = 0; + conductivitySensorControl[ sensor ].writeComplete = 0; + conductivitySensorControl[ sensor ].writeData = 0; + conductivitySensorControl[ sensor ].readExecState = CONDUCTIVITY_READ_INITIATE; + conductivitySensorControl[ sensor ].writeExecState = CONDUCTIVITY_WRITE_INITIATE; + conductivitySensorControl[ sensor ].writeEnable = FALSE; + conductivitySensorControl[ sensor ].writeInProgress = FALSE; } // Initialize the conductivity sensor FPGA alarms @@ -144,6 +144,8 @@ initFPGAPersistentAlarm( FPGA_PERS_ERROR_D29_COND_SENSOR, ALARM_ID_DD_D29_COND_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); initFPGAPersistentAlarm( FPGA_PERS_ERROR_D43_COND_SENSOR, ALARM_ID_DD_D43_COND_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); initFPGAPersistentAlarm( FPGA_PERS_ERROR_D74_COND_SENSOR, ALARM_ID_DD_D74_COND_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); + //initFPGAPersistentAlarm( FPGA_PERS_ERROR_P9_COND_SENSOR, ALARM_ID_FP_P9_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); + //initFPGAPersistentAlarm( FPGA_PERS_ERROR_P18_COND_SENSOR, ALARM_ID_FP_P18_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); } /*********************************************************************//** @@ -167,26 +169,34 @@ currentConductivityReadings[ D29_COND ].data = (F32)getFPGAD29Cond(); currentConductivityReadings[ D43_COND ].data = (F32)getFPGAD43Cond(); currentConductivityReadings[ D74_COND ].data = (F32)getFPGAD74Cond(); + currentConductivityReadings[ P9_COND ].data = (F32)getFPGAP9Conductivity(); + currentConductivityReadings[ P18_COND ].data = (F32)getFPGAP18Conductivity(); // Read temperature associated to conductivity sensor currentTemperatureReadings[ D17_COND ].data = (F32)getFPGAD17CondTemp(); currentTemperatureReadings[ D27_COND ].data = (F32)getFPGAD27CondTemp(); currentTemperatureReadings[ D29_COND ].data = (F32)getFPGAD29CondTemp(); currentTemperatureReadings[ D43_COND ].data = (F32)getFPGAD43CondTemp(); currentTemperatureReadings[ D74_COND ].data = (F32)getFPGAD74CondTemp(); + currentTemperatureReadings[ P9_COND ].data = (F32)getFPGAP9Temperature(); + currentTemperatureReadings[ P18_COND ].data = (F32)getFPGAP18Temperature(); // Update read and error counters for each conductivity sensor lastConductivityReadCounter[ D17_COND ].data = (U32)getFPGAD17CondReadCount(); lastConductivityReadCounter[ D27_COND ].data = (U32)getFPGAD27CondReadCount(); lastConductivityReadCounter[ D29_COND ].data = (U32)getFPGAD29CondReadCount(); lastConductivityReadCounter[ D43_COND ].data = (U32)getFPGAD43CondReadCount(); lastConductivityReadCounter[ D74_COND ].data = (U32)getFPGAD74CondReadCount(); + lastConductivityReadCounter[ P9_COND ].data = (U32)getFPGAP9ReadCount(); + lastConductivityReadCounter[ P18_COND ].data = (U32)getFPGAP18ReadCount(); lastConductivityErrorCounter[ D17_COND ].data = (U32)getFPGAD17CondErrorCount(); lastConductivityErrorCounter[ D27_COND ].data = (U32)getFPGAD27CondErrorCount(); lastConductivityErrorCounter[ D29_COND ].data = (U32)getFPGAD29CondErrorCount(); lastConductivityErrorCounter[ D43_COND ].data = (U32)getFPGAD43CondErrorCount(); lastConductivityErrorCounter[ D74_COND ].data = (U32)getFPGAD74CondErrorCount(); + lastConductivityErrorCounter[ P9_COND ].data = (U32)getFPGAP9ErrorCount(); + lastConductivityErrorCounter[ P18_COND ].data = (U32)getFPGAP18ErrorCount(); #ifdef ENABLE_ALARM_1 // Monitor conductivity sensor health @@ -214,17 +224,21 @@ *************************************************************************/ static void checkConductivitySensors( void ) { - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D17_COND_SENSOR, getConductivitySensorReadCount(D17_COND) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D27_COND_SENSOR, getConductivitySensorReadCount(D27_COND) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D29_COND_SENSOR, getConductivitySensorReadCount(D29_COND) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D43_COND_SENSOR, getConductivitySensorReadCount(D43_COND) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D74_COND_SENSOR, getConductivitySensorReadCount(D74_COND) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D17_COND_SENSOR, getConductivitySensorReadCount( D17_COND ) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D27_COND_SENSOR, getConductivitySensorReadCount( D27_COND ) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D29_COND_SENSOR, getConductivitySensorReadCount( D29_COND ) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D43_COND_SENSOR, getConductivitySensorReadCount( D43_COND ) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D74_COND_SENSOR, getConductivitySensorReadCount( D74_COND ) ); + //checkFPGAPersistentAlarms( FPGA_PERS_ERROR_P9_COND_SENSOR, getConductivitySensorReadCount( P9_COND ) ); + //checkFPGAPersistentAlarms( FPGA_PERS_ERROR_P18_COND_SENSOR, getConductivitySensorReadCount( P18_COND ) ); checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_D17_COND_SENSOR, getConductivitySensorErrorCount( D17_COND ) ); checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_D27_COND_SENSOR, getConductivitySensorErrorCount( D27_COND ) ); checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_D29_COND_SENSOR, getConductivitySensorErrorCount( D29_COND ) ); checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_D43_COND_SENSOR, getConductivitySensorErrorCount( D43_COND ) ); checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_D74_COND_SENSOR, getConductivitySensorErrorCount( D74_COND ) ); + //checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_P9_COND_SENSOR, getConductivitySensorErrorCount( P9_COND ) ); + //checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_P18_COND_SENSOR, getConductivitySensorErrorCount( P18_COND ) ); } /*********************************************************************//** @@ -538,6 +552,30 @@ // clear D74 reset clearFPGAD74CondReset(); } + + if ( TRUE == conductivitySensorControl[ P9_COND ].resetRequested ) + { + // P9 reset + setFPGAP9Reset(); + conductivitySensorControl[ P9_COND ].resetRequested = FALSE; + } + else + { + // clear P9 reset + clearFPGAP9Reset(); + } + + if ( TRUE == conductivitySensorControl[ P18_COND ].resetRequested ) + { + // P18 reset + setFPGAP18Reset(); + conductivitySensorControl[ P18_COND ].resetRequested = FALSE; + } + else + { + // clear P18 reset + clearFPGAP18Reset(); + } } /*********************************************************************//** @@ -612,6 +650,30 @@ // clear D74 Init command clearFPGAD74CondInitEnable(); } + + if ( TRUE == conductivitySensorControl[ P9_COND ].initEnable ) + { + // P9 initialization + setFPGAP9InitEnable(); + conductivitySensorControl[ P9_COND ].initEnable = FALSE; + } + else + { + // clear P9 Init command + clearFPGAP9InitEnable(); + } + + if ( TRUE == conductivitySensorControl[ P18_COND ].initEnable ) + { + // P18 initialization + setFPGAP18InitEnable(); + conductivitySensorControl[ P18_COND ].initEnable = FALSE; + } + else + { + // clear P18 Init command + clearFPGAP18InitEnable(); + } } /*********************************************************************//** @@ -628,22 +690,22 @@ { CONDUCTIVITY_SENSORS_T sensor; - for ( sensor = FIRST_COND_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) + for ( sensor = FIRST_DD_COND_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) { // write state machine - switch ( conductivitySensorControl[sensor].writeExecState ) + switch ( conductivitySensorControl[ sensor ].writeExecState ) { case CONDUCTIVITY_WRITE_INITIATE: - conductivitySensorControl[sensor].writeExecState = handleConductivitySensorsWriteInitiate(); + conductivitySensorControl[ sensor ].writeExecState = handleConductivitySensorsWriteInitiate( sensor ); break; case CONDUCTIVITY_WRITE_COMPLETE: - conductivitySensorControl[sensor].writeExecState = handleConductivitySensorsWriteComplete(); + conductivitySensorControl[ sensor ].writeExecState = handleConductivitySensorsWriteComplete( sensor ); break; default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_WR_INVALID_EXEC_STATE, conductivitySensorControl[sensor].writeExecState ) - conductivitySensorControl[sensor].writeExecState = CONDUCTIVITY_WRITE_INITIATE; + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_WR_INVALID_EXEC_STATE, conductivitySensorControl[ sensor ].writeExecState ) + conductivitySensorControl[ sensor ].writeExecState = CONDUCTIVITY_WRITE_INITIATE; break; } } @@ -655,72 +717,65 @@ * transaction of given conducitviy sensors. * @details \b Inputs: conductivitySensorControl * @details \b Outputs: conductivitySensorControl + * @param sensorID ID of conductivity sensor to handle write initiate state for * @return CONDUCTIVITY_WRITE_STATE_T current state of write transaction *************************************************************************/ -static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteInitiate( void ) +static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteInitiate( CONDUCTIVITY_SENSORS_T sensorID ) { CONDUCTIVITY_WRITE_STATE_T state = CONDUCTIVITY_WRITE_INITIATE; - if ( TRUE == conductivitySensorControl[ D17_COND ].writeEnable && - FALSE == conductivitySensorControl[ D17_COND ].writeInProgress ) + if ( TRUE == conductivitySensorControl[ sensorID ].writeEnable && + FALSE == conductivitySensorControl[ sensorID ].writeInProgress ) { - // D17 write request - conductivitySensorControl[ D17_COND ].writeComplete = FALSE; - conductivitySensorControl[ D17_COND ].writeInProgress = TRUE; - setFPGACD12Address( conductivitySensorControl[ D17_COND ].writeAddress ); - setFPGACD12Data( conductivitySensorControl[ D17_COND ].writeData ); - setFPGAD17CondWriteEnable(); - state = CONDUCTIVITY_WRITE_COMPLETE; - } + conductivitySensorControl[ sensorID ].writeComplete = FALSE; + conductivitySensorControl[ sensorID ].writeInProgress = TRUE; - if ( TRUE == conductivitySensorControl[ D27_COND ].writeEnable && - FALSE == conductivitySensorControl[ D27_COND ].writeInProgress ) - { - // D27 write request - conductivitySensorControl[ D27_COND ].writeComplete = FALSE; - conductivitySensorControl[ D27_COND ].writeInProgress = TRUE; - setFPGACD12Address( conductivitySensorControl[ D27_COND ].writeAddress ); - setFPGACD12Data( conductivitySensorControl[ D27_COND ].writeData ); - setFPGAD27CondWriteEnable(); - state = CONDUCTIVITY_WRITE_COMPLETE; - } + if ( D17_COND == sensorID ) + { + setFPGAD17D74Address( conductivitySensorControl[ sensorID ].writeAddress ); + setFPGAD17D74Data( conductivitySensorControl[ sensorID ].writeData ); + setFPGAD17CondWriteEnable(); + } + else if ( D27_COND == sensorID ) + { + setFPGAD27D29Address( conductivitySensorControl[ sensorID ].writeAddress ); + setFPGAD27D29Data( conductivitySensorControl[ sensorID ].writeData ); + setFPGAD27CondWriteEnable(); + } + else if ( D29_COND == sensorID ) + { + setFPGAD27D29Address( conductivitySensorControl[ sensorID ].writeAddress ); + setFPGAD27D29Data( conductivitySensorControl[ sensorID ].writeData ); + setFPGAD29CondWriteEnable(); + } + else if ( D43_COND == sensorID ) + { + setFPGAD43Address( conductivitySensorControl[ sensorID ].writeAddress ); + setFPGAD43Data( conductivitySensorControl[ sensorID ].writeData ); + setFPGAD43CondWriteEnable(); + } + else if ( D74_COND == sensorID ) + { + setFPGAD17D74Address( conductivitySensorControl[ sensorID ].writeAddress ); + setFPGAD17D74Data( conductivitySensorControl[ sensorID ].writeData ); + setFPGAD74CondWriteEnable(); + } + else if ( P9_COND == sensorID ) + { + setFPGAP9Address( conductivitySensorControl[ sensorID ].writeAddress ); + setFPGAP9Data( conductivitySensorControl[ sensorID ].writeData ); + setFPGAP9WriteEnable(); + } + else if ( P18_COND == sensorID ) + { + setFPGAP18Address( conductivitySensorControl[ sensorID ].writeAddress ); + setFPGAP18Data( conductivitySensorControl[ sensorID ].writeData ); + setFPGAP18WriteEnable(); + } - if ( TRUE == conductivitySensorControl[ D29_COND ].writeEnable && - FALSE == conductivitySensorControl[ D29_COND ].writeInProgress ) - { - // D29 write request - conductivitySensorControl[ D29_COND ].writeComplete = FALSE; - conductivitySensorControl[ D29_COND ].writeInProgress = TRUE; - setFPGACD34Address( conductivitySensorControl[ D29_COND ].writeAddress ); - setFPGACD34Data( conductivitySensorControl[ D29_COND ].writeData ); - setFPGAD29CondWriteEnable(); state = CONDUCTIVITY_WRITE_COMPLETE; } - if ( TRUE == conductivitySensorControl[ D43_COND ].writeEnable && - FALSE == conductivitySensorControl[ D43_COND ].writeInProgress ) - { - // D43 write request - conductivitySensorControl[ D43_COND ].writeComplete = FALSE; - conductivitySensorControl[ D43_COND ].writeInProgress = TRUE; - setFPGACD34Address( conductivitySensorControl[ D43_COND ].writeAddress ); - setFPGACD34Data( conductivitySensorControl[ D43_COND ].writeData ); - setFPGAD43CondWriteEnable(); - state = CONDUCTIVITY_WRITE_COMPLETE; - } - - if ( TRUE == conductivitySensorControl[ D74_COND ].writeEnable && - FALSE == conductivitySensorControl[ D74_COND ].writeInProgress ) - { - // D74 write request - conductivitySensorControl[ D74_COND ].writeComplete = FALSE; - conductivitySensorControl[ D74_COND ].writeInProgress = TRUE; - setFPGACD5Address( conductivitySensorControl[ D74_COND ].writeAddress ); - setFPGACD5Data( conductivitySensorControl[ D74_COND ].writeData ); - setFPGAD74CondWriteEnable(); - state = CONDUCTIVITY_WRITE_COMPLETE; - } - return state; } @@ -730,51 +785,50 @@ * transaction completion of given conducitviy sensors. * @details \b Inputs: conductivitySensorControl * @details \b Outputs: conductivitySensorControl + * @param sensorID ID of conductivity sensor to handle write complete state for * @return CONDUCTIVITY_WRITE_STATE_T current state of write transaction *************************************************************************/ -static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteComplete( void ) +static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteComplete( CONDUCTIVITY_SENSORS_T sensorID ) { CONDUCTIVITY_WRITE_STATE_T state = CONDUCTIVITY_WRITE_COMPLETE; - if ( TRUE == conductivitySensorControl[ D17_COND ].writeInProgress ) + if ( TRUE == conductivitySensorControl[ sensorID ].writeInProgress ) { - conductivitySensorControl[ D17_COND ].writeComplete = TRUE; - conductivitySensorControl[ D17_COND ].writeEnable = FALSE; - clearFPGAD17CondWriteEnable(); - state = CONDUCTIVITY_WRITE_INITIATE; - } + conductivitySensorControl[ sensorID ].writeComplete = TRUE; + conductivitySensorControl[ sensorID ].writeEnable = FALSE; - if ( TRUE == conductivitySensorControl[ D27_COND ].writeInProgress ) - { - conductivitySensorControl[ D27_COND ].writeComplete = TRUE; - conductivitySensorControl[ D27_COND ].writeEnable = FALSE; - clearFPGAD27CondWriteEnable(); - state = CONDUCTIVITY_WRITE_INITIATE; - } + if ( D17_COND == sensorID ) + { + clearFPGAD17CondWriteEnable(); + } + else if ( D27_COND == sensorID ) + { + clearFPGAD27CondWriteEnable(); + } + else if ( D29_COND == sensorID ) + { + clearFPGAD29CondWriteEnable(); + } + else if ( D43_COND == sensorID ) + { + clearFPGAD43CondWriteEnable(); + } + else if ( D74_COND == sensorID ) + { + clearFPGAD74CondWriteEnable(); + } + else if ( P9_COND == sensorID ) + { + clearFPGAP9WriteEnable(); + } + else if ( P18_COND == sensorID ) + { + clearFPGAP18WriteEnable(); + } - if ( TRUE == conductivitySensorControl[ D29_COND ].writeInProgress ) - { - conductivitySensorControl[ D29_COND ].writeComplete = TRUE; - conductivitySensorControl[ D29_COND ].writeEnable = FALSE; - clearFPGAD29CondWriteEnable(); state = CONDUCTIVITY_WRITE_INITIATE; } - if ( TRUE == conductivitySensorControl[ D43_COND ].writeInProgress ) - { - conductivitySensorControl[ D43_COND ].writeComplete = TRUE; - conductivitySensorControl[ D43_COND ].writeEnable = FALSE; - clearFPGAD43CondWriteEnable(); - state = CONDUCTIVITY_WRITE_INITIATE; - } - - if ( TRUE == conductivitySensorControl[ D74_COND ].writeInProgress ) - { - conductivitySensorControl[ D74_COND ].writeComplete = TRUE; - conductivitySensorControl[ D74_COND ].writeEnable = FALSE; - clearFPGAD74CondWriteEnable(); - state = CONDUCTIVITY_WRITE_INITIATE; - } return state; } @@ -792,22 +846,22 @@ { CONDUCTIVITY_SENSORS_T sensor; - for ( sensor = FIRST_COND_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) + for ( sensor = FIRST_DD_COND_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) { // Read state machine - switch ( conductivitySensorControl[sensor].readExecState ) + switch ( conductivitySensorControl[ sensor ].readExecState ) { case CONDUCTIVITY_READ_INITIATE: - conductivitySensorControl[sensor].readExecState = handleConductivitySensorsReadInitiate(); + conductivitySensorControl[ sensor ].readExecState = handleConductivitySensorsReadInitiate( sensor ); break; case CONDUCTIVITY_READ_COMPLETE: - conductivitySensorControl[sensor].readExecState = handleConductivitySensorsReadComplete(); + conductivitySensorControl[ sensor ].readExecState = handleConductivitySensorsReadComplete( sensor ); break; default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_RD_INVALID_EXEC_STATE, conductivitySensorControl[sensor].readExecState ) - conductivitySensorControl[sensor].readExecState = CONDUCTIVITY_READ_INITIATE; + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_RD_INVALID_EXEC_STATE, conductivitySensorControl[ sensor ].readExecState ) + conductivitySensorControl[ sensor ].readExecState = CONDUCTIVITY_READ_INITIATE; break; } } @@ -819,67 +873,59 @@ * transaction of given conducitviy sensors. * @details \b Inputs: conductivitySensorControl * @details \b Outputs: conductivitySensorControl + * @param sensorID ID of conductivity sensor to handle read initiate state for * @return CONDUCTIVITY_READ_STATE_T current state of read transaction *************************************************************************/ -static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadInitiate( void ) +static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadInitiate( CONDUCTIVITY_SENSORS_T sensorID ) { CONDUCTIVITY_READ_STATE_T state = CONDUCTIVITY_READ_INITIATE; - if ( TRUE == conductivitySensorControl[ D17_COND ].readEnable && - FALSE == conductivitySensorControl[ D17_COND ].readInProgress ) + if ( TRUE == conductivitySensorControl[ sensorID ].readEnable && + FALSE == conductivitySensorControl[ sensorID ].readInProgress ) { // D17 read request - conductivitySensorControl[ D17_COND ].readComplete = FALSE; - conductivitySensorControl[ D17_COND ].readInProgress = TRUE; - setFPGACD12Address( conductivitySensorControl[ D17_COND ].readAddress ); - setFPGAD17CondReadEnable(); - state = CONDUCTIVITY_READ_COMPLETE; - } + conductivitySensorControl[ sensorID ].readComplete = FALSE; + conductivitySensorControl[ sensorID ].readInProgress = TRUE; - if ( TRUE == conductivitySensorControl[ D27_COND ].readEnable && - FALSE == conductivitySensorControl[ D27_COND ].readInProgress ) - { - // D27 read request - conductivitySensorControl[ D27_COND ].readComplete = FALSE; - conductivitySensorControl[ D27_COND ].readInProgress = TRUE; - setFPGACD12Address( conductivitySensorControl[ D27_COND ].readAddress ); - setFPGAD27CondReadEnable(); - state = CONDUCTIVITY_READ_COMPLETE; - } + if ( D17_COND == sensorID ) + { + setFPGAD17D74Address( conductivitySensorControl[ sensorID ].readAddress ); + setFPGAD17CondReadEnable(); + } + else if ( D27_COND == sensorID ) + { + setFPGAD27D29Address( conductivitySensorControl[ sensorID ].readAddress ); + setFPGAD27CondReadEnable(); + } + else if ( D29_COND == sensorID ) + { + setFPGAD27D29Address( conductivitySensorControl[ sensorID ].readAddress ); + setFPGAD29CondReadEnable(); + } + else if ( D43_COND == sensorID ) + { + setFPGAD43Address( conductivitySensorControl[ sensorID ].readAddress ); + setFPGAD43CondReadEnable(); + } + else if ( D74_COND == sensorID ) + { + setFPGAD17D74Address( conductivitySensorControl[ sensorID ].readAddress ); + setFPGAD74CondReadEnable(); + } + else if ( P9_COND == sensorID ) + { + setFPGAP9Address( conductivitySensorControl[ sensorID ].readAddress ); + setFPGAP9ReadEnable(); + } + else if ( P18_COND == sensorID ) + { + setFPGAP18Address( conductivitySensorControl[ sensorID ].readAddress ); + setFPGAP18ReadEnable(); + } - if ( TRUE == conductivitySensorControl[ D29_COND ].readEnable && - FALSE == conductivitySensorControl[ D29_COND ].readInProgress ) - { - // D29 read request - conductivitySensorControl[ D29_COND ].readComplete = FALSE; - conductivitySensorControl[ D29_COND ].readInProgress = TRUE; - setFPGACD34Address( conductivitySensorControl[ D29_COND ].readAddress ); - setFPGAD29CondReadEnable(); state = CONDUCTIVITY_READ_COMPLETE; } - if ( TRUE == conductivitySensorControl[ D43_COND ].readEnable && - FALSE == conductivitySensorControl[ D43_COND ].readInProgress ) - { - // D43 read request - conductivitySensorControl[ D43_COND ].readComplete = FALSE; - conductivitySensorControl[ D43_COND ].readInProgress = TRUE; - setFPGACD34Address( conductivitySensorControl[ D43_COND ].readAddress ); - setFPGAD43CondReadEnable(); - state = CONDUCTIVITY_READ_COMPLETE; - } - - if ( TRUE == conductivitySensorControl[ D74_COND ].readEnable && - FALSE == conductivitySensorControl[ D74_COND ].readInProgress ) - { - // D74 read request - conductivitySensorControl[ D74_COND ].readComplete = FALSE; - conductivitySensorControl[ D74_COND ].readInProgress = TRUE; - setFPGACD5Address( conductivitySensorControl[ D74_COND ].readAddress ); - setFPGAD74CondReadEnable(); - state = CONDUCTIVITY_READ_COMPLETE; - } - return state; } @@ -889,66 +935,162 @@ * request completion of given conducitviy sensors. * @details \b Inputs: conductivitySensorControl * @details \b Outputs: conductivitySensorControl + * @param sensorID ID of conductivity sensor to handle read complete state for * @return CONDUCTIVITY_READ_STATE_T current state of write transaction *************************************************************************/ -static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadComplete( void ) +static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadComplete( CONDUCTIVITY_SENSORS_T sensorID ) { CONDUCTIVITY_READ_STATE_T state = CONDUCTIVITY_READ_COMPLETE; - if ( TRUE == conductivitySensorControl[ D17_COND ].readInProgress ) + if ( TRUE == conductivitySensorControl[ sensorID ].readInProgress ) { - conductivitySensorControl[ D17_COND ].readData = getFPGAD17CondData(); - conductivitySensorControl[ D17_COND ].readComplete = TRUE; - conductivitySensorControl[ D17_COND ].readEnable = FALSE; - clearFPGAD17CondReadEnable(); - state = CONDUCTIVITY_READ_INITIATE; - } + conductivitySensorControl[ sensorID ].readComplete = TRUE; + conductivitySensorControl[ sensorID ].readEnable = FALSE; - if ( TRUE == conductivitySensorControl[ D27_COND ].readInProgress ) - { - conductivitySensorControl[ D27_COND ].readData = getFPGAD27CondData(); - conductivitySensorControl[ D27_COND ].readComplete = TRUE; - conductivitySensorControl[ D27_COND ].readEnable = FALSE; - clearFPGAD27CondReadEnable(); + if ( D17_COND == sensorID ) + { + conductivitySensorControl[ sensorID ].readData = getFPGAD17CondData(); + clearFPGAD17CondReadEnable(); + } + else if ( D27_COND == sensorID ) + { + conductivitySensorControl[ sensorID ].readData = getFPGAD27CondData(); + clearFPGAD27CondReadEnable(); + } + else if ( D29_COND == sensorID ) + { + conductivitySensorControl[ sensorID ].readData = getFPGAD29CondData(); + clearFPGAD29CondReadEnable(); + } + else if ( D43_COND == sensorID ) + { + conductivitySensorControl[ sensorID ].readData = getFPGAD43CondData(); + clearFPGAD43CondReadEnable(); + } + else if ( D74_COND == sensorID ) + { + conductivitySensorControl[ sensorID ].readData = getFPGAD74CondData(); + clearFPGAD74CondReadEnable(); + } + else if ( P9_COND == sensorID ) + { + conductivitySensorControl[ sensorID ].readData = getFPGAP9Data(); + clearFPGAP9ReadEnable(); + } + else if ( P18_COND == sensorID ) + { + conductivitySensorControl[ sensorID ].readData = getFPGAP18Data(); + clearFPGAP18ReadEnable(); + } + state = CONDUCTIVITY_READ_INITIATE; } - if ( TRUE == conductivitySensorControl[ D29_COND ].readInProgress ) + return state; +} + + +/************************************************************************* + * TEST SUPPORT FUNCTIONS + *************************************************************************/ + + +/*********************************************************************//** + * @brief + * The testDDConductivitySensorReadingsOverride function overrides the value of the + * specified DD conductivity sensor with a given value. + * @details \b Inputs: none + * @details \b Outputs: currentConductivityReadings[] + * @param message Override message from Dialin which includes an sensor + * ID and override value of the conductivity sensor. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testDDConductivitySensorReadingsOverride( MESSAGE_T *message ) +{ + BOOL result = FALSE; + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &payload ); + + if ( payload.index <= LAST_DD_COND_SENSOR ) { - conductivitySensorControl[ D29_COND ].readData = getFPGAD29CondData(); - conductivitySensorControl[ D29_COND ].readComplete = TRUE; - conductivitySensorControl[ D29_COND ].readEnable = FALSE; - clearFPGAD29CondReadEnable(); - state = CONDUCTIVITY_READ_INITIATE; + result = f32ArrayOverride( message, ¤tConductivityReadings[0], NUM_OF_CONDUCTIVITY_SENSORS - 1 ); } - if ( TRUE == conductivitySensorControl[ D43_COND ].readInProgress ) + return result; +} + +/*********************************************************************//** + * @brief + * The testDDConductivitySensorTemperatureReadingsOverride function overrides + * the value of the specified DD conductivity sensor temperature with a given value. + * @details \b Inputs: none + * @details \b Outputs: currentPresTempReadings[] + * @param message Override message from Dialin which includes an sensor + * ID and override value of the conductivity sensor temperature. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testDDConductivitySensorTemperatureReadingsOverride( MESSAGE_T *message ) +{ + BOOL result = FALSE; + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &payload ); + + if ( payload.index <= LAST_DD_COND_SENSOR ) { - conductivitySensorControl[ D43_COND ].readData = getFPGAD43CondData(); - conductivitySensorControl[ D43_COND ].readComplete = TRUE; - conductivitySensorControl[ D43_COND ].readEnable = FALSE; - clearFPGAD43CondReadEnable(); - state = CONDUCTIVITY_READ_INITIATE; + result = f32ArrayOverride( message, ¤tTemperatureReadings[0], NUM_OF_CONDUCTIVITY_SENSORS - 1 ); } - if ( TRUE == conductivitySensorControl[ D74_COND ].readInProgress ) + return result; +} + +/*********************************************************************//** + * @brief + * The testDDConductivitySensorReadCounterOverride function overrides + * the value of the specified DD conductivity sensor read counter with a given value. + * @details \b Inputs: none + * @details \b Outputs: lastConductivityReadCounter[] + * @param message Override message from Dialin which includes an sensor + * ID and override value of the conductivity sensor read counter. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testDDConductivitySensorReadCounterOverride( MESSAGE_T *message ) +{ + BOOL result = FALSE; + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &payload ); + + if ( payload.index <= LAST_DD_COND_SENSOR ) { - conductivitySensorControl[ D74_COND ].readData = getFPGAD74CondData(); - conductivitySensorControl[ D74_COND ].readComplete = TRUE; - conductivitySensorControl[ D74_COND ].readEnable = FALSE; - clearFPGAD74CondReadEnable(); - state = CONDUCTIVITY_READ_INITIATE; + result = u32ArrayOverride( message, &lastConductivityReadCounter[0], NUM_OF_CONDUCTIVITY_SENSORS - 1, 0, COND_SENSORS_READ_ERR_MAX_CNT ); } - return state; + return result; } - -/************************************************************************* - * TEST SUPPORT FUNCTIONS +/*********************************************************************//** + * @brief + * The testDDConductivitySensorErrorCounterOverride function overrides + * the value of the specified DD conductivity sensor error counter with a given value. + * @details \b Inputs: none + * @details \b Outputs: lastConductivityErrorCounter[] + * @param message Override message from Dialin which includes an sensor + * ID and override value of the conductivity sensor error counter. + * @return TRUE if override successful, FALSE if not *************************************************************************/ +BOOL testDDConductivitySensorErrorCounterOverride( MESSAGE_T *message ) +{ + BOOL result = FALSE; + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &payload ); + if ( payload.index <= LAST_DD_COND_SENSOR ) + { + result = u32ArrayOverride( message, &lastConductivityErrorCounter[0], NUM_OF_CONDUCTIVITY_SENSORS - 1, 0, COND_SENSORS_READ_ERR_MAX_CNT ); + } + return result; +} + /*********************************************************************//** * @brief * The testConductivitySensorReadingsOverride function overrides the value of the @@ -959,10 +1101,17 @@ * ID and override value of the conductivity sensor. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testConductivitySensorReadingsOverride( MESSAGE_T *message ) +BOOL testFPConductivitySensorReadingsOverride( MESSAGE_T *message ) { - BOOL result = f32ArrayOverride( message, ¤tConductivityReadings[0], NUM_OF_CONDUCTIVITY_SENSORS - 1 ); + BOOL result = FALSE; + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &payload ); + if ( ( payload.index >= FIRST_FP_COND_SENSOR ) && ( payload.index <= LAST_FP_COND_SENSOR ) ) + { + result = f32ArrayOverride( message, ¤tConductivityReadings[0], NUM_OF_CONDUCTIVITY_SENSORS - 1 ); + } + return result; } @@ -976,10 +1125,17 @@ * ID and override value of the conductivity sensor temperature. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testConductivitySensorTemperatureReadingsOverride( MESSAGE_T *message ) +BOOL testFPConductivitySensorTemperatureReadingsOverride( MESSAGE_T *message ) { - BOOL result = f32ArrayOverride( message, ¤tTemperatureReadings[0], NUM_OF_CONDUCTIVITY_SENSORS - 1 ); + BOOL result = FALSE; + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &payload ); + if ( ( payload.index >= FIRST_FP_COND_SENSOR ) && ( payload.index <= LAST_FP_COND_SENSOR ) ) + { + result = f32ArrayOverride( message, ¤tTemperatureReadings[0], NUM_OF_CONDUCTIVITY_SENSORS - 1 ); + } + return result; } @@ -993,10 +1149,17 @@ * ID and override value of the conductivity sensor read counter. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testConductivitySensorReadCounterOverride( MESSAGE_T *message ) +BOOL testFPConductivitySensorReadCounterOverride( MESSAGE_T *message ) { - BOOL result = u32ArrayOverride( message, &lastConductivityReadCounter[0], NUM_OF_CONDUCTIVITY_SENSORS - 1, 0, COND_SENSORS_READ_ERR_MAX_CNT ); + BOOL result = FALSE; + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &payload ); + if ( ( payload.index >= FIRST_FP_COND_SENSOR ) && ( payload.index <= LAST_FP_COND_SENSOR ) ) + { + result = u32ArrayOverride( message, &lastConductivityReadCounter[0], NUM_OF_CONDUCTIVITY_SENSORS - 1, 0, COND_SENSORS_READ_ERR_MAX_CNT ); + } + return result; } @@ -1010,10 +1173,17 @@ * ID and override value of the conductivity sensor error counter. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testConductivitySensorErrorCounterOverride( MESSAGE_T *message ) +BOOL testFPConductivitySensorErrorCounterOverride( MESSAGE_T *message ) { - BOOL result = u32ArrayOverride( message, &lastConductivityErrorCounter[0], NUM_OF_CONDUCTIVITY_SENSORS - 1, 0, COND_SENSORS_READ_ERR_MAX_CNT ); + BOOL result = FALSE; + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &payload ); + if ( ( payload.index >= FIRST_FP_COND_SENSOR ) && ( payload.index <= LAST_FP_COND_SENSOR ) ) + { + result = u32ArrayOverride( message, &lastConductivityErrorCounter[0], NUM_OF_CONDUCTIVITY_SENSORS - 1, 0, COND_SENSORS_READ_ERR_MAX_CNT ); + } + return result; }