Index: firmware/App/Drivers/ConductivitySensors.c =================================================================== diff -u -r2205857f59dd884c4af450239381387cfb560c2e -rf47296145b6a0adb78df0e325587629171909fd6 --- firmware/App/Drivers/ConductivitySensors.c (.../ConductivitySensors.c) (revision 2205857f59dd884c4af450239381387cfb560c2e) +++ firmware/App/Drivers/ConductivitySensors.c (.../ConductivitySensors.c) (revision f47296145b6a0adb78df0e325587629171909fd6) @@ -84,10 +84,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_READ_STATE_T handleConductivitySensorsReadComplete( CONDUCTIVITY_SENSORS_T sensorID ); +static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteInitiate( CONDUCTIVITY_SENSORS_T sensorID ); +static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteComplete( CONDUCTIVITY_SENSORS_T sensorID ); /*********************************************************************//** * @brief @@ -98,45 +98,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 = CONDUCTIVITYSENSORS_FIRST; 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 @@ -155,36 +155,28 @@ * @note This function should be called periodically to maintain fresh * sensor readings for all conductivity sensors. * @details \b Inputs: FPGA - * @details \b Outputs: currentConductivityReadings[],currentTemperatureReadings[], - * lastConductivityReadCounter[],lastConductivityErrorCounter[]. + * @details \b Outputs: currentConductivityReadings[], currentTemperatureReadings[], + * lastConductivityReadCounter[], lastConductivityErrorCounter[]. * @return none *************************************************************************/ void readConductivitySensors( void ) { -// // Read raw conductivity -// currentConductivityReadings[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (F32)getFPGACD1(); -// currentConductivityReadings[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (F32)getFPGACD2(); -// currentConductivityReadings[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (F32)getFPGACD3(); -// currentConductivityReadings[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (F32)getFPGACD4(); -// -// // Read temperature associated to conductivity sensor -// currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (F32)getFPGACD1Temp(); -// currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (F32)getFPGACD2Temp(); -// currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (F32)getFPGACD3Temp(); -// currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (F32)getFPGACD4Temp(); -// -// // Update read and error counters for each conductivity sensor -// lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (U32)getFPGACD1ReadCount(); -// lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (U32)getFPGACD2ReadCount(); -// lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (U32)getFPGACD3ReadCount(); -// lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (U32)getFPGACD4ReadCount(); -// -// lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (U32)getFPGACD1ErrorCount(); -// lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (U32)getFPGACD2ErrorCount(); -// lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (U32)getFPGACD3ErrorCount(); -// lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (U32)getFPGACD4ErrorCount(); -// -// // Monitor conductivity sensor health + // Read raw conductivity + currentConductivityReadings[ CONDUCTIVITYSENSORS_CPI_SENSOR ].data = (F32)getFPGACPiConductivity(); + currentConductivityReadings[ CONDUCTIVITYSENSORS_CPO_SENSOR ].data = (F32)getFPGACPoConductivity(); + + // Read temperature associated to conductivity sensor + currentTemperatureReadings[ CONDUCTIVITYSENSORS_CPI_SENSOR ].data = (F32)getFPGACPiTemperature(); + currentTemperatureReadings[ CONDUCTIVITYSENSORS_CPO_SENSOR ].data = (F32)getFPGACPoTemperature(); + + // Update read and error counters for each conductivity sensor + lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CPI_SENSOR ].data = (U32)getFPGACPiReadCount(); + lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CPO_SENSOR ].data = (U32)getFPGACPoReadCount(); + + lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CPI_SENSOR ].data = (U32)getFPGACPiErrorCount(); + lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CPO_SENSOR ].data = (U32)getFPGACPoErrorCount(); + + // Monitor conductivity sensor health // checkConductivitySensors(); } @@ -219,461 +211,386 @@ /*********************************************************************//** * @brief - * The getConductivityValue function gets the conductivity - * value for a given conductivity sensor id. + * The getConductivityValue function gets the conductivity value for a given + * conductivity sensor. * @details \b Inputs: currentConductivityReadings[] * @details \b Outputs: none - * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT if given sensor is invalid. * @param sensorId conductivity sensor id * @return conductivity value *************************************************************************/ -//F32 getConductivityValue( CONDUCTIVITY_SENSORS_T sensor ) -//{ -// F32 result = 0.0F; -// -// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) -// { -// result = currentConductivityReadings[ sensor ].data; -// if ( OVERRIDE_KEY == currentConductivityReadings[ sensor ].override ) -// { -// result = currentConductivityReadings[ sensor ].ovData; -// } -// } -// else -// { -// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID, sensor ); -// } -// -// return result; -//} +F32 getConductivityValue( CONDUCTIVITY_SENSORS_T sensor ) +{ + F32 result = 0.0F; + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + result = currentConductivityReadings[ sensor ].data; + if ( OVERRIDE_KEY == currentConductivityReadings[ sensor ].override ) + { + result = currentConductivityReadings[ sensor ].ovData; + } + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID, (U32)sensor ); + } + + return result; +} + /*********************************************************************//** * @brief * The getConductivityTemperatureValue function gets the temperature * value for a given conductivity sensor id. * @details \b Inputs: currentTemperatureReadings[] * @details \b Outputs: none - * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT if given sensor is invalid. * @param sensorId conductivity sensor id * @return temperature value *************************************************************************/ -//F32 getConductivityTemperatureValue( CONDUCTIVITY_SENSORS_T sensor ) -//{ -// F32 result = 0.0F; -// -// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) -// { -// result = currentTemperatureReadings[ sensor ].data; -// if ( OVERRIDE_KEY == currentTemperatureReadings[ sensor ].override ) -// { -// result = currentTemperatureReadings[ sensor ].ovData; -// } -// } -// else -// { -// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID1, sensor ); -// } -// -// return result; -//} +F32 getConductivityTemperatureValue( CONDUCTIVITY_SENSORS_T sensor ) +{ + F32 result = 0.0F; + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + result = currentTemperatureReadings[ sensor ].data; + if ( OVERRIDE_KEY == currentTemperatureReadings[ sensor ].override ) + { + result = currentTemperatureReadings[ sensor ].ovData; + } + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID1, (U32)sensor ); + } + + return result; +} + /*********************************************************************//** * @brief * The getConductivitySensorReadCount function gets the current conductivity sensor * read count for a given conductivity sensor. - * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT if given sensor is invalid. * @details \b Inputs: lastConductivityReadCounter * @details \b Outputs: none * @param sensor ID of conductivity sensor to get read count for. * @return The current conductivity sensor read count of a given conductivity sensor. *************************************************************************/ -//U32 getConductivitySensorReadCount( CONDUCTIVITY_SENSORS_T sensor ) -//{ -// U32 result = 0; -// -// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) -// { -// result = lastConductivityReadCounter[ sensor ].data; -// if ( OVERRIDE_KEY == lastConductivityReadCounter[ sensor ].override ) -// { -// result = lastConductivityReadCounter[ sensor ].ovData; -// } -// } -// else -// { -// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID2, sensor ) -// } -// -// return result; -//} +U32 getConductivitySensorReadCount( CONDUCTIVITY_SENSORS_T sensor ) +{ + U32 result = 0; + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + result = lastConductivityReadCounter[ sensor ].data; + if ( OVERRIDE_KEY == lastConductivityReadCounter[ sensor ].override ) + { + result = lastConductivityReadCounter[ sensor ].ovData; + } + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID2, (U32)sensor ) + } + + return result; +} + /*********************************************************************//** * @brief * The getConductivitySensorErrorCount function gets the current conductivity sensor * error count for a given conductivity sensor. - * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT if given sensor is invalid. * @details \b Inputs: lastConductivityErrorCounter * @details \b Outputs: none * @param sensor ID of conductivity sensor to get error count for. * @return The current conductivity sensor error count of a given conductivity sensor. *************************************************************************/ -//U32 getConductivitySensorErrorCount( CONDUCTIVITY_SENSORS_T sensor ) -//{ -// U32 result = 0; -// -// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) -// { -// result = lastConductivityErrorCounter[ sensor ].data; -// if ( OVERRIDE_KEY == lastConductivityErrorCounter[ sensor ].override ) -// { -// result = lastConductivityErrorCounter[ sensor ].ovData; -// } -// } -// else -// { -// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID3, sensor ) -// } -// -// return result; -//} +U32 getConductivitySensorErrorCount( CONDUCTIVITY_SENSORS_T sensor ) +{ + U32 result = 0; + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + result = lastConductivityErrorCounter[ sensor ].data; + if ( OVERRIDE_KEY == lastConductivityErrorCounter[ sensor ].override ) + { + result = lastConductivityErrorCounter[ sensor ].ovData; + } + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID3, (U32)sensor ) + } + + return result; +} + /*********************************************************************//** * @brief * The requestConductivitySensorReset function commands the given * the conductivity sensor to go for reset. * @details \b Inputs: none - * @details \b Outputs: conductivitySensorControl - * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. - * @param sensor conductivity sensor id + * @details \b Outputs: conductivitySensorControl[] + * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT if given sensor is invalid. + * @param sensor ID of conductivity sensor to request reset for * @return none *************************************************************************/ -//void requestConductivitySensorReset( CONDUCTIVITY_SENSORS_T sensor ) -//{ -// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) -// { -// conductivitySensorControl[ sensor ].resetRequested = TRUE; -// } -// else -// { -// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID4, sensor ); -// } -//} +void requestConductivitySensorReset( CONDUCTIVITY_SENSORS_T sensor ) +{ + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + conductivitySensorControl[ sensor ].resetRequested = TRUE; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID4, (U32)sensor ); + } +} /*********************************************************************//** * @brief * The setConductivitySensorInitEnable function enables the given * the conductivity sensor (re)initialization procedure. * @details \b Inputs: none * @details \b Outputs: conductivitySensorControl - * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. - * @param sensor conductivity sensor id + * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT if given sensor is invalid. + * @param sensor ID of conductivity sensor to enable initialization for * @return none *************************************************************************/ -//void setConductivitySensorInitEnable( CONDUCTIVITY_SENSORS_T sensor ) -//{ -// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) -// { -// conductivitySensorControl[ sensor ].initEnable = TRUE; -// } -// else -// { -// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID5, sensor ); -// } -//} +void setConductivitySensorInitEnable( CONDUCTIVITY_SENSORS_T sensor ) +{ + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + conductivitySensorControl[ sensor ].initEnable = TRUE; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID5, sensor ); + } +} /*********************************************************************//** * @brief * The conductivitySensorWriteRequest function requests the write transaction * for the given conductivity sensor. * @details \b Inputs: none * @details \b Outputs: conductivitySensorControl - * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. - * @param sensor conductivity sensor id - * @param writeAddr address to write for the given conductivity sensor. + * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT if given sensor is invalid. + * @param sensor ID of conductivity sensor to request write for + * @param writeAddr Address to write for the given conductivity sensor. * @param data data to write in write address of given conductivity sensor. * @return none *************************************************************************/ -//void conductivitySensorWriteRequest( CONDUCTIVITY_SENSORS_T sensor, U16 writeAddr, U32 data ) -//{ -// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) -// { -// conductivitySensorControl[ sensor ].writeAddress = writeAddr; -// conductivitySensorControl[ sensor ].writeData = data; -// conductivitySensorControl[ sensor ].writeEnable = TRUE; -// } -// else -// { -// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID6, sensor ); -// } -//} +void conductivitySensorWriteRequest( CONDUCTIVITY_SENSORS_T sensor, U16 writeAddr, U32 data ) +{ + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + conductivitySensorControl[ sensor ].writeAddress = writeAddr; + conductivitySensorControl[ sensor ].writeData = data; + conductivitySensorControl[ sensor ].writeEnable = TRUE; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID6, (U32)sensor ); + } +} /*********************************************************************//** * @brief * The conductivitySensorReadRequest function requests the read transaction * for the given conductivity sensor. * @details \b Inputs: none - * @details \b Outputs: conductivitySensorControl - * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. - * @param sensor conductivity sensor id - * @param readAddr for sensor read transaction. + * @details \b Outputs: conductivitySensorControl[] + * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT if given sensor is invalid. + * @param sensor ID of conductivity sensor to request read for + * @param readAddr Address to read from the given sensor. * @return none *************************************************************************/ -//void conductivitySensorReadRequest( CONDUCTIVITY_SENSORS_T sensor, U16 readAddr ) -//{ -// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) -// { -// conductivitySensorControl[ sensor ].readAddress = readAddr; -// conductivitySensorControl[ sensor ].readEnable = TRUE; -// } -// else -// { -// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID7, sensor ); -// } -//} +void conductivitySensorReadRequest( CONDUCTIVITY_SENSORS_T sensor, U16 readAddr ) +{ + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + conductivitySensorControl[ sensor ].readAddress = readAddr; + conductivitySensorControl[ sensor ].readEnable = TRUE; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID7, (U32)sensor ); + } +} /*********************************************************************//** * @brief - * The conductivitySensorReadData function returns the read data - * for the given conductivity sensor. - * @details \b Inputs: conductivitySensorControl + * The conductivitySensorReadData function returns the read data for the + * given conductivity sensor. + * @details \b Inputs: conductivitySensorControl[] * @details \b Outputs: none - * @param sensor conductivity sensor id - * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. - * @return read data for the last request + * @param sensor ID conductivity sensor to read data from + * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT if given sensor is invalid. + * @return read data for the last read request *************************************************************************/ -//U32 conductivitySensorReadData( CONDUCTIVITY_SENSORS_T sensor ) -//{ -// U32 data; -// -// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) -// { -// data = conductivitySensorControl[ sensor ].readData; -// } -// else -// { -// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID8, sensor ); -// } -// -// return data; -//} +U32 conductivitySensorReadData( CONDUCTIVITY_SENSORS_T sensor ) +{ + U32 data; + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + data = conductivitySensorControl[ sensor ].readData; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID8, (U32)sensor ); + } + + return data; +} + /*********************************************************************//** * @brief * The handleConductivitySensorsReset function checks the reset requested - * for all conductivity sensors and perform the sensor reset. + * for all conductivity sensors and performs the sensor reset if requested. * @note This function should be called periodically to handle any * reset request for all conductivity sensors. - * @details \b Inputs: conductivitySensorControl - * @details \b Outputs: conductivitySensorControl + * @details \b Inputs: conductivitySensorControl[] + * @details \b Outputs: conductivitySensorControl[] * @return none *************************************************************************/ void handleConductivitySensorsReset( void ) { -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].resetRequested ) -// { -// // CD1 reset -// setFPGACD1Reset(); -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].resetRequested = FALSE; -// } -// else -// { -// // clear CD1 reset -// clearFPGACD1Reset(); -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].resetRequested ) -// { -// // CD2 reset -// setFPGACD2Reset(); -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].resetRequested = FALSE; -// } -// else -// { -// // clear CD2 reset -// clearFPGACD2Reset(); -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].resetRequested ) -// { -// // CD3 reset -// setFPGACD3Reset(); -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].resetRequested = FALSE; -// } -// else -// { -// // clear CD3 reset -// clearFPGACD3Reset(); -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].resetRequested ) -// { -// // CD4 reset -// setFPGACD4Reset(); -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].resetRequested = FALSE; -// } -// else -// { -// // clear CD4 reset -// clearFPGACD4Reset(); -// } + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CPI_SENSOR ].resetRequested ) + { + // CPi reset + setFPGACPiReset(); + conductivitySensorControl[ CONDUCTIVITYSENSORS_CPI_SENSOR ].resetRequested = FALSE; + } + else + { + // clear CPi reset + clearFPGACPiReset(); + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CPO_SENSOR ].resetRequested ) + { + // CPo reset + setFPGACPoReset(); + conductivitySensorControl[ CONDUCTIVITYSENSORS_CPO_SENSOR ].resetRequested = FALSE; + } + else + { + // clear CPo reset + clearFPGACPoReset(); + } } /*********************************************************************//** * @brief * The handleConductivitySensorsInitProcedure function checks the (re)initialization - * of conducitviy sensors request and may perform the sensor sequencing to - * complete the initialization. - * @note This function should be called periodically to handle any - * Init request for all conductivity sensors. - * @details \b Inputs: conductivitySensorControl - * @details \b Outputs: conductivitySensorControl + * requested for all conductivity sensors request and performs the sensor initialization + * sequencing if requested. + * @note This function should be called periodically to handle any initialization + * request for all conductivity sensors. + * @details \b Inputs: conductivitySensorControl[] + * @details \b Outputs: conductivitySensorControl[] * @return none *************************************************************************/ -//void handleConductivitySensorsInitProcedure( void ) -//{ -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].initEnable ) -// { -// // CD1 initialization -// setFPGACD1InitEnable(); -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].initEnable = FALSE; -// } -// else -// { -// // clear CD1 Init command -// clearFPGACD1InitEnable(); -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].initEnable ) -// { -// // CD2 initialization -// setFPGACD2InitEnable(); -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].initEnable = FALSE; -// } -// else -// { -// // clear CD2 Init command -// clearFPGACD2InitEnable(); -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].initEnable ) -// { -// // CD3 initialization -// setFPGACD3InitEnable(); -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].initEnable = FALSE; -// } -// else -// { -// // clear CD3 Init command -// clearFPGACD3InitEnable(); -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].initEnable ) -// { -// // CD4 initialization -// setFPGACD4InitEnable(); -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].initEnable = FALSE; -// } -// else -// { -// // clear CD4 Init command -// clearFPGACD4InitEnable(); -// } -//} +void handleConductivitySensorsInitProcedure( void ) +{ + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CPI_SENSOR ].initEnable ) + { + // CPi initialization + setFPGACPiInitEnable(); + conductivitySensorControl[ CONDUCTIVITYSENSORS_CPI_SENSOR ].initEnable = FALSE; + } + else + { + // clear CPi Init command + clearFPGACPiInitEnable(); + } + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CPO_SENSOR ].initEnable ) + { + // CPo initialization + setFPGACPoInitEnable(); + conductivitySensorControl[ CONDUCTIVITYSENSORS_CPO_SENSOR ].initEnable = FALSE; + } + else + { + // clear CPo Init command + clearFPGACPoInitEnable(); + } +} + /*********************************************************************//** * @brief * The execConductivitySensorWrite function executes the conductivity sensor write * state machine. * @details \b Inputs: conductivitySensorWriteState * @details \b Outputs: conductivitySensorWriteState - * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if invalid conductivity sensor write + * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT if invalid conductivity sensor write * state seen * @return none *************************************************************************/ -//void execConductivitySensorWrite( void ) -//{ -// CONDUCTIVITY_SENSORS_T sensor; -// -// for ( sensor = CONDUCTIVITYSENSORS_CD1_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) -// { -// // write state machine -// switch ( conductivitySensorControl[sensor].writeExecState ) -// { -// case CONDUCTIVITY_WRITE_INITIATE: -// conductivitySensorControl[sensor].writeExecState = handleConductivitySensorsWriteInitiate(); -// break; -// -// case CONDUCTIVITY_WRITE_COMPLETE: -// conductivitySensorControl[sensor].writeExecState = handleConductivitySensorsWriteComplete(); -// 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; -// break; -// } -// } -//} +void execConductivitySensorWrite( void ) +{ + CONDUCTIVITY_SENSORS_T sensor; + for ( sensor = CONDUCTIVITYSENSORS_FIRST; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) + { + // write state machine + switch ( conductivitySensorControl[sensor].writeExecState ) + { + case CONDUCTIVITY_WRITE_INITIATE: + conductivitySensorControl[sensor].writeExecState = handleConductivitySensorsWriteInitiate( sensor ); + break; + + case CONDUCTIVITY_WRITE_COMPLETE: + conductivitySensorControl[sensor].writeExecState = handleConductivitySensorsWriteComplete( sensor ); + break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_WR_INVALID_EXEC_STATE, (U32)conductivitySensorControl[sensor].writeExecState ) + conductivitySensorControl[sensor].writeExecState = CONDUCTIVITY_WRITE_INITIATE; + break; + } + } +} + /*********************************************************************//** * @brief * The handleConductivitySensorsWriteInitiate function initiates the write * 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[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeEnable && -// FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeInProgress ) -// { -// // CD1 write request -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeComplete = FALSE; -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeInProgress = TRUE; -// setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeAddress ); -// setFPGACD12Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeData ); -// setFPGACD1WriteEnable(); -// state = CONDUCTIVITY_WRITE_COMPLETE; -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeEnable && -// FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeInProgress ) -// { -// // CD2 write request -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeComplete = FALSE; -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeInProgress = TRUE; -// setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeAddress ); -// setFPGACD12Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeData ); -// setFPGACD2WriteEnable(); -// state = CONDUCTIVITY_WRITE_COMPLETE; -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeEnable && -// FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeInProgress ) -// { -// // CD3 write request -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeComplete = FALSE; -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeInProgress = TRUE; -// setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeAddress ); -// setFPGACD34Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeData ); -// setFPGACD3WriteEnable(); -// state = CONDUCTIVITY_WRITE_COMPLETE; -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeEnable && -// FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeInProgress ) -// { -// // CD4 write request -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeComplete = FALSE; -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeInProgress = TRUE; -// setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeAddress ); -// setFPGACD34Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeData ); -// setFPGACD4WriteEnable(); -// state = CONDUCTIVITY_WRITE_COMPLETE; -// } + if ( TRUE == conductivitySensorControl[ sensorID ].writeEnable && + FALSE == conductivitySensorControl[ sensorID ].writeInProgress ) + { + conductivitySensorControl[ sensorID ].writeComplete = FALSE; + conductivitySensorControl[ sensorID ].writeInProgress = TRUE; + if ( CONDUCTIVITYSENSORS_CPI_SENSOR == sensorID ) + { + setFPGACPiAddress( conductivitySensorControl[ sensorID ].writeAddress ); + setFPGACPiData( conductivitySensorControl[ sensorID ].writeData ); + setFPGACPiWriteEnable(); + } + else + { + setFPGACPoAddress( conductivitySensorControl[ sensorID ].writeAddress ); + setFPGACPoData( conductivitySensorControl[ sensorID ].writeData ); + setFPGACPoWriteEnable(); + } + state = CONDUCTIVITY_WRITE_COMPLETE; + } return state; } @@ -684,43 +601,27 @@ * 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[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeInProgress ) -// { -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeComplete = TRUE; -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeEnable = FALSE; -// clearFPGACD1WriteEnable(); -// state = CONDUCTIVITY_WRITE_INITIATE; -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeInProgress ) -// { -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeComplete = TRUE; -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeEnable = FALSE; -// clearFPGACD2WriteEnable(); -// state = CONDUCTIVITY_WRITE_INITIATE; -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeInProgress ) -// { -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeComplete = TRUE; -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeEnable = FALSE; -// clearFPGACD3WriteEnable(); -// state = CONDUCTIVITY_WRITE_INITIATE; -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeInProgress ) -// { -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeComplete = TRUE; -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeEnable = FALSE; -// clearFPGACD4WriteEnable(); -// state = CONDUCTIVITY_WRITE_INITIATE; -// } + if ( TRUE == conductivitySensorControl[ sensorID ].writeInProgress ) + { + conductivitySensorControl[ sensorID ].writeComplete = TRUE; + conductivitySensorControl[ sensorID ].writeEnable = FALSE; + if ( CONDUCTIVITYSENSORS_CPI_SENSOR == sensorID ) + { + clearFPGACPiWriteEnable(); + } + else + { + clearFPGACPoWriteEnable(); + } + state = CONDUCTIVITY_WRITE_INITIATE; + } return state; } @@ -731,30 +632,30 @@ * state machine. * @details \b Inputs: conductivitySensorReadState * @details \b Outputs: conductivitySensorReadState - * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if invalid conductivity sensor read + * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT if invalid conductivity sensor read * state seen * @return none *************************************************************************/ void execConductivitySensorRead( void ) { CONDUCTIVITY_SENSORS_T sensor; - for ( sensor = CONDUCTIVITYSENSORS_CD1_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) + for ( sensor = CONDUCTIVITYSENSORS_FIRST; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) { // Read state machine 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_RO_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_RD_INVALID_EXEC_STATE, (U32)conductivitySensorControl[sensor].readExecState ) + conductivitySensorControl[sensor].readExecState = CONDUCTIVITY_READ_INITIATE; break; } } @@ -766,55 +667,30 @@ * 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[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readEnable && -// FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readInProgress ) -// { -// // CD1 read request -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readComplete = FALSE; -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readInProgress = TRUE; -// setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readAddress ); -// setFPGACD1ReadEnable(); -// state = CONDUCTIVITY_READ_COMPLETE; -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readEnable && -// FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readInProgress ) -// { -// // CD2 read request -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readComplete = FALSE; -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readInProgress = TRUE; -// setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readAddress ); -// setFPGACD2ReadEnable(); -// state = CONDUCTIVITY_READ_COMPLETE; -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readEnable && -// FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readInProgress ) -// { -// // CD3 read request -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readComplete = FALSE; -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readInProgress = TRUE; -// setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readAddress ); -// setFPGACD3ReadEnable(); -// state = CONDUCTIVITY_READ_COMPLETE; -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readEnable && -// FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readInProgress ) -// { -// // CD4 read request -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readComplete = FALSE; -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readInProgress = TRUE; -// setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readAddress ); -// setFPGACD4ReadEnable(); -// state = CONDUCTIVITY_READ_COMPLETE; -// } + if ( TRUE == conductivitySensorControl[ sensorID ].readEnable && + FALSE == conductivitySensorControl[ sensorID ].readInProgress ) + { + conductivitySensorControl[ sensorID ].readComplete = FALSE; + conductivitySensorControl[ sensorID ].readInProgress = TRUE; + if ( CONDUCTIVITYSENSORS_CPI_SENSOR == sensorID ) + { + setFPGACPiAddress( conductivitySensorControl[ sensorID ].readAddress ); + setFPGACPiReadEnable(); + } + else + { + setFPGACPoAddress( conductivitySensorControl[ sensorID ].readAddress ); + setFPGACPoReadEnable(); + } + state = CONDUCTIVITY_READ_COMPLETE; + } return state; } @@ -825,47 +701,29 @@ * 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[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readInProgress ) -// { -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readData = getFPGACD1Data(); -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readComplete = TRUE; -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readEnable = FALSE; -// clearFPGACD1ReadEnable(); -// state = CONDUCTIVITY_READ_INITIATE; -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readInProgress ) -// { -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readData = getFPGACD2Data(); -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readComplete = TRUE; -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readEnable = FALSE; -// clearFPGACD2ReadEnable(); -// state = CONDUCTIVITY_READ_INITIATE; -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readInProgress ) -// { -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readData = getFPGACD3Data(); -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readComplete = TRUE; -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readEnable = FALSE; -// clearFPGACD3ReadEnable(); -// state = CONDUCTIVITY_READ_INITIATE; -// } -// -// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readInProgress ) -// { -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readData = getFPGACD4Data(); -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readComplete = TRUE; -// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readEnable = FALSE; -// clearFPGACD4ReadEnable(); -// state = CONDUCTIVITY_READ_INITIATE; -// } + if ( TRUE == conductivitySensorControl[ sensorID ].readInProgress ) + { + if ( CONDUCTIVITYSENSORS_CPI_SENSOR == sensorID ) + { + conductivitySensorControl[ sensorID ].readData = getFPGACPiData(); + clearFPGACPiReadEnable(); + } + else + { + conductivitySensorControl[ sensorID ].readData = getFPGACPoData(); + clearFPGACPoReadEnable(); + } + conductivitySensorControl[ sensorID ].readComplete = TRUE; + conductivitySensorControl[ sensorID ].readEnable = FALSE; + state = CONDUCTIVITY_READ_INITIATE; + } return state; }