Index: firmware/App/Drivers/ConductivityTeensy.c =================================================================== diff -u -r5c5496009e91f63def2014cbc04a71eada45f8de -r133bb277d0f518f13e74a57c4edabaf22bc0ebe7 --- firmware/App/Drivers/ConductivityTeensy.c (.../ConductivityTeensy.c) (revision 5c5496009e91f63def2014cbc04a71eada45f8de) +++ firmware/App/Drivers/ConductivityTeensy.c (.../ConductivityTeensy.c) (revision 133bb277d0f518f13e74a57c4edabaf22bc0ebe7) @@ -30,9 +30,13 @@ #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. // ********** private data ********** -static CONDUCTIVITY_COMM_STATE_T conductivityCommState = COND_COMM_STATE_START; +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 U32 condReceiptCounter = 0; ///< Conductivity response receipt counter. static U32 condTransmitCounter = 0; ///< Conductivity command transmit counter. @@ -48,6 +52,13 @@ 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. +// 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. @@ -61,26 +72,40 @@ 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 , "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" }, +}; +// 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 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 ); @@ -98,18 +123,18 @@ static BOOL sendTeensyReadCmd( 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_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 void sendCmd_stopMeasurement( void ); @@ -133,93 +158,19 @@ void initCondTeensy( void ) { - conductivityCommState = COND_COMM_STATE_START; + conductivityCommState = COND_COMM_STATE_IDLE; condReceiptCounter = 0; condTransmitCounter = 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 ); initConductivityDMAchannels(); -} -void execConductivityCommunication( void ) -{ - switch ( conductivityCommState ) - { - case COND_COMM_STATE_START: - break; - - case COND_COMM_STATE_SEND_CMD: - break; - - case COND_COMM_STATE_RCV_RSPNS: - break; - - case COND_COMM_STATE_SEND_CMD_GET_INIT_STATUS: - conductivityCommState = sendCmd_getInitStatus(); - break; - - case COND_COMM_STATE_RCV_RSPNS_GET_INIT_STATUS: - conductivityCommState = rcvRspns_getInitStatus(); - break; - - case COND_COMM_STATE_SEND_CMD_UPDATE_EEPROM_DATA: - { - CONDUCTIVITY_EEPROM_DATA_T eepromData = {0}; - conductivityCommState = sendCmd_updateEEPROMdata( eepromData ); - break; - } - - case COND_COMM_STATE_RCV_RSPNS_UPDATE_EEPROM_DATA: - conductivityCommState = rcvRspns_updateEEPROMdata(); - break; - - case COND_COMM_STATE_SEND_CMD_GET_EEPROM_DATA: - conductivityCommState = sendCmd_getEEPROMdata(); - break; - - 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; - } - - case COND_COMM_STATE_RCV_RSPNS_UPDATE_MEASUREMENT_SETTINGS: - conductivityCommState = rcvRspns_updateMeasurementSettings(); - break; - - case COND_COMM_STATE_SEND_CMD_GET_MEASUREMENT_SETTINGS: - conductivityCommState = sendCmd_getMeasurementSettings(); - break; - - case COND_COMM_STATE_RCV_RSPNS_GET_MEASUREMENT_SETTINGS: - conductivityCommState = rcvRspns_getMeasurementSettings(); - break; - - case COND_COMM_STATE_SEND_CMD_GET_MEASUREMENT: - conductivityCommState = sendCmd_getMeasurements(); - break; - - case COND_COMM_STATE_RCV_RSPNS_GET_MEASUREMENT: - conductivityCommState = rcvRspns_getMeasurements(); - break; - - case COND_COMM_STATE_FAILED: - break; - - default: - break; - } - + // add init conductivity commands + enqueue( TEENSY_CMD_INIT_SENSOR ); + enqueue( TEENSY_CMD_GET_MEASUREMENT ); } static void initConductivityDMAchannels( void ) @@ -312,6 +263,154 @@ /*********************************************************************//** * @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_SEND_CMD: + conductivityCommState = handleConductivityTX(); + break; + + case COND_COMM_STATE_RCV_RSPNS: + conductivityCommState = handleConductivityRX(); + 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_SEND_CMD; + } + + 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_SEND_CMD; + + + switch ( currentCmd ) + { + case TEENSY_CMD_INIT_SENSOR: + state = sendCmd_initSensor(); + break; + case TEENSY_CMD_GET_INIT_STATUS: + state = sendCmd_getInitStatus(); + break; + case TEENSY_CMD_UPDATE_EEPROM_DATA: + state = sendCmd_updateEEPROMdata( eePromDataTX ); + break; + case TEENSY_CMD_GET_EEPROM_DATA: + state = sendCmd_getEEPROMdata(); + break; + case TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS: + state = sendCmd_updateMeasurementSettings( measurementSettingsTX ); + break; + case TEENSY_CMD_GET_MEASUREMENT_SETTINGS: + state = sendCmd_getMeasurementSettings(); + break; + case TEENSY_CMD_GET_MEASUREMENT: + state = sendCmd_getMeasurements(); + break; + case TEENSY_CMD_STOP_MEASUREMENT: + sendCmd_stopMeasurement(); + break; + case TEENSY_CMD_GET_ALL_MEASUREMENTS: + sendCmd_getAllMeasurements(); + break; + case TEENSY_CMD_SELECT_SENSOR: + sendCmd_selectSensor( currentSelectedSensor ); + break; + case TEENSY_CMD_GET_SINGLE_MEASUREMENT: + sendCmd_getSingleMeasurement( currentCmd ); + 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_SEND_CMD; + + switch ( currentCmd ) + { + 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; + } + + return state; +} + +/*********************************************************************//** + * @brief * The signalConductivityReceiptCompleted function increments a counter to indicate * that another DMA receipt from the Conductivity has completed and sets comm flags * indicating pending response from Conductivity is completed. @@ -390,15 +489,98 @@ 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 @@ -612,42 +794,52 @@ static BOOL sendTeensyWriteCmd( TEENSY_CMD_INDEX_T cmdIndex, const U08* param ) { BOOL success = FALSE; + U32 txByteLength = 0; // Validate command index and ensure command string exists if ( ( cmdIndex >= MAX_NUM_OF_TEENSY_CMDS ) || - ( NULL == teensyCmd[ cmdIndex ] ) ) + ( NULL == teensyCmdMap[ cmdIndex ][ 1 ] ) ) { success = FALSE; } else { - const U08* baseCmd = (const U08*)teensyCmd[ cmdIndex ]; + const U08* baseCmd = (const U08*)teensyCmdMap[ cmdIndex ]; // 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; } @@ -688,13 +880,17 @@ static CONDUCTIVITY_COMM_STATE_T sendCmd_initSensor( void ) { - CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_SEND_CMD_INIT_SENSOR; + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_SEND_CMD; if ( FALSE == sendTeensyWriteCmd( TEENSY_CMD_INIT_SENSOR, NULL ) ) { // Handle error: log or set error flag } - + else + { + // Waiting for DMA Read buffer true + state = COND_COMM_STATE_RCV_RSPNS; + } return state; }