Index: firmware/App/Drivers/ConductivityTeensy.c =================================================================== diff -u -r133bb277d0f518f13e74a57c4edabaf22bc0ebe7 -r64ca86ddd949d0ae1c02fa10dfb3b8bb6e0c9f6c --- firmware/App/Drivers/ConductivityTeensy.c (.../ConductivityTeensy.c) (revision 133bb277d0f518f13e74a57c4edabaf22bc0ebe7) +++ firmware/App/Drivers/ConductivityTeensy.c (.../ConductivityTeensy.c) (revision 64ca86ddd949d0ae1c02fa10dfb3b8bb6e0c9f6c) @@ -26,18 +26,29 @@ #define SCI_RECEIVE_DMA_REQUEST 38 ///< Serial port receive DMA request line. #define SCI_TRANSMIT_DMA_REQUEST 39 ///< Serial port transmit DMA request line. + #define COND_WRITE_CMD_BUFFER_LEN 256 ///< Conductivity write command buffer byte length. #define COND_WRITE_RSP_BUFFER_LEN 8 ///< Conductivity write command response buffer byte length. #define COND_READ_CMD_BUFFER_LEN 8 ///< Conductivity read command buffer byte length. #define COND_READ_RSP_BUFFER_LEN 256 ///< Conductivity read command response buffer byte length. #define COND_CMD_Q_LEN 8 ///< Maximum number of cmds that can be queue'd. #define QUEUE_START_INDEX 0U ///< Queue start index. +#define COND_CMD_Q_LEN 8 ///< Maximum number of cmds that can be queue'd. +#define QUEUE_START_INDEX 0U ///< Queue start index. + +#define COND_STATUS_TIMEOUT_MS ( 2 * MS_PER_SECOND ) ///< Timeout before which we should receive INIT_STATUS_IN_PROGRESS from teensy +#define COND_DATA_TIMEOUT_MS ( 5 * MS_PER_SECOND ) ///< Timeout before which we should receive INIT_STATUS_INITIALIZED or INIT_STATUS_FAILED from teensy + +//#define COND_TX_BUFFER_LEN 256 ///< Conductivity transmit buffer length in bytes. +//#define COND_RX_BUFFER_LEN 256 ///< Conductivity receive buffer length in bytes. + // ********** private data ********** static CONDUCTIVITY_COMM_STATE_T conductivityCommState = COND_COMM_STATE_IDLE; -static CONDUCTIVITY_TX_STATE_T conductivityTXCommState = COND_COMM_STATE_SEND_CMD_INIT_SENSOR; -static CONDUCTIVITY_RX_STATE_T conductivityRXCommState = COND_COMM_STATE_RCV_RSPNS_INIT_SENSOR; +static CONDUCTIVITY_COMM_STATE_T currentFailedState = COND_COMM_STATE_IDLE; +static U32 condResponseTime = 0; + static U32 condReceiptCounter = 0; ///< Conductivity response receipt counter. static U32 condTransmitCounter = 0; ///< Conductivity command transmit counter. static BOOL condWriteCommandInProgress = FALSE; ///< Flag indicating an Conductivity write command is in progress. @@ -52,6 +63,9 @@ static U08 condReadCmdBuffer[ COND_READ_CMD_BUFFER_LEN ]; ///< Conductivity read command buffer. Holds the next Conductivity read command to be transmitted. static U08 condReadResponseBuffer[ COND_READ_RSP_BUFFER_LEN ]; ///< Conductivity read command response buffer. Memory reserved to capture the response to the last Conductivity read command. +//static U08 condTxBuffer[ COND_TX_BUFFER_LEN ]; ///< Conductivity transmit buffer. +//static U08 condRxBuffer[ COND_RX_BUFFER_LEN ]; ///< Conductivity receive buffer + // Conductivity queue buffer and supporting variables. static TEENSY_CMD_INDEX_T condCmdQ[ COND_CMD_Q_LEN ]; ///< Conductivity command queue buffer. static U08 queueCount; ///< Queue count. @@ -66,25 +80,26 @@ static g_dmaCTRL condDMAReadRespControlRecord; ///< DMA record for controlling a DMA read command reception to buffer. static CONDUCTIVITY_INIT_STATUS_T conductivityInitStatus; +static CONDUCTIVITY_UPDATE_EEPROM_STATUS_T condUpdateEEPROMstatus; +static CONDUCTIVITY_UPDATE_MST_STATUS_T condUpdateMeasurementSettings; static CONDUCTIVITY_EEPROM_DATA_T conductivityEEPROMdata; static CONDUCTIVITY_MEASUREMENT_SETTINGS_T conductivityMeasurementSettings; static CONDUCTIVITY_SENSOR_DATA_T rawConductivityValues[ MAX_TEENSY_SENSOR ]; static CONDUCTIVITY_CALCULATED_MEASUREMENTS_T calculatedMeasurement[ MAX_TEENSY_SENSOR ]; static CONDUCTIVITY_COEFFICIENTS_T conductivityCoeff[MAX_TEENSY_SENSOR]; -static const CONDUCTIVITY_CMD_DATA_T teensyCmdMap[][] = -{ - { TEENSY_CMD_INIT_SENSOR , "a" }, - { TEENSY_CMD_GET_INIT_STATUS , "l" }, - { TEENSY_CMD_UPDATE_EEPROM_DATA , "save" }, - { TEENSY_CMD_GET_EEPROM_DATA , "e" }, - { TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS , "cfg" }, - { TEENSY_CMD_GET_MEASUREMENT_SETTINGS , "k" }, - { TEENSY_CMD_GET_MEASUREMENT , "m" }, - { TEENSY_CMD_STOP_MEASUREMENT , "n" }, - { TEENSY_CMD_GET_ALL_MEASUREMENTS , "g" }, - { TEENSY_CMD_SELECT_SENSOR , "j" }, - { TEENSY_CMD_GET_SINGLE_MEASUREMENT , "h" }, +static const CONDUCTIVITY_CMD_DATA_T teensyCmdMap[] = { + { TEENSY_CMD_INIT_SENSOR , (U08*)"a" }, + { TEENSY_CMD_GET_INIT_STATUS , (U08*)"l" }, + { TEENSY_CMD_UPDATE_EEPROM_DATA , (U08*)"save" }, + { TEENSY_CMD_GET_EEPROM_DATA , (U08*)"e" }, + { TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS , (U08*)"cfg" }, + { TEENSY_CMD_GET_MEASUREMENT_SETTINGS , (U08*)"k" }, + { TEENSY_CMD_GET_MEASUREMENT , (U08*)"m" }, + { TEENSY_CMD_STOP_MEASUREMENT , (U08*)"n" }, + { TEENSY_CMD_GET_ALL_MEASUREMENTS , (U08*)"g" }, + { TEENSY_CMD_SELECT_SENSOR , (U08*)"j" }, + { TEENSY_CMD_GET_SINGLE_MEASUREMENT , (U08*)"h" }, }; // Conductivity cmd data structs @@ -94,11 +109,19 @@ CONDUCTIVITY_MEASUREMENT_SETTINGS_T measurementSettingsTX; CONDUCTIVITY_MEASUREMENT_SETTINGS_T measurementSettingsRX; +// Conductivity cmd data structs +TEENSY_SENSOR_INDEX_T currentSelectedSensor; +CONDUCTIVITY_EEPROM_DATA_T eePromDataTX; +CONDUCTIVITY_EEPROM_DATA_T eePromDataRX; +CONDUCTIVITY_MEASUREMENT_SETTINGS_T measurementSettingsTX; +CONDUCTIVITY_MEASUREMENT_SETTINGS_T measurementSettingsRX; + // ********** private function prototypes ********** static void initConductivityDMAchannels( void ); static CONDUCTIVITY_COMM_STATE_T handleConductivityIdle( void ); static CONDUCTIVITY_COMM_STATE_T handleConductivityTX( void ); static CONDUCTIVITY_COMM_STATE_T handleConductivityRX( void ); +static CONDUCTIVITY_COMM_STATE_T handleFailedState( void ); static void consumeUnexpectedConductivityData( void ); static BOOL isQueueFull ( void ); @@ -119,33 +142,42 @@ static CONDUCTIVITY_PARSE_STATUS parseEEPROMdata( const U32 *buffer, U32 len ); static CONDUCTIVITY_PARSE_STATUS parseConductivityMeasurements( const U32 *buffer, U32 len ); -static BOOL sendTeensyWriteCmd( TEENSY_CMD_INDEX_T cmdIndex, const U08* param ); -static BOOL sendTeensyReadCmd( TEENSY_CMD_INDEX_T cmdIndex ); +static BOOL txTeensyWriteCmd( TEENSY_CMD_INDEX_T cmdIndex, const U08* param ); +static BOOL txTeensyReadCmd( TEENSY_CMD_INDEX_T cmdIndex ); -static CONDUCTIVITY_COMM_STATE_T sendCmd_initSensor( void ); -static CONDUCTIVITY_COMM_STATE_T sendCmd_getInitStatus( void ); -static CONDUCTIVITY_COMM_STATE_T sendCmd_updateEEPROMdata( CONDUCTIVITY_EEPROM_DATA_T eepromData); -static CONDUCTIVITY_COMM_STATE_T sendCmd_getEEPROMdata( void ); -static CONDUCTIVITY_COMM_STATE_T sendCmd_updateMeasurementSettings( CONDUCTIVITY_MEASUREMENT_SETTINGS_T measurementSettings ); -static CONDUCTIVITY_COMM_STATE_T sendCmd_getMeasurementSettings( void ); -static CONDUCTIVITY_COMM_STATE_T sendCmd_getMeasurements( void ); +static CONDUCTIVITY_COMM_STATE_T txInitSensor( void ); +static CONDUCTIVITY_COMM_STATE_T rxInitSensor( void ); -static CONDUCTIVITY_COMM_STATE_T rcvRspns_initSensor( void ); -static CONDUCTIVITY_COMM_STATE_T rcvRspns_getInitStatus( void ); -static CONDUCTIVITY_COMM_STATE_T rcvRspns_updateEEPROMdata( void ); -static CONDUCTIVITY_COMM_STATE_T rcvRspns_updateMeasurementSettings( void ); -static CONDUCTIVITY_COMM_STATE_T rcvRspns_getMeasurementSettings( void ); -static CONDUCTIVITY_COMM_STATE_T rcvRspns_getMeasurements( void ); +static CONDUCTIVITY_COMM_STATE_T txGetInitStatus( void ); +static CONDUCTIVITY_COMM_STATE_T rxGetInitStatus( void ); -static void sendCmd_stopMeasurement( void ); -static void rcvRspns_stopMeasurement( void ); -static void sendCmd_getAllMeasurements( void ); -static void rcvRspns_getAllMeasurements( void ); -static void sendCmd_selectSensor( TEENSY_SENSOR_INDEX_T sensorNum ); -static void rcvRspns_selectSensor( TEENSY_SENSOR_INDEX_T sensorNum ); -static void sendCmd_getSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ); -static void rcvRspns_getSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ); +static CONDUCTIVITY_COMM_STATE_T txUpdateEEPROMdata( CONDUCTIVITY_EEPROM_DATA_T eepromData); +static CONDUCTIVITY_COMM_STATE_T rxUpdateEEPROMdata( void ); +static CONDUCTIVITY_COMM_STATE_T txGetEEPROMdata( void ); +static CONDUCTIVITY_COMM_STATE_T rxGetEEPROMdata( void ); + +static CONDUCTIVITY_COMM_STATE_T txUpdateMeasurementSettings( CONDUCTIVITY_MEASUREMENT_SETTINGS_T measurementSettings ); +static CONDUCTIVITY_COMM_STATE_T rxUpdateMeasurementSettings( void ); + +static CONDUCTIVITY_COMM_STATE_T txGetMeasurementSettings( void ); +static CONDUCTIVITY_COMM_STATE_T rxGetMeasurementSettings( void ); + +static CONDUCTIVITY_COMM_STATE_T txGetMeasurements( void ); +static CONDUCTIVITY_COMM_STATE_T rxGetMeasurements( void ); + +static void txStopMeasurement( void ); +static void rxStopMeasurement( void ); + +static void txGetAllMeasurements( void ); +static void rxGetAllMeasurements( void ); + +static void txSelectSensor( TEENSY_SENSOR_INDEX_T sensorNum ); +static void rxSelectSensor( TEENSY_SENSOR_INDEX_T sensorNum ); + +static void txGetSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ); +static void rxGetSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ); + static CONDUCTIVITY_INIT_STATUS_T getInitStatus( void ); static const CONDUCTIVITY_EEPROM_DATA_T* getEEPROMdata( void ); static const CONDUCTIVITY_MEASUREMENT_SETTINGS_T* getMeasurementSettings( void ); @@ -161,18 +193,217 @@ conductivityCommState = COND_COMM_STATE_IDLE; condReceiptCounter = 0; condTransmitCounter = 0; + condResponseTime = 0; // initialize Conductivity comm buffers memset( &condWriteCmdBuffer, 0, COND_WRITE_CMD_BUFFER_LEN ); memset( &condReadCmdBuffer, 0, COND_READ_CMD_BUFFER_LEN ); +// memset( &condTxBuffer, 0, COND_TX_BUFFER_LEN ); +// memset( &condRxBuffer, 0, COND_RX_BUFFER_LEN ); + initConductivityDMAchannels(); // add init conductivity commands enqueue( TEENSY_CMD_INIT_SENSOR ); enqueue( TEENSY_CMD_GET_MEASUREMENT ); +/*********************************************************************//** + * @brief + * The execConductivityTeensy function manages incoming data exchanges with + * the Teensy board over UART. + * @details \b Inputs: conductivityCommState + * @details \b Outputs: conductivityCommState + * @return none + *************************************************************************/ +void execConductivityTeensy( void ) +{ + switch ( conductivityCommState ) + { + case COND_COMM_STATE_IDLE: + conductivityCommState = handleConductivityIdle(); + break; + + case COND_COMM_STATE_TX: + conductivityCommState = handleConductivityTX(); + break; + + case COND_COMM_STATE_RX: + conductivityCommState = handleConductivityRX(); + break; + + case COND_COMM_STATE_FAILED: + conductivityCommState = handleFailedState(); + break; + + default: + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, (U32)conductivityCommState ) + break; + } } +/*********************************************************************//** + * @brief + * The handleConductivityIdle handles the command queue and transitions to the respective + * comm state. + * @details \b Inputs: TBD + * @details \b Outputs: TBD + * @return none + *************************************************************************/ +static CONDUCTIVITY_COMM_STATE_T handleConductivityIdle( void ) +{ + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_IDLE; + if ( !isQueueEmpty() ) + { + dequeue(); + state = COND_COMM_STATE_TX; + } + + return state; +} + +/*********************************************************************//** + * @brief + * The handleConductivityTX handles the transmission of data over UART + * to the Teensy board. + * @details \b Inputs: TBD + * @details \b Outputs: TBD + * @return none + *************************************************************************/ +static CONDUCTIVITY_COMM_STATE_T handleConductivityTX( void ) +{ + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; + + + switch ( currentCmd ) + { + case TEENSY_CMD_INIT_SENSOR: + state = txInitSensor(); + break; + case TEENSY_CMD_GET_INIT_STATUS: + state = txGetInitStatus(); + break; + case TEENSY_CMD_UPDATE_EEPROM_DATA: + state = txUpdateEEPROMdata( eePromDataTX ); + break; + case TEENSY_CMD_GET_EEPROM_DATA: + state = txGetEEPROMdata(); + break; + case TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS: + state = txUpdateMeasurementSettings( measurementSettingsTX ); + break; + case TEENSY_CMD_GET_MEASUREMENT_SETTINGS: + state = txGetMeasurementSettings(); + break; + case TEENSY_CMD_GET_MEASUREMENT: + state = txGetMeasurements(); + break; + case TEENSY_CMD_STOP_MEASUREMENT: + txStopMeasurement(); + break; + case TEENSY_CMD_GET_ALL_MEASUREMENTS: + txGetAllMeasurements(); + break; + case TEENSY_CMD_SELECT_SENSOR: + txSelectSensor( currentSelectedSensor ); + break; + case TEENSY_CMD_GET_SINGLE_MEASUREMENT: + txGetSingleMeasurement( currentSelectedSensor ); + break; + + default: + break; + } + + return state; +} + +/*********************************************************************//** + * @brief + * The handleConductivityRX handles the receiving of data over UART + * to the Teensy board. + * @details \b Inputs: TBD + * @details \b Outputs: TBD + * @return none + *************************************************************************/ +static CONDUCTIVITY_COMM_STATE_T handleConductivityRX( void ) +{ + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; + + switch ( currentCmd ) + { + case TEENSY_CMD_INIT_SENSOR: + state = rxInitSensor(); + break; + case TEENSY_CMD_GET_INIT_STATUS: + state = rxGetInitStatus(); + break; + case TEENSY_CMD_UPDATE_EEPROM_DATA: + state = rxUpdateEEPROMdata( ); + break; + case TEENSY_CMD_GET_EEPROM_DATA: + state = rxGetEEPROMdata(); + break; + case TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS: + state = rxUpdateMeasurementSettings( ); + break; + case TEENSY_CMD_GET_MEASUREMENT_SETTINGS: + state = rxGetMeasurementSettings(); + break; + case TEENSY_CMD_GET_MEASUREMENT: + state = rxGetMeasurements(); + break; + case TEENSY_CMD_STOP_MEASUREMENT: + rxStopMeasurement(); + break; + case TEENSY_CMD_GET_ALL_MEASUREMENTS: + rxGetAllMeasurements(); + break; + case TEENSY_CMD_SELECT_SENSOR: + rxSelectSensor( currentSelectedSensor ); + break; + case TEENSY_CMD_GET_SINGLE_MEASUREMENT: + rxGetSingleMeasurement( currentSelectedSensor ); + break; + } + + return state; +} + + +static CONDUCTIVITY_COMM_STATE_T handleFailedState( void ) +{ + switch(currentFailedState) + { + case TEENSY_CMD_INIT_SENSOR: + break; + case TEENSY_CMD_GET_INIT_STATUS: + break; + case TEENSY_CMD_UPDATE_EEPROM_DATA: + break; + case TEENSY_CMD_GET_EEPROM_DATA: + break; + case TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS: + break; + case TEENSY_CMD_GET_MEASUREMENT_SETTINGS: + break; + case TEENSY_CMD_GET_MEASUREMENT: + break; + case TEENSY_CMD_STOP_MEASUREMENT: + break; + case TEENSY_CMD_GET_ALL_MEASUREMENTS: + break; + case TEENSY_CMD_SELECT_SENSOR: + break; + case TEENSY_CMD_GET_SINGLE_MEASUREMENT: + break; + default: + break; + + } +} + + + static void initConductivityDMAchannels( void ) { // Assign DMA channels to h/w DMA requests @@ -579,8 +810,6 @@ _enable_IRQ(); } - - static void consumeUnexpectedConductivityData( void ) { // Clear any errors @@ -667,25 +896,25 @@ * len - Length of the input data. * @return CONDUCTIVITY_PARSE_STATUS to tell if parsing was successful or not. *************************************************************************/ -static CONDUCTIVITY_PARSE_STATUS parseMeasurementSettings( const U32 *buffer, U32 len ) +static CONDUCTIVITY_PARSE_STATUS parseMeasurementSettings(const U32 *buffer, U32 len) { - CONDUCTIVITY_PARSE_STATUS parseStatus = CONDUCTIVITY_PARSE_SUCCESS; - U32 expectedDataLength = sizeof( CONDUCTIVITY_MEASUREMENT_SETTINGS_T ); + CONDUCTIVITY_PARSE_STATUS parseStatus = CONDUCTIVITY_PARSE_NONE; + U32 expectedDataLength = sizeof(CONDUCTIVITY_MEASUREMENT_SETTINGS_T); // Validate buffer - if ( buffer == NULL ) + if (buffer == NULL) { parseStatus = CONDUCTIVITY_PARSE_ERROR_NULL_BUFFER; } - // Validate buffer length - else if ( len != expectedDataLength ) + else if (len != expectedDataLength) { parseStatus = CONDUCTIVITY_PARSE_ERROR_INVALID_LENGTH; } else { - // Parse and Store the data - memcpy( &conductivityMeasurementSettings, buffer, expectedDataLength ); + // Parse and store the data + memcpy(&conductivityMeasurementSettings, buffer, expectedDataLength); + parseStatus = CONDUCTIVITY_PARSE_SUCCESS; } return parseStatus; @@ -701,25 +930,26 @@ * len - Length of the input data. * @return CONDUCTIVITY_PARSE_STATUS to tell if parsing was successful or not. *************************************************************************/ -static CONDUCTIVITY_PARSE_STATUS parseEEPROMdata( const U32 *buffer, U32 len ) +static CONDUCTIVITY_PARSE_STATUS parseEEPROMdata(const U32 *buffer, U32 len) { - CONDUCTIVITY_PARSE_STATUS parseStatus = CONDUCTIVITY_PARSE_SUCCESS; - U32 expectedDataLength = sizeof( CONDUCTIVITY_EEPROM_DATA_T ); + CONDUCTIVITY_PARSE_STATUS parseStatus = CONDUCTIVITY_PARSE_NONE; + U32 expectedDataLength = sizeof(CONDUCTIVITY_EEPROM_DATA_T); // Validate buffer - if ( buffer == NULL ) + if (buffer == NULL) { parseStatus = CONDUCTIVITY_PARSE_ERROR_NULL_BUFFER; } // Validate buffer length - else if ( len != expectedDataLength ) + else if (len != expectedDataLength) { parseStatus = CONDUCTIVITY_PARSE_ERROR_INVALID_LENGTH; } else { // Parse and Store the data - memcpy( &conductivityEEPROMdata, buffer, expectedDataLength ); + memcpy(&conductivityEEPROMdata, buffer, expectedDataLength); + parseStatus = CONDUCTIVITY_PARSE_SUCCESS; } return parseStatus; @@ -735,21 +965,20 @@ * len - Length of the input data. * @return CONDUCTIVITY_PARSE_STATUS to tell if parsing was successful or not. *************************************************************************/ -static CONDUCTIVITY_PARSE_STATUS parseConductivityMeasurements( const U32 *buffer, U32 len ) +static CONDUCTIVITY_PARSE_STATUS parseConductivityMeasurements(const U32 *buffer, U32 len) { - CONDUCTIVITY_PARSE_STATUS parseStatus = CONDUCTIVITY_PARSE_SUCCESS; - U32 expectedDataLength = sizeof( CONDUCTIVITY_SENSOR_DATA_T ); + CONDUCTIVITY_PARSE_STATUS parseStatus = CONDUCTIVITY_PARSE_NONE; + U32 expectedDataLength = sizeof(CONDUCTIVITY_SENSOR_DATA_T); U32 sensorCount = 0; U16 sensorIdx = 0; - // // Validate buffer - if ( NULL == buffer ) + // Validate buffer + if (buffer == NULL) { parseStatus = CONDUCTIVITY_PARSE_ERROR_NULL_BUFFER; } - // Validate buffer length - else if ( ( len % expectedDataLength ) != 0 ) + else if ((len % expectedDataLength) != 0) { parseStatus = CONDUCTIVITY_PARSE_ERROR_INVALID_LENGTH; } @@ -759,24 +988,23 @@ sensorCount = len / expectedDataLength; // Parse the data and store in conductivityMeasurements[] - for ( sensorIdx = 0; sensorIdx < sensorCount; sensorIdx++ ) + for (sensorIdx = 0; sensorIdx < sensorCount; sensorIdx++) { // Read the sensor data temporarily CONDUCTIVITY_SENSOR_DATA_T tempSensor; - memcpy(&tempSensor, ( buffer + ( sensorIdx * expectedDataLength ) ), expectedDataLength ); + memcpy(&tempSensor, (buffer + (sensorIdx * expectedDataLength)), expectedDataLength); - // And check if the received sensor number id valid - if ( (tempSensor.sensorNum < 1 ) || - ( tempSensor.sensorNum > MAX_TEENSY_SENSOR ) ) + // Check if the received sensor number is valid + if ((tempSensor.sensorNum < 1) || (tempSensor.sensorNum > MAX_TEENSY_SENSOR)) { parseStatus = CONDUCTIVITY_PARSE_ERROR_INVALID_SENSOR_NUM; break; } else { - // The received data value contains sensor values from 1 to 6. - // So store value in array index for position (sensorNum - 1) i.e. 0 to 5. + // Store value in array index for position (sensorNum - 1) rawConductivityValues[tempSensor.sensorNum - 1] = tempSensor; + parseStatus = CONDUCTIVITY_PARSE_SUCCESS; } } } @@ -791,28 +1019,29 @@ * @param param Optional parameter string to append after the command. * @return TRUE if the command was successfully written to the write buffer, FALSE otherwise. */ -static BOOL sendTeensyWriteCmd( TEENSY_CMD_INDEX_T cmdIndex, const U08* param ) +static BOOL txTeensyWriteCmd( TEENSY_CMD_INDEX_T cmdIndex, const U08* param ) { BOOL success = FALSE; U32 txByteLength = 0; + U16 written = 0; // Validate command index and ensure command string exists if ( ( cmdIndex >= MAX_NUM_OF_TEENSY_CMDS ) || - ( NULL == teensyCmdMap[ cmdIndex ][ 1 ] ) ) + ( NULL == teensyCmdMap[ cmdIndex ].teensyCMD ) ) { success = FALSE; } else { - const U08* baseCmd = (const U08*)teensyCmdMap[ cmdIndex ]; + const U08* baseCmd = (const U08*)teensyCmdMap[ cmdIndex ].teensyCMD; // Clear the write buffer before writing memset( condWriteCmdBuffer, 0, COND_WRITE_CMD_BUFFER_LEN ); // Format command with optional parameter if ( ( NULL != param ) && ( strlen( (const char*)param ) > 0 ) ) { - written = snprintf( (char*)condWriteCmdBuffer, + written = snprintf( (char*)condWriteCmdBuffer, COND_WRITE_CMD_BUFFER_LEN, "%s %s", (const char*)baseCmd, @@ -849,86 +1078,136 @@ * @param cmdIndex Index of the command in teensyCmd[]. * @return TRUE if the command was successfully written to the read buffer, FALSE otherwise. */ -static BOOL sendTeensyReadCmd( TEENSY_CMD_INDEX_T cmdIndex ) +static BOOL txTeensyReadCmd( TEENSY_CMD_INDEX_T cmdIndex ) { BOOL success = FALSE; - // Validate command index and ensure command string exists - if ( ( cmdIndex >= MAX_NUM_OF_TEENSY_CMDS ) || - ( NULL == teensyCmd[ cmdIndex ] ) ) - { - success = FALSE; - } - else - { - const U08* baseCmd = (const U08*)teensyCmd[ cmdIndex ]; + // Validate command index and ensure command string exists + if ( ( cmdIndex >= MAX_NUM_OF_TEENSY_CMDS ) || + ( NULL == teensyCmdMap[ cmdIndex ].teensyCMD ) ) + { + success = FALSE; + } + else + { + const U08* baseCmd = (const U08*)teensyCmdMap[ cmdIndex ].teensyCMD;; - // Clear the read buffer before writing - memset( condReadCmdBuffer, 0, COND_READ_CMD_BUFFER_LEN ); + // Clear the read buffer before writing + memset( condReadCmdBuffer, 0, COND_READ_CMD_BUFFER_LEN ); - // Write only the command string (no parameters allowed) - U16 written = snprintf( (char*)condReadCmdBuffer, - COND_READ_CMD_BUFFER_LEN, - "%s", - (const char*)baseCmd ); + // Write only the command string (no parameters allowed) + U16 written = snprintf( (char*)condReadCmdBuffer, + COND_READ_CMD_BUFFER_LEN, + "%s", + (const char*)baseCmd ); - success = ( written > 0 ) && ( written < COND_READ_CMD_BUFFER_LEN ); - } + success = ( written > 0 ) && ( written < COND_READ_CMD_BUFFER_LEN ); + } - return success; + return success; } -static CONDUCTIVITY_COMM_STATE_T sendCmd_initSensor( void ) +static CONDUCTIVITY_COMM_STATE_T txInitSensor( void ) { - CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_SEND_CMD; + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; - if ( FALSE == sendTeensyWriteCmd( TEENSY_CMD_INIT_SENSOR, NULL ) ) + // If the init sensor cmd was sent successfully + if ( TRUE == txTeensyWriteCmd( TEENSY_CMD_INIT_SENSOR, NULL ) ) { - // Handle error: log or set error flag + // Get the current time + condResponseTime = getMSTimerCount(); + state = COND_COMM_STATE_RX; } else { - // Waiting for DMA Read buffer true - state = COND_COMM_STATE_RCV_RSPNS; + state = COND_COMM_STATE_FAILED; } + return state; } -static CONDUCTIVITY_COMM_STATE_T rcvRspns_initSensor( void ) +static CONDUCTIVITY_COMM_STATE_T rxInitSensor( void ) { - CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RCV_RSPNS_INIT_SENSOR; + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; + CONDUCTIVITY_INIT_STATUS_T initStatus = CONDUCTIVITY_INIT_STATUS_UNITIALIZED; - // condWriteResponseBuffer + initStatus = (CONDUCTIVITY_INIT_STATUS_T)condWriteResponseBuffer[0]; + switch(initStatus) + { + case CONDUCTIVITY_INIT_STATUS_UNITIALIZED: + // Check if init has not started before the timeout + if ( TRUE == didTimeout( condResponseTime, COND_STATUS_TIMEOUT_MS ) ) + { + // Then, Move to failed state + state = COND_COMM_STATE_FAILED; + } + else + { + // Get the current time + condResponseTime = getMSTimerCount(); + } + break; + + case CONDUCTIVITY_INIT_STATUS_IN_PROGRESS: + // Check if initialization has not completed before the timeout + if ( TRUE == didTimeout( condResponseTime, COND_DATA_TIMEOUT_MS ) ) + { + // Then, Move to failed state + state = COND_COMM_STATE_FAILED; + } + else + { + // Reset timer for next use + condResponseTime = 0; + } + break; + + case CONDUCTIVITY_INIT_STATUS_INITIALIZED: + // Move to execute next command + state = COND_COMM_STATE_IDLE; + break; + + case CONDUCTIVITY_INIT_STATUS_FAILED: + default: + // Then, Move to failed state + state = COND_COMM_STATE_FAILED; + break; + } + return state; } -static CONDUCTIVITY_COMM_STATE_T sendCmd_getInitStatus( void ) +static CONDUCTIVITY_COMM_STATE_T txGetInitStatus( void ) { - CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_SEND_CMD_GET_INIT_STATUS; + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; - if ( FALSE == sendTeensyReadCmd( TEENSY_CMD_GET_INIT_STATUS ) ) + // If the get init status cmd was sent successfully + if ( TRUE == txTeensyReadCmd( TEENSY_CMD_GET_INIT_STATUS ) ) { - // Handle error + state = COND_COMM_STATE_RX; } + else + { + state = COND_COMM_STATE_FAILED; + } - return state; } -static CONDUCTIVITY_COMM_STATE_T rcvRspns_getInitStatus( void ) +static CONDUCTIVITY_COMM_STATE_T rxGetInitStatus( void ) { - CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RCV_RSPNS_GET_INIT_STATUS; + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; + conductivityInitStatus = ( CONDUCTIVITY_INIT_STATUS_T )condReadResponseBuffer[ 0 ]; + state = COND_COMM_STATE_IDLE; - // condReadResponseBuffer - return state; } -static CONDUCTIVITY_COMM_STATE_T sendCmd_updateEEPROMdata( CONDUCTIVITY_EEPROM_DATA_T eepromData ) +static CONDUCTIVITY_COMM_STATE_T txUpdateEEPROMdata( CONDUCTIVITY_EEPROM_DATA_T eepromData ) { - CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_SEND_CMD_UPDATE_EEPROM_DATA; + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; // Format EEPROM data into a string U08 paramStr[256]; @@ -957,47 +1236,54 @@ paramStr[ offset - 1 ] = '\0'; } - if ( FALSE == sendTeensyWriteCmd( TEENSY_CMD_UPDATE_EEPROM_DATA, paramStr ) ) + if ( TRUE == txTeensyWriteCmd( TEENSY_CMD_UPDATE_EEPROM_DATA, paramStr ) ) { - // Handle error + state = COND_COMM_STATE_RX; } + else + { + state = COND_COMM_STATE_FAILED; + } return state; } -static CONDUCTIVITY_COMM_STATE_T rcvRspns_updateEEPROMdata( void ) +static CONDUCTIVITY_COMM_STATE_T rxUpdateEEPROMdata( void ) { - CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RCV_RSPNS_UPDATE_EEPROM_DATA; - - // condWriteResponseBuffer - + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; + condUpdateEEPROMstatus = ( CONDUCTIVITY_UPDATE_EEPROM_STATUS_T )condWriteResponseBuffer[ 0 ]; + state = COND_COMM_STATE_IDLE; return state; } -static CONDUCTIVITY_COMM_STATE_T sendCmd_getEEPROMdata( void ) +static CONDUCTIVITY_COMM_STATE_T txGetEEPROMdata( void ) { - CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_SEND_CMD_GET_EEPROM_DATA; + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; - if ( FALSE == sendTeensyReadCmd( TEENSY_CMD_GET_EEPROM_DATA ) ) + if ( TRUE == txTeensyReadCmd( TEENSY_CMD_GET_EEPROM_DATA ) ) { - // Handle error + state = COND_COMM_STATE_RX; + } + else + { + state = COND_COMM_STATE_FAILED; + } return state; } -static CONDUCTIVITY_COMM_STATE_T rcvRspns_getEEPROMdata( void ) +static CONDUCTIVITY_COMM_STATE_T rxGetEEPROMdata( void ) { - CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RCV_RSPNS_GET_EEPROM_DATA; - - // condReadResponseBuffer - + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; + CONDUCTIVITY_PARSE_STATUS parseStatus = parseEEPROMdata( condReadResponseBuffer, COND_READ_RSP_BUFFER_LEN ); + state = COND_COMM_STATE_IDLE; return state; } -static CONDUCTIVITY_COMM_STATE_T sendCmd_updateMeasurementSettings( CONDUCTIVITY_MEASUREMENT_SETTINGS_T measurementSettings ) +static CONDUCTIVITY_COMM_STATE_T txUpdateMeasurementSettings( CONDUCTIVITY_MEASUREMENT_SETTINGS_T measurementSettings ) { - CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_SEND_CMD_UPDATE_MEASUREMENT_SETTINGS; + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; // Format measurement settings into a string U08 paramStr[128]; @@ -1011,134 +1297,144 @@ measurementSettings.DftNum, measurementSettings.ADCAvgNum ); - if ( FALSE == sendTeensyWriteCmd( TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS, paramStr ) ) + if ( TRUE == txTeensyWriteCmd( TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS, paramStr ) ) { - // Handle error + state = COND_COMM_STATE_RX; } + else + { + state = COND_COMM_STATE_FAILED; + } return state; } -static CONDUCTIVITY_COMM_STATE_T rcvRspns_updateMeasurementSettings( void ) +static CONDUCTIVITY_COMM_STATE_T rxUpdateMeasurementSettings( void ) { - CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RCV_RSPNS_UPDATE_MEASUREMENT_SETTINGS; - - // condWriteResponseBuffer - + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; + condUpdateMeasurementSettings = ( CONDUCTIVITY_UPDATE_MST_STATUS_T )condWriteResponseBuffer[0]; + state = COND_COMM_STATE_IDLE; return state; } -static CONDUCTIVITY_COMM_STATE_T sendCmd_getMeasurementSettings( void ) +static CONDUCTIVITY_COMM_STATE_T txGetMeasurementSettings( void ) { - CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_SEND_CMD_GET_MEASUREMENT_SETTINGS; + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; - if ( FALSE == sendTeensyReadCmd( TEENSY_CMD_GET_MEASUREMENT_SETTINGS ) ) + if ( TRUE == txTeensyReadCmd( TEENSY_CMD_GET_MEASUREMENT_SETTINGS ) ) { - // Handle error + state = COND_COMM_STATE_RX; } + else + { + state = COND_COMM_STATE_FAILED; + } return state; } -static CONDUCTIVITY_COMM_STATE_T rcvRspns_getMeasurementSettings( void ) +static CONDUCTIVITY_COMM_STATE_T rxGetMeasurementSettings( void ) { - CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RCV_RSPNS_GET_MEASUREMENT_SETTINGS; + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; + CONDUCTIVITY_PARSE_STATUS parseStatus = parseMeasurementSettings( condReadResponseBuffer, COND_READ_RSP_BUFFER_LEN ); + state = COND_COMM_STATE_IDLE; - // condReadResponseBuffer - return state; } -static CONDUCTIVITY_COMM_STATE_T sendCmd_getMeasurements( void ) +static CONDUCTIVITY_COMM_STATE_T txGetMeasurements( void ) { - CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_SEND_CMD_GET_MEASUREMENT; + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; - if ( FALSE == sendTeensyReadCmd( TEENSY_CMD_GET_MEASUREMENT ) ) + if ( TRUE == txTeensyReadCmd( TEENSY_CMD_GET_MEASUREMENT ) ) { - // Handle error + state = COND_COMM_STATE_RX; } - + else + { + state = COND_COMM_STATE_FAILED; + } return state; } -static CONDUCTIVITY_COMM_STATE_T rcvRspns_getMeasurements( void ) +static CONDUCTIVITY_COMM_STATE_T rxGetMeasurements( void ) { - CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RCV_RSPNS_GET_MEASUREMENT; - - // condReadResponseBuffer - + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; + CONDUCTIVITY_PARSE_STATUS parseStatus = parseConductivityMeasurements( condReadResponseBuffer, COND_READ_RSP_BUFFER_LEN ); + state = COND_COMM_STATE_IDLE; return state; } -static void sendCmd_stopMeasurement( void ) + +static void txStopMeasurement( void ) { - if ( FALSE == sendTeensyReadCmd( TEENSY_CMD_STOP_MEASUREMENT ) ) + if ( FALSE == txTeensyReadCmd( TEENSY_CMD_STOP_MEASUREMENT ) ) { // Handle error } } -static void rcvRspns_stopMeasurement( void ) +static void rxStopMeasurement( void ) { // condReadResponseBuffer } -static void sendCmd_getAllMeasurements( void ) +static void txGetAllMeasurements( void ) { - if ( FALSE == sendTeensyReadCmd( TEENSY_CMD_GET_ALL_MEASUREMENTS ) ) + if ( FALSE == txTeensyReadCmd( TEENSY_CMD_GET_ALL_MEASUREMENTS ) ) { // Handle error } } -static void rcvRspns_getAllMeasurements( void ) +static void rxGetAllMeasurements( void ) { // condReadResponseBuffer } -static void sendCmd_selectSensor( TEENSY_SENSOR_INDEX_T sensorNum ) +static void txSelectSensor( TEENSY_SENSOR_INDEX_T sensorNum ) { U08 paramStr[8]; snprintf( (char*)paramStr, sizeof(paramStr), "%d", sensorNum ); - if ( FALSE == sendTeensyWriteCmd( TEENSY_CMD_SELECT_SENSOR, paramStr ) ) + if ( FALSE == txTeensyWriteCmd( TEENSY_CMD_SELECT_SENSOR, paramStr ) ) { // Handle error } } -static void rcvRspns_selectSensor( TEENSY_SENSOR_INDEX_T sensorNum ) +static void rxSelectSensor( TEENSY_SENSOR_INDEX_T sensorNum ) { // condWriteResponseBuffer } -static void sendCmd_getSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ) +static void txGetSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ) { // Assumes sensor has already been selected - if ( FALSE == sendTeensyReadCmd( TEENSY_CMD_GET_SINGLE_MEASUREMENT ) ) + if ( FALSE == txTeensyReadCmd( TEENSY_CMD_GET_SINGLE_MEASUREMENT ) ) { // Handle error } } -static void rcvRspns_getSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ) +static void rxGetSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ) { // condReadResponseBuffer } static CONDUCTIVITY_INIT_STATUS_T getInitStatus( void ) { - sendCmd_getInitStatus(); - rcvRspns_getInitStatus(); + tx_getInitStatus(); + rx_getInitStatus(); return conductivityInitStatus; }