Index: firmware/App/Drivers/ConductivityTeensy.c =================================================================== diff -u -r424859ea9121940514b9415fe5a15ae1882825a6 -rf135c526491ca9a69fe1b1b5334e52109b861ebd --- firmware/App/Drivers/ConductivityTeensy.c (.../ConductivityTeensy.c) (revision 424859ea9121940514b9415fe5a15ae1882825a6) +++ firmware/App/Drivers/ConductivityTeensy.c (.../ConductivityTeensy.c) (revision f135c526491ca9a69fe1b1b5334e52109b861ebd) @@ -23,24 +23,35 @@ #include "Comm.h" #include "ConductivityTeensy.h" +#include "Timers.h" -#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 SCI_RECEIVE_DMA_REQUEST 30 ///< Serial port receive DMA request line. +#define SCI_TRANSMIT_DMA_REQUEST 31 ///< Serial port transmit DMA request line. -#define COND_WRITE_CMD_BUFFER_LEN 256 ///< Conductivity write command buffer byte length. -#define COND_WRITE_RSP_BUFFER_LEN 8 ///< Conductivity write command response buffer byte length. -#define COND_READ_CMD_BUFFER_LEN 8 ///< Conductivity read command buffer byte length. -#define COND_READ_RSP_BUFFER_LEN 256 ///< Conductivity read command response buffer byte length. +#define COND_CMD_Q_LEN 8 ///< Maximum number of cmds that can be queue'd. +#define QUEUE_START_INDEX 0U ///< Queue start index. -#define COND_CMD_Q_LEN 8 ///< Maximum number of cmds that can be queue'd. -#define QUEUE_START_INDEX 0U ///< Queue start index. +#define COND_WRITE_CMD_BUFFER_LEN 256 ///< Conductivity transmit buffer length in bytes. +#define COND_WRITE_RSP_BUFFER_LEN 256 ///< Conductivity receive buffer length in bytes. -#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. -//#define COND_TX_BUFFER_LEN 256 ///< Conductivity transmit buffer length in bytes. -//#define COND_RX_BUFFER_LEN 256 ///< Conductivity receive buffer length in bytes. +#define RX_SIZE_INIT_SENSOR 2 +#define RX_SIZE_GET_INIT_STATUS 1 +#define RX_SIZE_UPDATE_EEPROM 1 +#define RX_SIZE_GET_EEPROM ( sizeof( CONDUCTIVITY_EEPROM_DATA_T ) ) +#define RX_SIZE_UPDATE_MEASUREMENT_SETTINGS 1 +#define RX_SIZE_GET_MEASUREMENT_SETTNGS ( sizeof( CONDUCTIVITY_MEASUREMENT_SETTINGS_T ) ) +#define RX_SIZE_GET_MEASUREMENT ( sizeof( CONDUCTIVITY_SENSOR_DATA_T ) ) +#define RX_SIZE_STOP_MEASUREMENT 1 +#define RX_SIZE_GET_ALL_MEASUREMENTS ( 6 * RX_SIZE_GET_MEASUREMENT ) +#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_DATA_TIMEOUT_MS ( 5 * MS_PER_SECOND ) ///< Timeout before which we should receive INIT_STATUS_INITIALIZED or INIT_STATUS_FAILED from teensy + // ********** private data ********** static CONDUCTIVITY_COMM_STATE_T conductivityCommState = COND_COMM_STATE_IDLE; static CONDUCTIVITY_COMM_STATE_T currentFailedState = COND_COMM_STATE_IDLE; @@ -58,18 +69,19 @@ // Conductivity comm buffers static U08 condWriteCmdBuffer[ COND_WRITE_CMD_BUFFER_LEN ]; ///< Conductivity write command buffer. Holds the next Conductivity write command to be transmitted. static U08 condWriteResponseBuffer[ COND_WRITE_RSP_BUFFER_LEN ]; ///< Conductivity write command response buffer. Memory reserved to capture the response to the last Conductivity write command. -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 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 +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; +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. @@ -79,27 +91,37 @@ static CONDUCTIVITY_INIT_STATUS_T conductivityInitStatus; static CONDUCTIVITY_UPDATE_EEPROM_STATUS_T condUpdateEEPROMstatus; -static CONDUCTIVITY_UPDATE_MST_STATUS_T condUpdateMeasurementSettings; +static CONDUCTIVITY_UPDATE_MST_STATUS_T condUpdateSettingStatus[MAX_CONDUCTIVITY_MST_PARAM_IDX]; static CONDUCTIVITY_EEPROM_DATA_T conductivityEEPROMdata; static CONDUCTIVITY_MEASUREMENT_SETTINGS_T conductivityMeasurementSettings; static CONDUCTIVITY_SENSOR_DATA_T rawConductivityValues[ MAX_TEENSY_SENSOR ]; static CONDUCTIVITY_CALCULATED_MEASUREMENTS_T calculatedMeasurement[ MAX_TEENSY_SENSOR ]; static CONDUCTIVITY_COEFFICIENTS_T conductivityCoeff[MAX_TEENSY_SENSOR]; static const CONDUCTIVITY_CMD_DATA_T teensyCmdMap[] = { - { TEENSY_CMD_INIT_SENSOR , (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" }, +// 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*)"upe" , RX_SIZE_UPDATE_EEPROM }, + { TEENSY_CMD_GET_EEPROM_DATA , (U08*)"e" , RX_SIZE_GET_EEPROM }, + { 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 }, + { TEENSY_CMD_GET_ALL_MEASUREMENTS , (U08*)"g" , RX_SIZE_GET_ALL_MEASUREMENTS }, + { TEENSY_CMD_SELECT_SENSOR , (U08*)"j" , RX_SIZE_SELECT_SENSOR }, + { 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; @@ -130,12 +152,12 @@ 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 txTeensyReadCmd( TEENSY_CMD_INDEX_T cmdIndex ); +static BOOL rxTeensyReadRsp( TEENSY_CMD_INDEX_T cmdIndex ); static CONDUCTIVITY_COMM_STATE_T txInitSensor( void ); static CONDUCTIVITY_COMM_STATE_T rxInitSensor( void ); @@ -158,17 +180,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 ); @@ -188,15 +210,112 @@ condResponseTime = 0; // initialize Conductivity comm buffers +// memset( &condWriteCmdBuffer, 0, COND_WRITE_CMD_BUFFER_LEN ); +// memset( &condReadCmdBuffer, 0, COND_READ_CMD_BUFFER_LEN ); + + memset( &condTxBuffer, 0, COND_TX_BUFFER_LEN ); + memset( &condRxBuffer, 0, COND_RX_BUFFER_LEN ); + + initConductivityDMAchannels(); + + // add init conductivity commands + enqueue( TEENSY_CMD_INIT_SENSOR ); + enqueue( TEENSY_CMD_GET_INIT_STATUS ); + currentSettingParam = CONDUCTIVITY_MST_PARAM_IDX_SINFREQ; + enqueue( TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS ); +} + +static void initConductivityDMAchannels( void ) +{ + 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 ); + // Enable interrupt notifications for FPGA serial port + sciEnableNotification( sciREG, SCI_OE_INT | SCI_FE_INT ); + // Assign DMA channels to h/w DMA requests + dmaReqAssign( DMA_CH1, SCI_RECEIVE_DMA_REQUEST ); + dmaReqAssign( DMA_CH3, SCI_TRANSMIT_DMA_REQUEST ); + // Set DMA channel priorities + dmaSetPriority( DMA_CH1, HIGHPRIORITY ); + dmaSetPriority( DMA_CH3, LOWPRIORITY ); + // Enable DMA block transfer complete interrupts + dmaEnableInterrupt( DMA_CH1, BTC ); + dmaEnableInterrupt( DMA_CH3, BTC ); -// memset( &condTxBuffer, 0, COND_TX_BUFFER_LEN ); -// memset( &condRxBuffer, 0, COND_RX_BUFFER_LEN ); + // Initialize Conductivity DMA Write Control Record + condDMAWriteControlRecord.PORTASGN = 4; // Port B (only choice per datasheet) + condDMAWriteControlRecord.SADD = (U32)condWriteCmdBuffer; // Transfer source address + condDMAWriteControlRecord.DADD = (U32)(&(sciREG->TD)); // Dest. is SCI xmit register + condDMAWriteControlRecord.CHCTRL = 0; // No chaining + condDMAWriteControlRecord.ELCNT = 1; // Frame is 1 element + condDMAWriteControlRecord.FRCNT = 0; // Block is TBD frames - will be populated later when known + condDMAWriteControlRecord.RDSIZE = ACCESS_8_BIT; // Element size is 1 byte for read + condDMAWriteControlRecord.WRSIZE = ACCESS_8_BIT; // Element size is 1 byte for write + condDMAWriteControlRecord.TTYPE = FRAME_TRANSFER; // Transfer type is block transfer + condDMAWriteControlRecord.ADDMODERD = ADDR_INC1; // Source addressing mode is post-increment + condDMAWriteControlRecord.ADDMODEWR = ADDR_FIXED; // Dest. addressing mode is fixed + condDMAWriteControlRecord.AUTOINIT = AUTOINIT_OFF; // Auto-init off + condDMAWriteControlRecord.ELSOFFSET = 0; // Not used + condDMAWriteControlRecord.ELDOFFSET = 0; // Not used + condDMAWriteControlRecord.FRSOFFSET = 0; // Not used + condDMAWriteControlRecord.FRDOFFSET = 0; // Not used - initConductivityDMAchannels(); + // Initialize Conductivity DMA Write Response Control Record + condDMAWriteRespControlRecord.PORTASGN = 4; // Port B (only choice per datasheet) + condDMAWriteRespControlRecord.SADD = (U32)(&(sciREG->RD)); // Source is SCI recv register + condDMAWriteRespControlRecord.DADD = (U32)condWriteResponseBuffer; // Transfer destination address + condDMAWriteRespControlRecord.CHCTRL = 0; // No chaining + condDMAWriteRespControlRecord.ELCNT = 1; // Frame is 1 element + condDMAWriteRespControlRecord.FRCNT = 0; // Block is TBD frames - will be populated later when known + condDMAWriteRespControlRecord.RDSIZE = ACCESS_8_BIT; // Element size is 1 byte + condDMAWriteRespControlRecord.WRSIZE = ACCESS_8_BIT; // + condDMAWriteRespControlRecord.TTYPE = FRAME_TRANSFER; // Transfer type is block transfer + condDMAWriteRespControlRecord.ADDMODERD = ADDR_FIXED; // Source addressing mode is fixed + condDMAWriteRespControlRecord.ADDMODEWR = ADDR_INC1; // Dest. addressing mode is post-increment + condDMAWriteRespControlRecord.AUTOINIT = AUTOINIT_OFF; // Auto-init off + condDMAWriteRespControlRecord.ELDOFFSET = 0; // Not used + condDMAWriteRespControlRecord.ELSOFFSET = 0; // Not used + condDMAWriteRespControlRecord.FRDOFFSET = 0; // Not used + condDMAWriteRespControlRecord.FRSOFFSET = 0; // Not used + +// // Initialize Conductivity DMA Read Control RecordfpgaReadCmdBuffer +// condDMAReadControlRecord.PORTASGN = 4; // Port B (only choice per datasheet) +// condDMAReadControlRecord.SADD = (U32)condRxBuffer; // Transfer source address +// condDMAReadControlRecord.DADD = (U32)(&(sciREG->TD)); // Dest. is SCI xmit register +// condDMAReadControlRecord.CHCTRL = 0; // No chaining +// condDMAReadControlRecord.ELCNT = 1; // Frame is 1 element +// condDMAReadControlRecord.FRCNT = 0; // Block is TBD frames - will be populated later when known +// condDMAReadControlRecord.RDSIZE = ACCESS_8_BIT; // Element size is 1 byte +// condDMAReadControlRecord.WRSIZE = ACCESS_8_BIT; // +// condDMAReadControlRecord.TTYPE = FRAME_TRANSFER; // Transfer type is block transfer +// condDMAReadControlRecord.ADDMODERD = ADDR_INC1; // Source addressing mode is post-increment +// condDMAReadControlRecord.ADDMODEWR = ADDR_FIXED; // Dest. addressing mode is fixed +// condDMAReadControlRecord.AUTOINIT = AUTOINIT_OFF; // Auto-init off +// condDMAReadControlRecord.ELSOFFSET = 0; // Not used +// condDMAReadControlRecord.ELDOFFSET = 0; // Not used +// condDMAReadControlRecord.FRSOFFSET = 0; // Not used +// condDMAReadControlRecord.FRDOFFSET = 0; // Not used +// +// // Initialize Conductivity DMA Read Response Control Record +// condDMAReadRespControlRecord.PORTASGN = 4; // Port B (only choice per datasheet) +// condDMAReadRespControlRecord.SADD = (U32)(&(sciREG->RD)); // Source is SCI recv register +// condDMAReadRespControlRecord.DADD = (U32)condRxBuffer; // Transfer destination address +// condDMAReadRespControlRecord.CHCTRL = 0; // No chaining +// condDMAReadRespControlRecord.ELCNT = 1; // Frame is 1 element +// condDMAReadRespControlRecord.FRCNT = 0; // Block is TBD frames - will be populated later when known +// condDMAReadRespControlRecord.RDSIZE = ACCESS_8_BIT; // Element size is 1 byte +// condDMAReadRespControlRecord.WRSIZE = ACCESS_8_BIT; // +// condDMAReadRespControlRecord.TTYPE = FRAME_TRANSFER; // Transfer type is block transfer +// condDMAReadRespControlRecord.ADDMODERD = ADDR_FIXED; // Source addressing mode is fixed +// condDMAReadRespControlRecord.ADDMODEWR = ADDR_INC1; // Dest. addressing mode is post-increment +// condDMAReadRespControlRecord.AUTOINIT = AUTOINIT_OFF; // Auto-init off +// condDMAReadRespControlRecord.ELDOFFSET = 0; // Not used +// condDMAReadRespControlRecord.ELSOFFSET = 0; // Not used +// condDMAReadRespControlRecord.FRDOFFSET = 0; // Not used +// condDMAReadRespControlRecord.FRSOFFSET = 0; // Not used + + // There should not be any data pending yet + consumeUnexpectedConductivityData(); } /*********************************************************************//** @@ -361,10 +480,11 @@ return state; } - static CONDUCTIVITY_COMM_STATE_T handleFailedState( void ) { - switch(currentFailedState) + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_FAILED; + + switch( state ) { case TEENSY_CMD_INIT_SENSOR: break; @@ -392,96 +512,8 @@ break; } -} - - -static void initConductivityDMAchannels( void ) -{ - // Assign DMA channels to h/w DMA requests - dmaReqAssign( DMA_CH1, SCI_RECEIVE_DMA_REQUEST ); - dmaReqAssign( DMA_CH3, SCI_TRANSMIT_DMA_REQUEST ); - // Set DMA channel priorities - dmaSetPriority( DMA_CH1, HIGHPRIORITY ); - dmaSetPriority( DMA_CH3, LOWPRIORITY ); - // Enable DMA block transfer complete interrupts - dmaEnableInterrupt( DMA_CH1, BTC ); - dmaEnableInterrupt( DMA_CH3, BTC ); - - // Initialize Conductivity DMA Write Control Record - condDMAWriteControlRecord.PORTASGN = 4; // Port B (only choice per datasheet) - condDMAWriteControlRecord.SADD = (U32)condWriteCmdBuffer; // Transfer source address - condDMAWriteControlRecord.DADD = (U32)(&(sciREG->TD)); // Dest. is SCI xmit register - condDMAWriteControlRecord.CHCTRL = 0; // No chaining - condDMAWriteControlRecord.ELCNT = 1; // Frame is 1 element - condDMAWriteControlRecord.FRCNT = 0; // Block is TBD frames - will be populated later when known - condDMAWriteControlRecord.RDSIZE = ACCESS_8_BIT; // Element size is 1 byte for read - condDMAWriteControlRecord.WRSIZE = ACCESS_8_BIT; // Element size is 1 byte for write - condDMAWriteControlRecord.TTYPE = FRAME_TRANSFER; // Transfer type is block transfer - condDMAWriteControlRecord.ADDMODERD = ADDR_INC1; // Source addressing mode is post-increment - condDMAWriteControlRecord.ADDMODEWR = ADDR_FIXED; // Dest. addressing mode is fixed - condDMAWriteControlRecord.AUTOINIT = AUTOINIT_OFF; // Auto-init off - condDMAWriteControlRecord.ELSOFFSET = 0; // Not used - condDMAWriteControlRecord.ELDOFFSET = 0; // Not used - condDMAWriteControlRecord.FRSOFFSET = 0; // Not used - condDMAWriteControlRecord.FRDOFFSET = 0; // Not used - - // Initialize Conductivity DMA Write Response Control Record - condDMAWriteRespControlRecord.PORTASGN = 4; // Port B (only choice per datasheet) - condDMAWriteRespControlRecord.SADD = (U32)(&(sciREG->RD)); // Source is SCI recv register - condDMAWriteRespControlRecord.DADD = (U32)condWriteResponseBuffer; // Transfer destination address - condDMAWriteRespControlRecord.CHCTRL = 0; // No chaining - condDMAWriteRespControlRecord.ELCNT = 1; // Frame is 1 element - condDMAWriteRespControlRecord.FRCNT = 0; // Block is TBD frames - will be populated later when known - condDMAWriteRespControlRecord.RDSIZE = ACCESS_8_BIT; // Element size is 1 byte - condDMAWriteRespControlRecord.WRSIZE = ACCESS_8_BIT; // - condDMAWriteRespControlRecord.TTYPE = FRAME_TRANSFER; // Transfer type is block transfer - condDMAWriteRespControlRecord.ADDMODERD = ADDR_FIXED; // Source addressing mode is fixed - condDMAWriteRespControlRecord.ADDMODEWR = ADDR_INC1; // Dest. addressing mode is post-increment - condDMAWriteRespControlRecord.AUTOINIT = AUTOINIT_OFF; // Auto-init off - condDMAWriteRespControlRecord.ELDOFFSET = 0; // Not used - condDMAWriteRespControlRecord.ELSOFFSET = 0; // Not used - condDMAWriteRespControlRecord.FRDOFFSET = 0; // Not used - condDMAWriteRespControlRecord.FRSOFFSET = 0; // Not used - - // Initialize Conductivity DMA Read Control Record - condDMAReadControlRecord.PORTASGN = 4; // Port B (only choice per datasheet) - condDMAReadControlRecord.SADD = (U32)condReadCmdBuffer; // Transfer source address - condDMAReadControlRecord.DADD = (U32)(&(sciREG->TD)); // Dest. is SCI xmit register - condDMAReadControlRecord.CHCTRL = 0; // No chaining - condDMAReadControlRecord.ELCNT = 1; // Frame is 1 element - condDMAReadControlRecord.FRCNT = 0; // Block is TBD frames - will be populated later when known - condDMAReadControlRecord.RDSIZE = ACCESS_8_BIT; // Element size is 1 byte - condDMAReadControlRecord.WRSIZE = ACCESS_8_BIT; // - condDMAReadControlRecord.TTYPE = FRAME_TRANSFER; // Transfer type is block transfer - condDMAReadControlRecord.ADDMODERD = ADDR_INC1; // Source addressing mode is post-increment - condDMAReadControlRecord.ADDMODEWR = ADDR_FIXED; // Dest. addressing mode is fixed - condDMAReadControlRecord.AUTOINIT = AUTOINIT_OFF; // Auto-init off - condDMAReadControlRecord.ELSOFFSET = 0; // Not used - condDMAReadControlRecord.ELDOFFSET = 0; // Not used - condDMAReadControlRecord.FRSOFFSET = 0; // Not used - condDMAReadControlRecord.FRDOFFSET = 0; // Not used - - // Initialize Conductivity DMA Read Response Control Record - condDMAReadRespControlRecord.PORTASGN = 4; // Port B (only choice per datasheet) - condDMAReadRespControlRecord.SADD = (U32)(&(sciREG->RD)); // Source is SCI recv register - condDMAReadRespControlRecord.DADD = (U32)condReadResponseBuffer; // Transfer destination address - condDMAReadRespControlRecord.CHCTRL = 0; // No chaining - condDMAReadRespControlRecord.ELCNT = 1; // Frame is 1 element - condDMAReadRespControlRecord.FRCNT = 0; // Block is TBD frames - will be populated later when known - condDMAReadRespControlRecord.RDSIZE = ACCESS_8_BIT; // Element size is 1 byte - condDMAReadRespControlRecord.WRSIZE = ACCESS_8_BIT; // - condDMAReadRespControlRecord.TTYPE = FRAME_TRANSFER; // Transfer type is block transfer - condDMAReadRespControlRecord.ADDMODERD = ADDR_FIXED; // Source addressing mode is fixed - condDMAReadRespControlRecord.ADDMODEWR = ADDR_INC1; // Dest. addressing mode is post-increment - condDMAReadRespControlRecord.AUTOINIT = AUTOINIT_OFF; // Auto-init off - condDMAReadRespControlRecord.ELDOFFSET = 0; // Not used - condDMAReadRespControlRecord.ELSOFFSET = 0; // Not used - condDMAReadRespControlRecord.FRDOFFSET = 0; // Not used - condDMAReadRespControlRecord.FRSOFFSET = 0; // Not used - - // There should not be any data pending yet - consumeUnexpectedConductivityData(); + return state; } /*********************************************************************//** @@ -516,8 +548,8 @@ condBulkWriteAndReadInProgress = FALSE; condReadCommandInProgress = TRUE; // Initiate bulk read command - startConductivityDMAReceiptOfReadResp(); - startConductivityDMAReadCmd(); + //startConductivityDMAReceiptOfReadResp(); + //startConductivityDMAReadCmd(); } } @@ -669,7 +701,7 @@ static void setupConductivityDMAForWriteCmd( U32 bytes2Transmit ) { // Verify # of bytes does not exceed buffer length - if ( bytes2Transmit <= COND_WRITE_CMD_BUFFER_LEN ) + if ( bytes2Transmit <= COND_TX_BUFFER_LEN ) { condDMAWriteControlRecord.FRCNT = bytes2Transmit; } @@ -686,7 +718,7 @@ static void setupConductivityDMAForWriteResp( U32 bytes2Receive ) { // Verify # of bytes does not exceed buffer length - if ( bytes2Receive <= COND_WRITE_RSP_BUFFER_LEN ) + if ( bytes2Receive <= COND_RX_BUFFER_LEN ) { condDMAWriteRespControlRecord.FRCNT = bytes2Receive; } @@ -699,37 +731,37 @@ setSCIDMAReceiveInterrupt(); } -static void setupConductivityDMAForReadCmd( U32 bytes2Transmit ) -{ - // Verify # of bytes does not exceed buffer length - if ( bytes2Transmit <= COND_READ_CMD_BUFFER_LEN ) - { - condDMAReadControlRecord.FRCNT = bytes2Transmit; - } -} +//static void setupConductivityDMAForReadCmd( U32 bytes2Transmit ) +//{ +// // Verify # of bytes does not exceed buffer length +// if ( bytes2Transmit <= COND_RX_BUFFER_LEN ) +// { +// condDMAReadControlRecord.FRCNT = bytes2Transmit; +// } +//} +// +//static void startConductivityDMAReadCmd( void ) +//{ +// dmaSetCtrlPacket( DMA_CH3, condDMAReadControlRecord ); +// dmaSetChEnable( DMA_CH3, DMA_HW ); +// setSCIDMATransmitInterrupt(); +//} +// +//static void setupConductivityDMAForReadResp( U32 bytes2Receive ) +//{ +// // Verify # of bytes does not exceed buffer length +// if ( bytes2Receive <= COND_RX_BUFFER_LEN ) +// { +// condDMAReadRespControlRecord.FRCNT = bytes2Receive; +// } +//} +//static void startConductivityDMAReceiptOfReadResp( void ) +//{ +// dmaSetCtrlPacket( DMA_CH1, condDMAReadRespControlRecord ); +// dmaSetChEnable( DMA_CH1, DMA_HW ); +// setSCIDMAReceiveInterrupt(); +//} -static void startConductivityDMAReadCmd( void ) -{ - dmaSetCtrlPacket( DMA_CH3, condDMAReadControlRecord ); - dmaSetChEnable( DMA_CH3, DMA_HW ); - setSCIDMATransmitInterrupt(); -} - -static void setupConductivityDMAForReadResp( U32 bytes2Receive ) -{ - // Verify # of bytes does not exceed buffer length - if ( bytes2Receive <= COND_READ_RSP_BUFFER_LEN ) - { - condDMAReadRespControlRecord.FRCNT = bytes2Receive; - } -} -static void startConductivityDMAReceiptOfReadResp( void ) -{ - dmaSetCtrlPacket( DMA_CH1, condDMAReadRespControlRecord ); - dmaSetChEnable( DMA_CH1, DMA_HW ); - setSCIDMAReceiveInterrupt(); -} - /*********************************************************************//** * @brief * The parseMeasurementSettings Reads measurement settings from buffer and @@ -740,7 +772,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); @@ -774,7 +806,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); @@ -809,20 +841,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 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; } // Validate buffer length - else if ((len % expectedDataLength) != 0) + else if ( ( len % expectedDataLength ) != 0 ) { parseStatus = CONDUCTIVITY_PARSE_ERROR_INVALID_LENGTH; } @@ -832,14 +864,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; @@ -866,7 +898,6 @@ 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 @@ -880,38 +911,37 @@ const U08* baseCmd = (const U08*)teensyCmdMap[ cmdIndex ].teensyCMD; // Clear the write buffer before writing - memset( condWriteCmdBuffer, 0, COND_WRITE_CMD_BUFFER_LEN ); + memset( &condTxBuffer, 0, COND_TX_BUFFER_LEN ); // Format command with optional parameter if ( ( NULL != param ) && ( strlen( (const char*)param ) > 0 ) ) { - written = snprintf( (char*)condWriteCmdBuffer, - COND_WRITE_CMD_BUFFER_LEN, - "%s %s", + written = snprintf( (char*)condTxBuffer, + COND_TX_BUFFER_LEN, + "%s,%s", (const char*)baseCmd, (const char*)param ); - - if ( written > 0 ) - { - success = TRUE; - } } else { - written = snprintf( (char*)condWriteCmdBuffer, - COND_WRITE_CMD_BUFFER_LEN, + written = snprintf( (char*)condTxBuffer, + COND_TX_BUFFER_LEN, "%s", (const char*)baseCmd ); - - if ( written > 0 ) - { - success = TRUE; - } } } + if ( written > 0 ) + { + memcpy( &condWriteCmdBuffer, &condTxBuffer, written ); + success = TRUE; + } + condWriteCommandInProgress = TRUE; setupConductivityDMAForWriteCmd( written ); + setupConductivityDMAForWriteResp( teensyCmdMap[ cmdIndex ].rxSize ); + + startConductivityDMAReceiptOfWriteResp(); startConductivityDMAWriteCmd(); return success; } @@ -922,33 +952,21 @@ * @param cmdIndex Index of the command in teensyCmd[]. * @return TRUE if the command was successfully written to the read buffer, FALSE otherwise. */ -static BOOL txTeensyReadCmd( TEENSY_CMD_INDEX_T cmdIndex ) +static BOOL rxTeensyReadRsp( TEENSY_CMD_INDEX_T cmdIndex ) { BOOL success = FALSE; - // 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;; + if ( TRUE == condWriteCmdRspnsRcvd ) + { + // Clear the read buffer before writing + memset( &condRxBuffer, 0, COND_RX_BUFFER_LEN ); + memcpy( &condRxBuffer, &condWriteResponseBuffer, teensyCmdMap[ cmdIndex ].rxSize ); + success = TRUE; + } + // Should not be any data received at this time + consumeUnexpectedConductivityData(); - // 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 ); - - success = ( written > 0 ) && ( written < COND_READ_CMD_BUFFER_LEN ); - } - - return success; + return success; } static CONDUCTIVITY_COMM_STATE_T txInitSensor( void ) @@ -960,10 +978,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; } @@ -974,51 +995,49 @@ static CONDUCTIVITY_COMM_STATE_T rxInitSensor( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; - CONDUCTIVITY_INIT_STATUS_T initStatus = CONDUCTIVITY_INIT_STATUS_UNITIALIZED; + 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 ); - initStatus = (CONDUCTIVITY_INIT_STATUS_T)condWriteResponseBuffer[0]; - - switch(initStatus) + if ( TRUE == recvComplete ) { - 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; + // 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]; - case CONDUCTIVITY_INIT_STATUS_IN_PROGRESS: - // Check if initialization has not completed before the timeout - if ( TRUE == didTimeout( condResponseTime, COND_DATA_TIMEOUT_MS ) ) + // Store the init status + conductivityInitStatus = initStatusInitialized; + + switch(conductivityInitStatus) { - // Then, Move to failed state - state = COND_COMM_STATE_FAILED; - } - else - { - // Reset timer for next use - condResponseTime = 0; - } - break; + case CONDUCTIVITY_INIT_STATUS_UNITIALIZED: + break; - case CONDUCTIVITY_INIT_STATUS_INITIALIZED: - // Move to execute next command - state = COND_COMM_STATE_IDLE; - break; + case CONDUCTIVITY_INIT_STATUS_IN_PROGRESS: + state = COND_COMM_STATE_IDLE; + break; - case CONDUCTIVITY_INIT_STATUS_FAILED: - default: - // Then, Move to failed state + case CONDUCTIVITY_INIT_STATUS_INITIALIZED: + state = COND_COMM_STATE_IDLE; + break; + + case CONDUCTIVITY_INIT_STATUS_FAILED: + default: + state = COND_COMM_STATE_FAILED; + break; + } + } + else if ( TRUE == didTimeout( condResponseTime, COND_STATUS_TIMEOUT_MS ) ) + { + // Go to failed state state = COND_COMM_STATE_FAILED; - break; } + else + { + // Do Nothing. Wait until we either receive a response OR timeout happens. + } return state; } @@ -1028,12 +1047,17 @@ CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; // If the get init status cmd was sent successfully - if ( TRUE == txTeensyReadCmd( TEENSY_CMD_GET_INIT_STATUS ) ) + 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; } @@ -1043,9 +1067,48 @@ static CONDUCTIVITY_COMM_STATE_T rxGetInitStatus( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; - conductivityInitStatus = ( CONDUCTIVITY_INIT_STATUS_T )condReadResponseBuffer[ 0 ]; - state = COND_COMM_STATE_IDLE; + // Check if a response is received in the RX buffer + BOOL recvComplete = rxTeensyReadRsp( TEENSY_CMD_GET_INIT_STATUS ); + if ( TRUE == recvComplete ) + { + // 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_FAILED; + 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; } @@ -1058,6 +1121,7 @@ U16 offset = 0; U16 i = 0; + // Pack the command and EEPROM data for ( i = 0; i < DOUBLE_COUNT; ++i ) { offset += snprintf( (char*)(paramStr + offset), @@ -1080,12 +1144,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; } @@ -1095,22 +1165,50 @@ static CONDUCTIVITY_COMM_STATE_T rxUpdateEEPROMdata( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; - condUpdateEEPROMstatus = ( CONDUCTIVITY_UPDATE_EEPROM_STATUS_T )condWriteResponseBuffer[ 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 == txTeensyReadCmd( 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; } @@ -1120,33 +1218,98 @@ static CONDUCTIVITY_COMM_STATE_T rxGetEEPROMdata( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; - CONDUCTIVITY_PARSE_STATUS parseStatus = parseEEPROMdata( condReadResponseBuffer, COND_READ_RSP_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(&conductivityEEPROMdata, &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( CONDUCTIVITY_MEASUREMENT_SETTINGS_T measurementSettings) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; + U08 paramStr[64]; - // Format measurement settings into a string - U08 paramStr[128]; + switch (currentSettingParam) + { + case CONDUCTIVITY_MST_PARAM_IDX_SINFREQ: + snprintf(paramStr, sizeof(paramStr), "%s,%.3f", condSettingsParam[currentSettingParam], measurementSettings.SinFreq); + break; - 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 ); + case CONDUCTIVITY_MST_PARAM_IDX_DACPP: + snprintf(paramStr, sizeof(paramStr), "%s,%.3f", condSettingsParam[currentSettingParam], measurementSettings.DacVoltPP); + break; + case CONDUCTIVITY_MST_PARAM_IDX_BIAS: + snprintf(paramStr, sizeof(paramStr), "%s,%.3f", condSettingsParam[currentSettingParam], measurementSettings.BiasVolt); + break; + + case CONDUCTIVITY_MST_PARAM_IDX_RTIA: + snprintf(paramStr, sizeof(paramStr), "%s,%u", condSettingsParam[currentSettingParam], measurementSettings.HstiaRtiaSel); + break; + + case CONDUCTIVITY_MST_PARAM_IDX_PGA: + snprintf(paramStr, sizeof(paramStr), "%s,%u", condSettingsParam[currentSettingParam], measurementSettings.AdcPgaGain); + break; + + case CONDUCTIVITY_MST_PARAM_IDX_DFTNUM: + snprintf(paramStr, sizeof(paramStr), "%s,%u", condSettingsParam[currentSettingParam], measurementSettings.DftNum); + break; + + case CONDUCTIVITY_MST_PARAM_IDX_AVGNUM: + snprintf(paramStr, sizeof(paramStr), "%s,%u", condSettingsParam[currentSettingParam], measurementSettings.ADCAvgNum); + break; + + default: + // Go to failed state + state = COND_COMM_STATE_FAILED; + break; + } + + // 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; } @@ -1156,21 +1319,99 @@ static CONDUCTIVITY_COMM_STATE_T rxUpdateMeasurementSettings( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; - condUpdateMeasurementSettings = ( CONDUCTIVITY_UPDATE_MST_STATUS_T )condWriteResponseBuffer[0]; - state = COND_COMM_STATE_IDLE; + CONDUCTIVITY_UPDATE_MST_STATUS_T updateSettingStatus = COND_MST_STATUS_ERR_UNRECOGNIZED_PARAM; + + // Check if a response is received in the RX buffer + BOOL recvComplete = rxTeensyReadRsp( TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS ); + if ( TRUE == recvComplete ) + { + // Get the time stamp for next parameter + condResponseTime = getMSTimerCount(); + + // Read the data from the receive buffer + memcpy(&updateSettingStatus, &condRxBuffer, teensyCmdMap[ TEENSY_CMD_UPDATE_MEASUREMENT_SETTINGS ].rxSize); +// updateSettingStatus = ( CONDUCTIVITY_UPDATE_MST_STATUS_T )condTxBuffer[0]; + + // Store the status of update measurement settings for the current param + condUpdateSettingStatus[currentSettingParam] = updateSettingStatus; + + // Move to TX state to update the next param. + state = COND_COMM_STATE_TX; + + switch (currentSettingParam) + { + case CONDUCTIVITY_MST_PARAM_IDX_SINFREQ: + currentSettingParam = CONDUCTIVITY_MST_PARAM_IDX_DACPP; + break; + + case CONDUCTIVITY_MST_PARAM_IDX_DACPP: + currentSettingParam = CONDUCTIVITY_MST_PARAM_IDX_BIAS; + break; + + case CONDUCTIVITY_MST_PARAM_IDX_BIAS: + currentSettingParam = CONDUCTIVITY_MST_PARAM_IDX_RTIA; + break; + + case CONDUCTIVITY_MST_PARAM_IDX_RTIA: + currentSettingParam = CONDUCTIVITY_MST_PARAM_IDX_PGA; + break; + + case CONDUCTIVITY_MST_PARAM_IDX_PGA: + currentSettingParam = CONDUCTIVITY_MST_PARAM_IDX_DFTNUM; + break; + + case CONDUCTIVITY_MST_PARAM_IDX_DFTNUM: + currentSettingParam = CONDUCTIVITY_MST_PARAM_IDX_AVGNUM; + break; + + case CONDUCTIVITY_MST_PARAM_IDX_AVGNUM: + { + // Reset the timer for next use. + condResponseTime = 0; + + // Update the current setting param to the first param in the list + currentSettingParam = CONDUCTIVITY_MST_PARAM_IDX_SINFREQ; + + // Go to the idle state. All the measurement settings param have been updated. + state = COND_COMM_STATE_IDLE; + break; + } + + default: + // Go to failed state + state = COND_COMM_STATE_FAILED; + 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; } static CONDUCTIVITY_COMM_STATE_T txGetMeasurementSettings( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_TX; - if ( TRUE == txTeensyReadCmd( 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; } @@ -1180,22 +1421,61 @@ static CONDUCTIVITY_COMM_STATE_T rxGetMeasurementSettings( void ) { CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; - CONDUCTIVITY_PARSE_STATUS parseStatus = parseMeasurementSettings( condReadResponseBuffer, COND_READ_RSP_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(&conductivityMeasurementSettings, &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 == txTeensyReadCmd( 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; @@ -1204,112 +1484,188 @@ static CONDUCTIVITY_COMM_STATE_T rxGetMeasurements( void ) { 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; + + // 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 == txTeensyReadCmd( 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 == txTeensyReadCmd( 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 == txTeensyReadCmd( TEENSY_CMD_GET_SINGLE_MEASUREMENT ) ) + if ( TRUE == txTeensyWriteCmd( TEENSY_CMD_GET_SINGLE_MEASUREMENT, NULL ) ) { - // Handle error + // Get the current time + condResponseTime = getMSTimerCount(); } -} -static void rxGetSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ) -{ - - // condReadResponseBuffer + return state; } -static CONDUCTIVITY_INIT_STATUS_T getInitStatus( void ) +static CONDUCTIVITY_COMM_STATE_T rxGetSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ) { - tx_getInitStatus(); - rx_getInitStatus(); - return conductivityInitStatus; -} + CONDUCTIVITY_COMM_STATE_T state = COND_COMM_STATE_RX; -static const CONDUCTIVITY_EEPROM_DATA_T* getEEPROMdata(void) -{ - return &conductivityEEPROMdata; -} + // 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 ); -static const CONDUCTIVITY_MEASUREMENT_SETTINGS_T* getMeasurementSettings(void) -{ - return &conductivityMeasurementSettings; -} + // 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. + } -static const CONDUCTIVITY_SENSOR_DATA_T* getSingleMeasurement( TEENSY_SENSOR_INDEX_T sensorNum ) -{ - const CONDUCTIVITY_SENSOR_DATA_T* result = NULL; - - if (sensorNum < MAX_TEENSY_SENSOR) - { - result = &rawConductivityValues[ sensorNum ]; - } - - return result; + return state; } -static const CONDUCTIVITY_SENSOR_DATA_T* getAllMeasurements( void ) -{ - return rawConductivityValues; -} - static void calculateConductivity( TEENSY_SENSOR_INDEX_T sensorNum ) { F64 calculatedConductivity = 0.0;