Index: firmware/App/Drivers/ConductivityTeensy.c =================================================================== diff -u -r5c5496009e91f63def2014cbc04a71eada45f8de -r424859ea9121940514b9415fe5a15ae1882825a6 --- firmware/App/Drivers/ConductivityTeensy.c (.../ConductivityTeensy.c) (revision 5c5496009e91f63def2014cbc04a71eada45f8de) +++ firmware/App/Drivers/ConductivityTeensy.c (.../ConductivityTeensy.c) (revision 424859ea9121940514b9415fe5a15ae1882825a6) @@ -26,14 +26,27 @@ #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_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_START; +static CONDUCTIVITY_COMM_STATE_T conductivityCommState = COND_COMM_STATE_IDLE; +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. @@ -48,39 +61,66 @@ 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. +static U08 queueRearIndex; ///< Queue rear index. +static U08 queueFrontIndex; ///< Queue front index. +static TEENSY_CMD_INDEX_T currentCmd; + // Conductivity DMA control records static g_dmaCTRL condDMAWriteControlRecord; ///< DMA record for controlling a DMA write command transmission from buffer. static g_dmaCTRL condDMAWriteRespControlRecord; ///< DMA record for controlling a DMA write command reception to buffer. static g_dmaCTRL condDMAReadControlRecord; ///< DMA record for controlling a DMA read command transmission from buffer. 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 U08* teensyCmd[] = { "a", ///< COND_COMM_STATE_SEND_CMD_INIT_SENSOR - "l", ///< COND_COMM_STATE_SEND_CMD_GET_INIT_STATUS - "save", ///< COND_COMM_STATE_SEND_CMD_UPDATE_EEPROM_DATA, - "e", ///< COND_COMM_STATE_SEND_CMD_GET_EEPROM_DATA, - "cfg", ///< COND_COMM_STATE_SEND_CMD_UPDATE_MEASUREMENT_SETTINGS, - "k", ///< COND_COMM_STATE_SEND_CMD_GET_MEASUREMENT_SETTINGS, - "m", ///< COND_COMM_STATE_SEND_CMD_GET_MEASUREMENT, - "n", ///< Stop getting measurements - "g", ///< Get measurements of all the sensors - "j", ///< Select a sensor. ex : "j 1" selects sensor number 1 - "h" ///< Get that of selected sensor. (First Execute command "j".) - }; +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 +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 void handleConductivitySendCmd( void ); -static void handleConductivityReceiveResponse( 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 ); +static BOOL isQueueEmpty ( void ); +static BOOL enqueue ( TEENSY_CMD_INDEX_T cmd ); +static void dequeue( void ); + static void setupConductivityDMAForWriteCmd( U32 bytes2Transmit ); static void startConductivityDMAWriteCmd( void ); static void setupConductivityDMAForWriteResp( U32 bytes2Receive ); @@ -94,33 +134,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 rcvRspns_initSensor( void ); -static CONDUCTIVITY_COMM_STATE_T sendCmd_getInitStatus( void ); -static CONDUCTIVITY_COMM_STATE_T rcvRspns_getInitStatus( void ); -static CONDUCTIVITY_COMM_STATE_T sendCmd_updateEEPROMdata( CONDUCTIVITY_EEPROM_DATA_T eepromData); -static CONDUCTIVITY_COMM_STATE_T rcvRspns_updateEEPROMdata( void ); -static CONDUCTIVITY_COMM_STATE_T sendCmd_getEEPROMdata( void ); -static CONDUCTIVITY_COMM_STATE_T rcvRspns_getEEPROMdata( void ); -static CONDUCTIVITY_COMM_STATE_T sendCmd_updateMeasurementSettings( CONDUCTIVITY_MEASUREMENT_SETTINGS_T measurementSettings ); -static CONDUCTIVITY_COMM_STATE_T rcvRspns_updateMeasurementSettings( void ); -static CONDUCTIVITY_COMM_STATE_T sendCmd_getMeasurementSettings( void ); -static CONDUCTIVITY_COMM_STATE_T rcvRspns_getMeasurementSettings( void ); -static CONDUCTIVITY_COMM_STATE_T sendCmd_getMeasurements( void ); -static CONDUCTIVITY_COMM_STATE_T rcvRspns_getMeasurements( void ); +static CONDUCTIVITY_COMM_STATE_T txInitSensor( void ); +static CONDUCTIVITY_COMM_STATE_T rxInitSensor( 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 txGetInitStatus( void ); +static CONDUCTIVITY_COMM_STATE_T rxGetInitStatus( void ); +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 ); @@ -133,95 +182,220 @@ void initCondTeensy( void ) { - conductivityCommState = COND_COMM_STATE_START; + 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( &condWriteResponseBuffer, 0, COND_WRITE_RSP_BUFFER_LEN ); memset( &condReadResponseBuffer, 0, COND_READ_RSP_BUFFER_LEN ); +// memset( &condTxBuffer, 0, COND_TX_BUFFER_LEN ); +// memset( &condRxBuffer, 0, COND_RX_BUFFER_LEN ); + initConductivityDMAchannels(); } -void execConductivityCommunication( void ) +/*********************************************************************//** + * @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_START: + case COND_COMM_STATE_IDLE: + conductivityCommState = handleConductivityIdle(); break; - case COND_COMM_STATE_SEND_CMD: + case COND_COMM_STATE_TX: + conductivityCommState = handleConductivityTX(); break; - case COND_COMM_STATE_RCV_RSPNS: + case COND_COMM_STATE_RX: + conductivityCommState = handleConductivityRX(); break; - case COND_COMM_STATE_SEND_CMD_GET_INIT_STATUS: - conductivityCommState = sendCmd_getInitStatus(); + case COND_COMM_STATE_FAILED: + conductivityCommState = handleFailedState(); break; - case COND_COMM_STATE_RCV_RSPNS_GET_INIT_STATUS: - conductivityCommState = rcvRspns_getInitStatus(); + default: + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, (U32)conductivityCommState ) break; + } +} - case COND_COMM_STATE_SEND_CMD_UPDATE_EEPROM_DATA: - { - CONDUCTIVITY_EEPROM_DATA_T eepromData = {0}; - conductivityCommState = sendCmd_updateEEPROMdata( eepromData ); - 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; + } - case COND_COMM_STATE_RCV_RSPNS_UPDATE_EEPROM_DATA: - conductivityCommState = rcvRspns_updateEEPROMdata(); - break; + return state; +} - case COND_COMM_STATE_SEND_CMD_GET_EEPROM_DATA: - conductivityCommState = sendCmd_getEEPROMdata(); - break; +/*********************************************************************//** + * @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; - case COND_COMM_STATE_RCV_RSPNS_GET_EEPROM_DATA: - conductivityCommState = rcvRspns_getEEPROMdata(); - break; - case COND_COMM_STATE_SEND_CMD_UPDATE_MEASUREMENT_SETTINGS: - { - CONDUCTIVITY_MEASUREMENT_SETTINGS_T measurementSettings = {0}; - conductivityCommState = sendCmd_updateMeasurementSettings( measurementSettings ); - break; - } + 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; - case COND_COMM_STATE_RCV_RSPNS_UPDATE_MEASUREMENT_SETTINGS: - conductivityCommState = rcvRspns_updateMeasurementSettings(); - break; + default: + break; + } - case COND_COMM_STATE_SEND_CMD_GET_MEASUREMENT_SETTINGS: - conductivityCommState = sendCmd_getMeasurementSettings(); - break; + return state; +} - case COND_COMM_STATE_RCV_RSPNS_GET_MEASUREMENT_SETTINGS: - conductivityCommState = rcvRspns_getMeasurementSettings(); - break; +/*********************************************************************//** + * @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; - case COND_COMM_STATE_SEND_CMD_GET_MEASUREMENT: - conductivityCommState = sendCmd_getMeasurements(); - break; + 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; + } - case COND_COMM_STATE_RCV_RSPNS_GET_MEASUREMENT: - conductivityCommState = rcvRspns_getMeasurements(); - break; + return state; +} - case COND_COMM_STATE_FAILED: - break; - default: +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 @@ -390,15 +564,96 @@ return calculatedMeasurement[sensorNum].Temperature; } -static void handleConductivitySendCmd( void ) +/*********************************************************************//** + * @brief + * The isQueueFull checks whether the queue is full and if it is full, + * it will return a true. + * @details Inputs: queueCount + * @details Outputs: none + * @return TRUE is queue is full + *************************************************************************/ +static BOOL isQueueFull ( void ) { + BOOL isFull = FALSE; + if ( queueCount >= COND_CMD_Q_LEN - 1 ) + { + isFull = TRUE; + } + + return isFull; } -static void handleConductivityReceiveResponse( void ) + +/*********************************************************************//** + * @brief + * The isQueueEmpty checks whether the queue is empty and if it is empty, + * it will return a false. + * @details Inputs: queueCount + * @details Outputs: none + * @return TRUE if queue is not empty + *************************************************************************/ +static BOOL isQueueEmpty ( void ) { + BOOL isEmpty = TRUE; + if ( queueCount > 0 ) + { + isEmpty = FALSE; + } + + return isEmpty; } +/*********************************************************************//** + * @brief + * The dequeue function adds a cmd from the cmd queue if it is not full. + * @details Inputs: condCmdQ[], queueRearIndex, queueCount + * @details Outputs: condCmdQ[], queueRearIndex, queueCount + * @param cmd the Cmd ID to be queue'd + * @return none + *************************************************************************/ +static BOOL enqueue ( TEENSY_CMD_INDEX_T cmd ) +{ + BOOL result = FALSE; + + _disable_IRQ(); + if ( !isQueueFull() ) + { + queueCount++; + condCmdQ[ queueRearIndex ] = cmd; + queueRearIndex = INC_WRAP( queueRearIndex, 0, COND_CMD_Q_LEN - 1 ); + result = TRUE; + } + _enable_IRQ(); + + return result; +} + +/*********************************************************************//** + * @brief + * The dequeue function removes a job from the job queue if it is not empty. + * @details Inputs: condCmdQ[], queueFrontIndex, queueCount + * @details Outputs: condCmdQ[], queueFrontIndex, queueCount, currentCmd + * @return none + *************************************************************************/ +static void dequeue( void ) +{ + U32 tempIndex; + + _disable_IRQ(); + tempIndex = queueFrontIndex; + if ( !isQueueEmpty() ) + { + queueFrontIndex = INC_WRAP( queueFrontIndex, 0, COND_CMD_Q_LEN - 1 ); + currentCmd = condCmdQ [ tempIndex ]; + } + if ( queueCount > 0 ) + { + queueCount--; + } + _enable_IRQ(); +} + static void consumeUnexpectedConductivityData( void ) { // Clear any errors @@ -485,25 +740,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; @@ -519,25 +774,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; @@ -553,21 +809,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; } @@ -577,24 +832,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; } } } @@ -609,45 +863,56 @@ * @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 == teensyCmd[ cmdIndex ] ) ) + ( NULL == teensyCmdMap[ cmdIndex ].teensyCMD ) ) { success = FALSE; } else { - const U08* baseCmd = (const U08*)teensyCmd[ 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 ) ) { - U16 written = snprintf( (char*)condWriteCmdBuffer, - COND_WRITE_CMD_BUFFER_LEN, - "%s %s", - (const char*)baseCmd, - (const char*)param ); + written = snprintf( (char*)condWriteCmdBuffer, + COND_WRITE_CMD_BUFFER_LEN, + "%s %s", + (const char*)baseCmd, + (const char*)param ); - success = ( written > 0 ) && ( written < COND_WRITE_CMD_BUFFER_LEN ); + if ( written > 0 ) + { + success = TRUE; + } } else { - U16 written = snprintf( (char*)condWriteCmdBuffer, - COND_WRITE_CMD_BUFFER_LEN, - "%s", - (const char*)baseCmd ); + written = snprintf( (char*)condWriteCmdBuffer, + COND_WRITE_CMD_BUFFER_LEN, + "%s", + (const char*)baseCmd ); - success = ( written > 0 ) && ( written < COND_WRITE_CMD_BUFFER_LEN ); + if ( written > 0 ) + { + success = TRUE; + } } } + condWriteCommandInProgress = TRUE; + setupConductivityDMAForWriteCmd( written ); + startConductivityDMAWriteCmd(); return success; } @@ -657,82 +922,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_INIT_SENSOR; + 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 + { + 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]; @@ -761,47 +1080,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]; @@ -815,134 +1141,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; } Index: firmware/App/Drivers/ConductivityTeensy.h =================================================================== diff -u -r1ab489b7b273361422832d620165a66951b1f93b -r424859ea9121940514b9415fe5a15ae1882825a6 --- firmware/App/Drivers/ConductivityTeensy.h (.../ConductivityTeensy.h) (revision 1ab489b7b273361422832d620165a66951b1f93b) +++ firmware/App/Drivers/ConductivityTeensy.h (.../ConductivityTeensy.h) (revision 424859ea9121940514b9415fe5a15ae1882825a6) @@ -62,38 +62,51 @@ typedef enum Conductivity_Parse_Status { - CONDUCTIVITY_PARSE_SUCCESS = 0, + CONDUCTIVITY_PARSE_NONE = 0, CONDUCTIVITY_PARSE_ERROR_NULL_BUFFER, CONDUCTIVITY_PARSE_ERROR_INVALID_LENGTH, - CONDUCTIVITY_PARSE_ERROR_INVALID_SENSOR_NUM + CONDUCTIVITY_PARSE_ERROR_INVALID_SENSOR_NUM, + CONDUCTIVITY_PARSE_SUCCESS, } CONDUCTIVITY_PARSE_STATUS; -/// Enumeration of FPGA states. +/// Enumeration of Conductivity Communication states. typedef enum Conductivity_Comm_States { - COND_COMM_STATE_START = 0, - COND_COMM_STATE_SEND_CMD, - COND_COMM_STATE_RCV_RSPNS, - COND_COMM_STATE_SEND_CMD_INIT_SENSOR, - COND_COMM_STATE_RCV_RSPNS_INIT_SENSOR, - COND_COMM_STATE_SEND_CMD_GET_INIT_STATUS, - COND_COMM_STATE_RCV_RSPNS_GET_INIT_STATUS, - COND_COMM_STATE_SEND_CMD_UPDATE_EEPROM_DATA, - COND_COMM_STATE_RCV_RSPNS_UPDATE_EEPROM_DATA, - COND_COMM_STATE_SEND_CMD_GET_EEPROM_DATA, - COND_COMM_STATE_RCV_RSPNS_GET_EEPROM_DATA, - COND_COMM_STATE_SEND_CMD_UPDATE_MEASUREMENT_SETTINGS, - COND_COMM_STATE_RCV_RSPNS_UPDATE_MEASUREMENT_SETTINGS, - COND_COMM_STATE_SEND_CMD_GET_MEASUREMENT_SETTINGS, - COND_COMM_STATE_RCV_RSPNS_GET_MEASUREMENT_SETTINGS, - COND_COMM_STATE_SEND_CMD_GET_MEASUREMENT, - COND_COMM_STATE_RCV_RSPNS_GET_MEASUREMENT, + COND_COMM_STATE_IDLE = 0, + COND_COMM_STATE_TX, + COND_COMM_STATE_RX, COND_COMM_STATE_FAILED, NUM_OF_COND_COMM_STATES } CONDUCTIVITY_COMM_STATE_T; +/// Update EEPROM status +typedef enum Conductivity_Update_Eeprom_Status +{ + COND_UPDATE_EEPROM_STATUS_UNITIALIZED = 0, ///< The initialization process has not started. + COND_UPDATE_EEPROMSTATUS_IN_PROGRESS, ///< The initialization process has started. + COND_UPDATE_EEPROM_STATUS_INITIALIZED, ///< Initialization process completed and all the sensors were initialized successfully. + COND_UPDATE_EEPROM_STATUS_FAILED ///< Initialization process completed but one or more sensor was not initialized properly. +}CONDUCTIVITY_UPDATE_EEPROM_STATUS_T; + +// Update Measurement Settings Status +typedef enum Update_mst_Status +{ + COND_MST_STATUS_ERR_UNRECOGNIZED_PARAM = 0, // Invalid parameter was passed with the command + COND_MST_STATUS_ERR_UPDATED_TO_DEFAULT_TIA, // Invalid value of "rtia" was passed with the command. So it was updated to its default value. + COND_MST_STATUS_ERR_UPDATED_TO_DEFAULT_PGA, // Invalid value of "pga" was passed with the command. So it was updated to its default value. + COND_MST_STATUS_ERR_UPDATED_TO_DEFAULT_DFT_NUM, // Invalid value of "dftnum" was passed with the command. So it was updated to its default value. + COND_MST_STATUS_ERR_UPDATED_TO_DEFAULT_AVG_NUM, // Invalid value of "avgnum" was passed with the command. So it was updated to its default value. + COND_MST_STATUS_SUCCESS +}CONDUCTIVITY_UPDATE_MST_STATUS_T;; + typedef struct { + TEENSY_CMD_INDEX_T cmdIdx; + U08* teensyCMD; +} CONDUCTIVITY_CMD_DATA_T; + +typedef struct +{ F64 A0; F64 A1; F64 B0; @@ -149,7 +162,7 @@ // ********** public function prototypes ********** void initCondTeensy( void ); -void execConductivityCommunication( void ); +void execConductivityTeensy( void ); void signalConductivityReceiptCompleted( void ); void signalConductivityTransmitCompleted( void ); F64 getImpedanceValue( U32 sensorNum ); Index: firmware/App/Monitors/Conductivity.c =================================================================== diff -u -rd48829521f698f5fe55157bc688ca196a9376faa -r424859ea9121940514b9415fe5a15ae1882825a6 --- firmware/App/Monitors/Conductivity.c (.../Conductivity.c) (revision d48829521f698f5fe55157bc688ca196a9376faa) +++ firmware/App/Monitors/Conductivity.c (.../Conductivity.c) (revision 424859ea9121940514b9415fe5a15ae1882825a6) @@ -146,7 +146,7 @@ execConductivitySensorRead(); #endif - execConductivityCommunication(); + execConductivityTeensy(); filterConductivitySensors(); // publish conductivity sensors