Index: firmware/App/Drivers/ConductivityTeensy.c =================================================================== diff -u -r9ccc651bf491c37bc202ad8d80f0e4063523320d -r7aafdc16c133bcd4cb0ce5fe08079c1969cc67d2 --- firmware/App/Drivers/ConductivityTeensy.c (.../ConductivityTeensy.c) (revision 9ccc651bf491c37bc202ad8d80f0e4063523320d) +++ firmware/App/Drivers/ConductivityTeensy.c (.../ConductivityTeensy.c) (revision 7aafdc16c133bcd4cb0ce5fe08079c1969cc67d2) @@ -49,7 +49,7 @@ #define RX_SIZE_SELECT_SENSOR 1 #define RX_SIZE_GET_SINGLE_MEASUREMENT ( sizeof( CONDUCTIVITY_SENSOR_DATA_T ) ) -#define COND_STATUS_TIMEOUT_MS ( 2 * MS_PER_SECOND ) ///< Timeout before which we should receive INIT_STATUS_IN_PROGRESS from teensy +#define COND_STATUS_TIMEOUT_MS ( 10 * 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 // ********** private data ********** @@ -60,6 +60,7 @@ static U32 condReceiptCounter = 0; ///< Conductivity response receipt counter. static U32 condTransmitCounter = 0; ///< Conductivity command transmit counter. +static BOOL condAutomatedDataPolling = FALSE; static BOOL condWriteCommandInProgress = FALSE; ///< Flag indicating an Conductivity write command is in progress. static BOOL condReadCommandInProgress = FALSE; ///< Flag indicating an Conductivity read command is in progress. static BOOL condBulkWriteAndReadInProgress = FALSE; ///< Flag indicating an Conductivity bulk write and read command are in progress. @@ -81,6 +82,7 @@ static U08 queueRearIndex; ///< Queue rear index. static U08 queueFrontIndex; ///< Queue front index. static TEENSY_CMD_INDEX_T currentCmd; +static CONDUCTIVITY_MST_PARAM_IDX_T currentSettingParam = CONDUCTIVITY_MST_PARAM_IDX_SINFREQ; // Conductivity DMA control records static g_dmaCTRL condDMAWriteControlRecord; ///< DMA record for controlling a DMA write command transmission from buffer. @@ -90,19 +92,18 @@ 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_UPDATE_MST_STATUS_T condUpdateSettingStatus[MAX_CONDUCTIVITY_MST_PARAM_IDX]; 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[] = { +// Command Index / Sub state Command Length of expected response data { TEENSY_CMD_INIT_SENSOR , (U08*)"a" , RX_SIZE_INIT_SENSOR }, { TEENSY_CMD_GET_INIT_STATUS , (U08*)"l" , RX_SIZE_GET_INIT_STATUS }, - { TEENSY_CMD_UPDATE_EEPROM_DATA , (U08*)"save", RX_SIZE_UPDATE_EEPROM }, + { TEENSY_CMD_UPDATE_EEPROM_DATA , (U08*)"upe" , RX_SIZE_UPDATE_EEPROM }, { TEENSY_CMD_GET_EEPROM_DATA , (U08*)"e" , RX_SIZE_GET_EEPROM }, - { TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS , (U08*)"cfg" , RX_SIZE_UPDATE_MEASUREMENT_SETTINGS }, + { TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS , (U08*)"mst" , RX_SIZE_UPDATE_MEASUREMENT_SETTINGS }, { TEENSY_CMD_GET_MEASUREMENT_SETTINGS , (U08*)"k" , RX_SIZE_GET_MEASUREMENT_SETTNGS }, { TEENSY_CMD_GET_MEASUREMENT , (U08*)"m" , RX_SIZE_GET_MEASUREMENT }, { TEENSY_CMD_STOP_MEASUREMENT , (U08*)"n" , RX_SIZE_STOP_MEASUREMENT }, @@ -111,6 +112,16 @@ { TEENSY_CMD_GET_SINGLE_MEASUREMENT , (U08*)"h" , RX_SIZE_GET_SINGLE_MEASUREMENT }, }; +static const U08* condSettingsParam = { + "sinfreq", + "dacpp", + "bias", + "rtia", + "pga", + "dftnum", + "avgnum" + }; + // Conductivity cmd data structs TEENSY_SENSOR_INDEX_T currentSelectedSensor; CONDUCTIVITY_EEPROM_DATA_T eePromDataTX; @@ -120,6 +131,8 @@ // ********** private function prototypes ********** static void initConductivityDMAchannels( void ); +static void initEEPROMdata( void ); +static void initMeasurementSettings( void ); static CONDUCTIVITY_COMM_STATE_T handleConductivityIdle( void ); static CONDUCTIVITY_COMM_STATE_T handleConductivityTX( void ); static CONDUCTIVITY_COMM_STATE_T handleConductivityRX( void ); @@ -140,9 +153,9 @@ static void setupConductivityDMAForReadResp( U32 bytes2Receive ); static void startConductivityDMAReceiptOfReadResp( void ); -static CONDUCTIVITY_PARSE_STATUS parseMeasurementSettings(const U32 *buffer, U32 len ); -static CONDUCTIVITY_PARSE_STATUS parseEEPROMdata( const U32 *buffer, U32 len ); -static CONDUCTIVITY_PARSE_STATUS parseConductivityMeasurements( const U32 *buffer, U32 len ); +static CONDUCTIVITY_PARSE_STATUS parseMeasurementSettings(const U08 *buffer, U32 len ); +static CONDUCTIVITY_PARSE_STATUS parseEEPROMdata( const U08 *buffer, U32 len ); +static CONDUCTIVITY_PARSE_STATUS parseConductivityMeasurements( const U08 *buffer, U32 len ); static BOOL txTeensyWriteCmd( TEENSY_CMD_INDEX_T cmdIndex, const U08* param ); static BOOL rxTeensyReadRsp( TEENSY_CMD_INDEX_T cmdIndex ); @@ -153,13 +166,13 @@ 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 txUpdateEEPROMdata( void ); 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 txUpdateMeasurementSettings( void ); static CONDUCTIVITY_COMM_STATE_T rxUpdateMeasurementSettings( void ); static CONDUCTIVITY_COMM_STATE_T txGetMeasurementSettings( void ); @@ -168,17 +181,17 @@ static CONDUCTIVITY_COMM_STATE_T txGetMeasurements( void ); static CONDUCTIVITY_COMM_STATE_T rxGetMeasurements( void ); -static void txStopMeasurement( void ); -static void rxStopMeasurement( void ); +static CONDUCTIVITY_COMM_STATE_T txStopMeasurement( void ); +static CONDUCTIVITY_COMM_STATE_T rxStopMeasurement( void ); -static void txGetAllMeasurements( void ); -static void rxGetAllMeasurements( void ); +static CONDUCTIVITY_COMM_STATE_T txGetAllMeasurements( void ); +static CONDUCTIVITY_COMM_STATE_T rxGetAllMeasurements( void ); -static void txSelectSensor( TEENSY_SENSOR_INDEX_T sensorNum ); -static void rxSelectSensor( TEENSY_SENSOR_INDEX_T sensorNum ); +static CONDUCTIVITY_COMM_STATE_T txSelectSensor( TEENSY_SENSOR_INDEX_T sensorNum ); +static CONDUCTIVITY_COMM_STATE_T rxSelectSensor( TEENSY_SENSOR_INDEX_T sensorNum ); -static void txGetSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ); -static void rxGetSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ); +static CONDUCTIVITY_COMM_STATE_T txGetSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ); +static CONDUCTIVITY_COMM_STATE_T rxGetSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ); static CONDUCTIVITY_INIT_STATUS_T getInitStatus( void ); static const CONDUCTIVITY_EEPROM_DATA_T* getEEPROMdata( void ); @@ -196,6 +209,7 @@ condReceiptCounter = 0; condTransmitCounter = 0; condResponseTime = 0; + condAutomatedDataPolling = FALSE; // initialize Conductivity comm buffers // memset( &condWriteCmdBuffer, 0, COND_WRITE_CMD_BUFFER_LEN ); @@ -209,11 +223,16 @@ // add init conductivity commands enqueue( TEENSY_CMD_INIT_SENSOR ); enqueue( TEENSY_CMD_GET_INIT_STATUS ); + initEEPROMdata( ); + enqueue( TEENSY_CMD_GET_EEPROM_DATA ); + initMeasurementSettings( ); + enqueue( TEENSY_CMD_GET_MEASUREMENT_SETTINGS ); + enqueue( TEENSY_CMD_GET_MEASUREMENT ); + } static void initConductivityDMAchannels( void ) { - memset( &condWriteCmdBuffer, 0, COND_WRITE_CMD_BUFFER_LEN ); memset( &condWriteResponseBuffer, 0, COND_WRITE_RSP_BUFFER_LEN ); // Enable interrupt notifications for FPGA serial port @@ -304,6 +323,53 @@ consumeUnexpectedConductivityData(); } +static void initEEPROMdata( void ) +{ + // TODO Update real values in eePromDataTX + eePromDataTX.doubleValue[ 0 ] = 0.0; + eePromDataTX.doubleValue[ 1 ] = 0.0; + eePromDataTX.doubleValue[ 2 ] = 0.0; + eePromDataTX.doubleValue[ 3 ] = 0.0; + eePromDataTX.doubleValue[ 4 ] = 0.0; + eePromDataTX.doubleValue[ 5 ] = 0.0; + eePromDataTX.doubleValue[ 6 ] = 0.0; + eePromDataTX.doubleValue[ 7 ] = 0.0; + + eePromDataTX.floatValue[ 0 ] = 0.0; + eePromDataTX.floatValue[ 1 ] = 0.0; + eePromDataTX.floatValue[ 2 ] = 0.0; + eePromDataTX.floatValue[ 3 ] = 0.0; + eePromDataTX.floatValue[ 4 ] = 0.0; + eePromDataTX.floatValue[ 5 ] = 0.0; + eePromDataTX.floatValue[ 6 ] = 0.0; + eePromDataTX.floatValue[ 7 ] = 0.0; + eePromDataTX.floatValue[ 8 ] = 0.0; + eePromDataTX.floatValue[ 8 ] = 0.0; + eePromDataTX.floatValue[ 10 ] = 0.0; + eePromDataTX.floatValue[ 11 ] = 0.0; + eePromDataTX.floatValue[ 12 ] = 0.0; + eePromDataTX.floatValue[ 13 ] = 0.0; + eePromDataTX.floatValue[ 14 ] = 0.0; + eePromDataTX.floatValue[ 15 ] = 0.0; + + enqueue( TEENSY_CMD_UPDATE_EEPROM_DATA ); + +} + +static void initMeasurementSettings( void ) +{ + // TODO Update real values in measurementSettingsTX + measurementSettingsTX.SinFreq = 11000.0; + measurementSettingsTX.DacVoltPP = 400.0; + measurementSettingsTX.BiasVolt = 200.0; + measurementSettingsTX.HstiaRtiaSel = 7; + measurementSettingsTX.AdcPgaGain = 2; + measurementSettingsTX.DftNum = 256; + measurementSettingsTX.ADCAvgNum = 16; + + enqueue( TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS ); +} + /*********************************************************************//** * @brief * The execConductivityTeensy function manages incoming data exchanges with @@ -354,6 +420,23 @@ dequeue(); state = COND_COMM_STATE_TX; } + else + { + // If queue is empty, q automated polling data cmd + // otherwise, we are already polling data, move to recv next data packet + if ( condAutomatedDataPolling == TRUE ) + { + state = COND_COMM_STATE_RX; + setupConductivityDMAForWriteResp( teensyCmdMap[ currentCmd ].rxSize ); + startConductivityDMAReceiptOfWriteResp(); + } + else + { + condAutomatedDataPolling = TRUE; + enqueue( TEENSY_CMD_GET_MEASUREMENT ); + state = COND_COMM_STATE_TX; + } + } return state; } @@ -380,13 +463,13 @@ state = txGetInitStatus(); break; case TEENSY_CMD_UPDATE_EEPROM_DATA: - state = txUpdateEEPROMdata( eePromDataTX ); + state = txUpdateEEPROMdata( ); break; case TEENSY_CMD_GET_EEPROM_DATA: state = txGetEEPROMdata(); break; case TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS: - state = txUpdateMeasurementSettings( measurementSettingsTX ); + state = txUpdateMeasurementSettings( ); break; case TEENSY_CMD_GET_MEASUREMENT_SETTINGS: state = txGetMeasurementSettings(); @@ -758,7 +841,7 @@ * 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 U08 *buffer, U32 len) { CONDUCTIVITY_PARSE_STATUS parseStatus = CONDUCTIVITY_PARSE_NONE; U32 expectedDataLength = sizeof(CONDUCTIVITY_MEASUREMENT_SETTINGS_T); @@ -775,7 +858,7 @@ else { // Parse and store the data - memcpy(&conductivityMeasurementSettings, buffer, expectedDataLength); + memcpy(&measurementSettingsRX, buffer, expectedDataLength); parseStatus = CONDUCTIVITY_PARSE_SUCCESS; } @@ -792,7 +875,7 @@ * 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 U08 *buffer, U32 len) { CONDUCTIVITY_PARSE_STATUS parseStatus = CONDUCTIVITY_PARSE_NONE; U32 expectedDataLength = sizeof(CONDUCTIVITY_EEPROM_DATA_T); @@ -810,7 +893,7 @@ else { // Parse and Store the data - memcpy(&conductivityEEPROMdata, buffer, expectedDataLength); + memcpy(&eePromDataRX, buffer, expectedDataLength); parseStatus = CONDUCTIVITY_PARSE_SUCCESS; } @@ -827,20 +910,17 @@ * 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 U08 *buffer, U32 len) { CONDUCTIVITY_PARSE_STATUS parseStatus = CONDUCTIVITY_PARSE_NONE; - U32 expectedDataLength = sizeof(CONDUCTIVITY_SENSOR_DATA_T); - U32 sensorCount = 0; - U16 sensorIdx = 0; // Validate buffer - if (buffer == NULL) + if ( NULL == buffer ) { - parseStatus = CONDUCTIVITY_PARSE_ERROR_NULL_BUFFER; + parseStatus = CONDUCTIVITY_PARSE_ERROR_INVALID_SENSOR_NUM; } // Validate buffer length - else if ((len % expectedDataLength) != 0) + else if ( ( len % expectedDataLength ) != 0 ) { parseStatus = CONDUCTIVITY_PARSE_ERROR_INVALID_LENGTH; } @@ -850,14 +930,14 @@ 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 ); // Check if the received sensor number is valid - if ((tempSensor.sensorNum < 1) || (tempSensor.sensorNum > MAX_TEENSY_SENSOR)) + if ( ( tempSensor.sensorNum < 1 ) || ( tempSensor.sensorNum > MAX_TEENSY_SENSOR ) ) { parseStatus = CONDUCTIVITY_PARSE_ERROR_INVALID_SENSOR_NUM; break; @@ -904,7 +984,7 @@ { written = snprintf( (char*)condTxBuffer, COND_TX_BUFFER_LEN, - "%s %s", + "%s,%s", (const char*)baseCmd, (const char*)param ); } @@ -919,6 +999,7 @@ if ( written > 0 ) { + memset( &condWriteCmdBuffer, 0, COND_WRITE_CMD_BUFFER_LEN ); memcpy( &condWriteCmdBuffer, &condTxBuffer, written ); success = TRUE; } @@ -947,8 +1028,10 @@ // Clear the read buffer before writing memset( &condRxBuffer, 0, COND_RX_BUFFER_LEN ); memcpy( &condRxBuffer, &condWriteResponseBuffer, teensyCmdMap[ cmdIndex ].rxSize ); + memset( &condWriteResponseBuffer, 0, COND_WRITE_RSP_BUFFER_LEN ); success = TRUE; } + // Should not be any data received at this time consumeUnexpectedConductivityData(); @@ -964,10 +1047,13 @@ { // Get the current time condResponseTime = getMSTimerCount(); + + // Go to receive state to receive the init status state = COND_COMM_STATE_RX; } else { + // Go to failed state state = COND_COMM_STATE_FAILED; } @@ -978,16 +1064,22 @@ static CONDUCTIVITY_COMM_STATE_T rxInitSensor( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; - CONDUCTIVITY_INIT_STATUS_T initStatusFirstByte = CONDUCTIVITY_INIT_STATUS_FAILED; // set to fail for testing - CONDUCTIVITY_INIT_STATUS_T initStatusSecondByte = CONDUCTIVITY_INIT_STATUS_FAILED; // if data populates + CONDUCTIVITY_INIT_STATUS_T initStatusInProgress = CONDUCTIVITY_INIT_STATUS_FAILED; // set to fail for testing + CONDUCTIVITY_INIT_STATUS_T initStatusInitialized = CONDUCTIVITY_INIT_STATUS_FAILED; // if data populates BOOL recvComplete = rxTeensyReadRsp( TEENSY_CMD_INIT_SENSOR ); if ( TRUE == recvComplete ) { - initStatusFirstByte = (CONDUCTIVITY_INIT_STATUS_T)condRxBuffer[0]; - initStatusSecondByte = (CONDUCTIVITY_INIT_STATUS_T)condRxBuffer[1]; + // Reset the timer for next use. + condResponseTime = 0; + // Read the data from the receive buffer + initStatusInProgress = (CONDUCTIVITY_INIT_STATUS_T)condRxBuffer[0]; + initStatusInitialized = (CONDUCTIVITY_INIT_STATUS_T)condRxBuffer[1]; - switch(initStatusSecondByte) + // Store the init status + conductivityInitStatus = initStatusInitialized; + + switch( conductivityInitStatus ) { case CONDUCTIVITY_INIT_STATUS_UNITIALIZED: break; @@ -1002,14 +1094,19 @@ case CONDUCTIVITY_INIT_STATUS_FAILED: default: - state = COND_COMM_STATE_FAILED; + state = COND_COMM_STATE_IDLE; break; } } else if ( TRUE == didTimeout( condResponseTime, COND_STATUS_TIMEOUT_MS ) ) { + // Go to failed state state = COND_COMM_STATE_FAILED; } + else + { + // Do Nothing. Wait until we either receive a response OR timeout happens. + } return state; } @@ -1021,10 +1118,15 @@ // If the get init status cmd was sent successfully if ( TRUE == txTeensyWriteCmd( TEENSY_CMD_GET_INIT_STATUS, NULL ) ) { + // Get the current time + condResponseTime = getMSTimerCount(); + + // Go to receive state to receive the init status state = COND_COMM_STATE_RX; } else { + // Go to failed state state = COND_COMM_STATE_FAILED; } @@ -1034,41 +1136,52 @@ static CONDUCTIVITY_COMM_STATE_T rxGetInitStatus( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; - CONDUCTIVITY_INIT_STATUS_T initStatus = CONDUCTIVITY_INIT_STATUS_UNITIALIZED; - BOOL recvComplete = rxTeensyReadRsp( TEENSY_CMD_INIT_SENSOR ); + // Check if a response is received in the RX buffer + BOOL recvComplete = rxTeensyReadRsp( TEENSY_CMD_GET_INIT_STATUS ); if ( TRUE == recvComplete ) { - initStatus = (CONDUCTIVITY_INIT_STATUS_T)condRxBuffer[0]; + // Reset the timer for next use. + condResponseTime = 0; + + // Read the data from the receive buffer + memcpy(&conductivityInitStatus, &condRxBuffer, teensyCmdMap[ TEENSY_CMD_GET_INIT_STATUS ].rxSize); +// conductivityInitStatus = (CONDUCTIVITY_INIT_STATUS_T)condRxBuffer[0]; + + switch(conductivityInitStatus) + { + case CONDUCTIVITY_INIT_STATUS_UNITIALIZED: + break; + + case CONDUCTIVITY_INIT_STATUS_IN_PROGRESS: + state = COND_COMM_STATE_IDLE; + break; + + case CONDUCTIVITY_INIT_STATUS_INITIALIZED: + state = COND_COMM_STATE_IDLE; + break; + + case CONDUCTIVITY_INIT_STATUS_FAILED: + default: + state = COND_COMM_STATE_IDLE; + break; + } } + else if ( TRUE == didTimeout( condResponseTime, COND_STATUS_TIMEOUT_MS ) ) { + // Go to failed state state = COND_COMM_STATE_FAILED; } - - switch(initStatus) + else { - case CONDUCTIVITY_INIT_STATUS_UNITIALIZED: - break; - - case CONDUCTIVITY_INIT_STATUS_IN_PROGRESS: - state = COND_COMM_STATE_IDLE; - break; - - case CONDUCTIVITY_INIT_STATUS_INITIALIZED: - state = COND_COMM_STATE_IDLE; - break; - - case CONDUCTIVITY_INIT_STATUS_FAILED: - default: - state = COND_COMM_STATE_FAILED; - break; + // Do Nothing. Wait until we either receive a response OR timeout happens. } return state; } -static CONDUCTIVITY_COMM_STATE_T txUpdateEEPROMdata( CONDUCTIVITY_EEPROM_DATA_T eepromData ) +static CONDUCTIVITY_COMM_STATE_T txUpdateEEPROMdata( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; @@ -1077,20 +1190,21 @@ U16 offset = 0; U16 i = 0; + // Pack the command and EEPROM data for ( i = 0; i < DOUBLE_COUNT; ++i ) { offset += snprintf( (char*)(paramStr + offset), sizeof(paramStr) - offset, "%.6f,", - eepromData.doubleValue[i] ); + eePromDataTX.doubleValue[i] ); } for ( i = 0; i < FLOAT_COUNT; ++i ) { offset += snprintf( (char*)(paramStr + offset), sizeof(paramStr) - offset, "%.6f,", - eepromData.floatValue[i] ); + eePromDataTX.floatValue[i] ); } // Remove trailing comma if needed @@ -1099,12 +1213,18 @@ paramStr[ offset - 1 ] = '\0'; } + // Transmit the command and the EEPROM data and check if it was sent successfully if ( TRUE == txTeensyWriteCmd( TEENSY_CMD_UPDATE_EEPROM_DATA, paramStr ) ) { + // Get the current time + condResponseTime = getMSTimerCount(); + + // Go to receive state to receive the EEPROM update status state = COND_COMM_STATE_RX; } else { + // Go to failed state state = COND_COMM_STATE_FAILED; } @@ -1114,22 +1234,50 @@ static CONDUCTIVITY_COMM_STATE_T rxUpdateEEPROMdata( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; - condUpdateEEPROMstatus = ( CONDUCTIVITY_UPDATE_EEPROM_STATUS_T )condTxBuffer[ 0 ]; - state = COND_COMM_STATE_IDLE; + + // Check if a response is received in the RX buffer + BOOL recvComplete = rxTeensyReadRsp( TEENSY_CMD_UPDATE_EEPROM_DATA ); + if ( TRUE == recvComplete ) + { + // Reset the timer for next use. + condResponseTime = 0; + + // Read the data from the receive buffer + memcpy(&condUpdateEEPROMstatus, &condRxBuffer, teensyCmdMap[ TEENSY_CMD_UPDATE_EEPROM_DATA ].rxSize); +// condUpdateEEPROMstatus = (CONDUCTIVITY_UPDATE_EEPROM_STATUS_T)condRxBuffer[0]; + + // Go to the idle state to execute next cmd in the queue + state = COND_COMM_STATE_IDLE; + } + else if ( TRUE == didTimeout( condResponseTime, COND_STATUS_TIMEOUT_MS ) ) + { + // Go to failed state + state = COND_COMM_STATE_FAILED; + } + else + { + // Do Nothing. Wait until we either receive a response OR timeout happens. + } + return state; } static CONDUCTIVITY_COMM_STATE_T txGetEEPROMdata( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; - if ( TRUE == rxTeensyReadRsp( TEENSY_CMD_GET_EEPROM_DATA ) ) + // If the get EEPROM data cmd was sent successfully + if ( TRUE == txTeensyWriteCmd( TEENSY_CMD_GET_EEPROM_DATA, NULL ) ) { - state = COND_COMM_STATE_RX; + // Get the current time + condResponseTime = getMSTimerCount(); + // Go to receive state to receive the EEPROM data + state = COND_COMM_STATE_RX; } else { + // Go to failed state state = COND_COMM_STATE_FAILED; } @@ -1139,33 +1287,72 @@ static CONDUCTIVITY_COMM_STATE_T rxGetEEPROMdata( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; - CONDUCTIVITY_PARSE_STATUS parseStatus = parseEEPROMdata( condRxBuffer, COND_RX_BUFFER_LEN ); + CONDUCTIVITY_PARSE_STATUS parseStatus = CONDUCTIVITY_PARSE_NONE; state = COND_COMM_STATE_IDLE; + + // Check if a response is received in the RX buffer + BOOL recvComplete = rxTeensyReadRsp( TEENSY_CMD_GET_EEPROM_DATA ); + if ( TRUE == recvComplete ) + { + // Reset the timer for next use. + condResponseTime = 0; + + // Read the data from the receive buffer + memcpy(&eePromDataRX, &condRxBuffer, teensyCmdMap[ TEENSY_CMD_GET_EEPROM_DATA ].rxSize); +// parseStatus = parseEEPROMdata( condRxBuffer, COND_RX_BUFFER_LEN ); + + // Check if parsing was done successfully + if(CONDUCTIVITY_PARSE_SUCCESS == parseStatus) + { + // Go to the idle state to execute next cmd in the queue + state = COND_COMM_STATE_IDLE; + } + else + { + // Go to failed state + state = COND_COMM_STATE_FAILED; + } + } + else if ( TRUE == didTimeout( condResponseTime, COND_DATA_TIMEOUT_MS ) ) + { + // Go to failed state + state = COND_COMM_STATE_FAILED; + } + else + { + // Do Nothing. Wait until we either receive a response OR timeout happens. + } + return state; } -static CONDUCTIVITY_COMM_STATE_T txUpdateMeasurementSettings( CONDUCTIVITY_MEASUREMENT_SETTINGS_T measurementSettings ) +static CONDUCTIVITY_COMM_STATE_T txUpdateMeasurementSettings( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; - - // Format measurement settings into a string U08 paramStr[128]; - snprintf( (char*)paramStr, sizeof(paramStr), "%.3f,%.3f,%.3f,%u,%u,%u,%u", - measurementSettings.SinFreq, - measurementSettings.DacVoltPP, - measurementSettings.BiasVolt, - measurementSettings.HstiaRtiaSel, - measurementSettings.AdcPgaGain, - measurementSettings.DftNum, - measurementSettings.ADCAvgNum ); + snprintf( ( char * )paramStr, sizeof( paramStr ), + "%.4f,%.4f,%.4f,%lu,%lu,%lu,%lu", + measurementSettingsTX.SinFreq, + measurementSettingsTX.DacVoltPP, + measurementSettingsTX.BiasVolt, + measurementSettingsTX.HstiaRtiaSel, + measurementSettingsTX.AdcPgaGain, + measurementSettingsTX.DftNum, + measurementSettingsTX.ADCAvgNum ); + // If update measurement settings cmd was sent successfully if ( TRUE == txTeensyWriteCmd( TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS, paramStr ) ) { + // Get the current time + condResponseTime = getMSTimerCount(); + + // Go to receive state to receive the EEPROM data state = COND_COMM_STATE_RX; } else { + // Go to failed state state = COND_COMM_STATE_FAILED; } @@ -1175,21 +1362,51 @@ static CONDUCTIVITY_COMM_STATE_T rxUpdateMeasurementSettings( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; - condUpdateMeasurementSettings = ( CONDUCTIVITY_UPDATE_MST_STATUS_T )condTxBuffer[0]; - state = COND_COMM_STATE_IDLE; + + // Check if a response is received in the RX buffer + BOOL recvComplete = rxTeensyReadRsp( TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS ); + if ( TRUE == recvComplete ) + { + // Reset the timer for next use. + condResponseTime = 0; + + // Read the data from the receive buffer + memcpy(&condUpdateSettingStatus, &condRxBuffer, teensyCmdMap[ TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS ].rxSize); +// updateSettingStatus = ( CONDUCTIVITY_UPDATE_MST_STATUS_T )condTxBuffer[0]; + + // Move to TX state to update the next param. + state = COND_COMM_STATE_TX; + + } + else if ( TRUE == didTimeout( condResponseTime, COND_STATUS_TIMEOUT_MS ) ) + { + // Go to failed state + state = COND_COMM_STATE_FAILED; + } + else + { + // Do Nothing. Wait until we either receive a response OR timeout happens. + } + return state; } static CONDUCTIVITY_COMM_STATE_T txGetMeasurementSettings( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; - if ( TRUE == rxTeensyReadRsp( TEENSY_CMD_GET_MEASUREMENT_SETTINGS ) ) + // If get measurement settings cmd was sent successfully + if ( TRUE == txTeensyWriteCmd( TEENSY_CMD_GET_MEASUREMENT_SETTINGS, NULL ) ) { + // Get the current time + condResponseTime = getMSTimerCount(); + + // Go to receive state to receive the EEPROM data state = COND_COMM_STATE_RX; } else { + // Go to failed state state = COND_COMM_STATE_FAILED; } @@ -1199,22 +1416,61 @@ static CONDUCTIVITY_COMM_STATE_T rxGetMeasurementSettings( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; - CONDUCTIVITY_PARSE_STATUS parseStatus = parseMeasurementSettings( condRxBuffer, COND_RX_BUFFER_LEN ); + CONDUCTIVITY_PARSE_STATUS parseStatus = CONDUCTIVITY_PARSE_NONE; state = COND_COMM_STATE_IDLE; + // Check if a response is received in the RX buffer + BOOL recvComplete = rxTeensyReadRsp( TEENSY_CMD_GET_MEASUREMENT_SETTINGS ); + if ( TRUE == recvComplete ) + { + // Reset the timer for next use. + condResponseTime = 0; + + // Read the data from the receive buffer + memcpy(&measurementSettingsRX, &condRxBuffer, teensyCmdMap[ TEENSY_CMD_GET_MEASUREMENT_SETTINGS ].rxSize); +// parseStatus = parseMeasurementSettings( condRxBuffer, COND_RX_BUFFER_LEN ); + + // Check if parsing was done successfully + if(CONDUCTIVITY_PARSE_SUCCESS == parseStatus) + { + // Go to the idle state to execute next cmd in the queue + state = COND_COMM_STATE_IDLE; + } + else + { + // Go to failed state + state = COND_COMM_STATE_FAILED; + } + } + else if ( TRUE == didTimeout( condResponseTime, COND_DATA_TIMEOUT_MS ) ) + { + // Go to failed state + state = COND_COMM_STATE_FAILED; + } + else + { + // Do Nothing. Wait until we either receive a response OR timeout happens. + } + return state; } static CONDUCTIVITY_COMM_STATE_T txGetMeasurements( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; - if ( TRUE == rxTeensyReadRsp( TEENSY_CMD_GET_MEASUREMENT ) ) + // If get measurement settings cmd was sent successfully + if ( TRUE == txTeensyWriteCmd( TEENSY_CMD_GET_MEASUREMENT, NULL ) ) { + // Get the current time + condResponseTime = getMSTimerCount(); + + // Go to receive state to receive the measurement data state = COND_COMM_STATE_RX; } else { + // Go to failed state state = COND_COMM_STATE_FAILED; } return state; @@ -1223,75 +1479,187 @@ static CONDUCTIVITY_COMM_STATE_T rxGetMeasurements( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; - CONDUCTIVITY_PARSE_STATUS parseStatus = parseConductivityMeasurements( condRxBuffer, COND_RX_BUFFER_LEN ); - state = COND_COMM_STATE_IDLE; + CONDUCTIVITY_PARSE_STATUS parseStatus; + + // Check if a response is received in the RX buffer + BOOL recvComplete = rxTeensyReadRsp( TEENSY_CMD_GET_MEASUREMENT ); + if ( TRUE == recvComplete ) + { + // Get the time stamp for next sensor packet + condResponseTime = getMSTimerCount(); + + // Read the data from the receive buffer + CONDUCTIVITY_PARSE_STATUS parseStatus = parseConductivityMeasurements( condRxBuffer, COND_RX_BUFFER_LEN ); + + // Check if parsing was done successfully + if( CONDUCTIVITY_PARSE_SUCCESS == parseStatus ) + { + // Go to the idle state to execute next cmd in the queue + state = COND_COMM_STATE_IDLE; + } + else + { + // Go to failed state + state = COND_COMM_STATE_FAILED; + } + } + else if ( TRUE == didTimeout( condResponseTime, COND_DATA_TIMEOUT_MS ) ) + { + // Go to failed state + state = COND_COMM_STATE_FAILED; + } + else + { + // Do Nothing. Wait until we either receive a response OR timeout happens. + } + return state; } -static void txStopMeasurement( void ) +static CONDUCTIVITY_COMM_STATE_T txStopMeasurement( void ) { + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; - if ( FALSE == rxTeensyReadRsp( TEENSY_CMD_STOP_MEASUREMENT ) ) + if ( TRUE == txTeensyWriteCmd( TEENSY_CMD_STOP_MEASUREMENT, NULL ) ) { - // Handle error + } + + return state; } -static void rxStopMeasurement( void ) +static CONDUCTIVITY_COMM_STATE_T rxStopMeasurement( void ) { - - // condReadResponseBuffer + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; + return state; } -static void txGetAllMeasurements( void ) +static CONDUCTIVITY_COMM_STATE_T txGetAllMeasurements( void ) { + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; - if ( FALSE == rxTeensyReadRsp( TEENSY_CMD_GET_ALL_MEASUREMENTS ) ) + if ( TRUE == txTeensyWriteCmd( TEENSY_CMD_GET_ALL_MEASUREMENTS, NULL ) ) { - // Handle error + // Get the current time + condResponseTime = getMSTimerCount(); } + return state; } -static void rxGetAllMeasurements( void ) +static CONDUCTIVITY_COMM_STATE_T rxGetAllMeasurements( void ) { + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; - // condReadResponseBuffer + // Check if a response is received in the RX buffer + BOOL recvComplete = rxTeensyReadRsp( TEENSY_CMD_GET_ALL_MEASUREMENTS ); + if ( TRUE == recvComplete ) + { + // Reset the timer for next use. + condResponseTime = 0; + // Read the data from the receive buffer + CONDUCTIVITY_PARSE_STATUS parseStatus = parseConductivityMeasurements( condRxBuffer, COND_RX_BUFFER_LEN ); + + // Check if parsing was done successfully + if(CONDUCTIVITY_PARSE_SUCCESS == parseStatus) + { + // Go to the idle state to execute next cmd in the queue + state = COND_COMM_STATE_IDLE; + } + else + { + // Go to failed state + state = COND_COMM_STATE_FAILED; + } + } + else if ( TRUE == didTimeout( condResponseTime, COND_DATA_TIMEOUT_MS ) ) + { + // Go to failed state + state = COND_COMM_STATE_FAILED; + } + else + { + // Do Nothing. Wait until we either receive a response OR timeout happens. + } + + return state; } -static void txSelectSensor( TEENSY_SENSOR_INDEX_T sensorNum ) +static CONDUCTIVITY_COMM_STATE_T txSelectSensor( TEENSY_SENSOR_INDEX_T sensorNum ) { + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; + U08 paramStr[8]; snprintf( (char*)paramStr, sizeof(paramStr), "%d", sensorNum ); - if ( FALSE == txTeensyWriteCmd( TEENSY_CMD_SELECT_SENSOR, paramStr ) ) + if ( TRUE == txTeensyWriteCmd( TEENSY_CMD_SELECT_SENSOR, paramStr ) ) { - // Handle error + } + + return state; } -static void rxSelectSensor( TEENSY_SENSOR_INDEX_T sensorNum ) +static CONDUCTIVITY_COMM_STATE_T rxSelectSensor( TEENSY_SENSOR_INDEX_T sensorNum ) { - // condWriteResponseBuffer + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; + return state; } -static void txGetSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ) +static CONDUCTIVITY_COMM_STATE_T txGetSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ) { + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; // Assumes sensor has already been selected - if ( FALSE == rxTeensyReadRsp( TEENSY_CMD_GET_SINGLE_MEASUREMENT ) ) + if ( TRUE == txTeensyWriteCmd( TEENSY_CMD_GET_SINGLE_MEASUREMENT, NULL ) ) { - // Handle error + // Get the current time + condResponseTime = getMSTimerCount(); } + + return state; } -static void rxGetSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ) +static CONDUCTIVITY_COMM_STATE_T rxGetSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ) { + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; - // condReadResponseBuffer + // Check if a response is received in the RX buffer + BOOL recvComplete = rxTeensyReadRsp( TEENSY_CMD_GET_SINGLE_MEASUREMENT ); + if ( TRUE == recvComplete ) + { + // Reset the timer for next use. + condResponseTime = 0; + + // Read the data from the receive buffer + CONDUCTIVITY_PARSE_STATUS parseStatus = parseConductivityMeasurements( condRxBuffer, COND_RX_BUFFER_LEN ); + + // Check if parsing was done successfully + if(CONDUCTIVITY_PARSE_SUCCESS == parseStatus) + { + // Go to the idle state to execute next cmd in the queue + state = COND_COMM_STATE_IDLE; + } + else + { + // Go to failed state + state = COND_COMM_STATE_FAILED; + } + } + else if ( TRUE == didTimeout( condResponseTime, COND_DATA_TIMEOUT_MS ) ) + { + // Go to failed state + state = COND_COMM_STATE_FAILED; + } + else + { + // Do Nothing. Wait until we either receive a response OR timeout happens. + } + + return state; } static void calculateConductivity( TEENSY_SENSOR_INDEX_T sensorNum )