Index: firmware/App/Drivers/PinchValve.c =================================================================== diff -u -r5b9b3a6bbbdc9257ddf01fdbe781a8f6748beafa -r73e17d7f9edcedb40fef1d905267ae629b8ace42 --- firmware/App/Drivers/PinchValve.c (.../PinchValve.c) (revision 5b9b3a6bbbdc9257ddf01fdbe781a8f6748beafa) +++ firmware/App/Drivers/PinchValve.c (.../PinchValve.c) (revision 73e17d7f9edcedb40fef1d905267ae629b8ace42) @@ -69,13 +69,15 @@ #define PINCH_VALVE_PROFILE_MODE_VELOCITY 1 #define PINCH_VALVE_PROFILE_MODE_S_CURVE 2 #define PINCH_VALVE_RESET_EVENT_STATUS_VALUE 0xFFEE -#define PINCH_VALVE_DEFAULT_VELOCITY 3342 #define PINCH_VALVE_ACTIVITY_PHASE_INITIALIZED_MASK 0x0001 #define PINCH_VALVE_ACTIVITY_AXIS_SETTLED_MASK 0x0080 #define PINCH_VALVE_EVENT_MOTION_COMPLETE_MASK 0x0001 #define PINCH_VALVE_EVENT_MOTION_ERROR_MASK 0x0010 +static const S32 HOMING_VELOCITY_FWD = 3342; ///< Forward velocity used while moving toward the first homing hard stop. +static const S32 HOMING_VELOCITY_REV = -3342; ///< Reverse velocity used while moving toward the opposite homing hard stop. +static const S32 POSITION_VELOCITY = 3342; ///< Velocity used when moving the pinch valve to a requested position. /// Pinch valve function state machine. typedef enum pinchValveFunctionStates @@ -96,23 +98,6 @@ PINCH_VALVE_CMD_ERROR_STATE } PINCH_VALVE_CMD_STATE_T; -/// Result of the active low level command. -typedef enum pinchValveCommandResults -{ - PINCH_VALVE_CMD_RESULT_IDLE = 0, - PINCH_VALVE_CMD_RESULT_BUSY, - PINCH_VALVE_CMD_RESULT_COMPLETE, - PINCH_VALVE_CMD_RESULT_ERROR -} PINCH_VALVE_CMD_RESULT_T; - -/// Pinch Valve Function. -typedef enum pinchValveFunctions -{ - PINCH_VALVE_FUNCTION_NONE = 0, - PINCH_VALVE_FUNCTION_HOME, - PINCH_VALVE_FUNCTION_SET_POSITION -} PINCH_VALVE_FUNCTION_T; - /// Pinch valve command request. typedef struct { @@ -125,17 +110,6 @@ BOOL writeOnly; ///< TRUE for a write-only command. } PINCH_VALVE_COMMAND_T; -/// Response from the FPGA command interface. -typedef struct -{ - U16 outputWord1; ///< Output word 1. - U16 outputWord2; ///< Output word 2. - U16 outputWord3; ///< Output word 3. - U08 spiCmdStatus; ///< FPGA SPI command status. - U08 readCount; ///< FPGA read count. - U08 errorCount; ///< FPGA invalid command error count. -} PINCH_VALVE_RESPONSE_T; - /// Pinch Valve Command for Homing. typedef enum pinchValveHomingCommandIndexes { @@ -173,21 +147,18 @@ // ********** private data ********** -const S32 HOMING_VELOCITY_FWD = 3342; ///< ** add a comment later *** -const S32 HOMING_VELOCITY_REV = -3342; - // This array is used for both H1_VALV and H19_VALV. The active valve only determines which FPGA register access functions run. static PINCH_VALVE_COMMAND_T homingCommands[ NUM_OF_PINCH_VALVE_HOMING_COMMANDS ] = { { PINCH_VALVE_PMD_CMD_SET_PROFILE_MODE, PINCH_VALVE_PROFILE_MODE_VELOCITY, 0, 0, 1, 0, FALSE }, { PINCH_VALVE_PMD_CMD_RESET_EVENT_STATUS, PINCH_VALVE_RESET_EVENT_STATUS_VALUE, 0, 0, 1, 0, FALSE }, - { PINCH_VALVE_PMD_CMD_SET_VELOCITY, (HOMING_VELOCITY_FWD >> 16), (HOMING_VELOCITY_FWD & 0xFFFF), 0, 2, 0, FALSE }, + { PINCH_VALVE_PMD_CMD_SET_VELOCITY, (U16)( ( (U32)HOMING_VELOCITY_FWD >> 16 ) & 0xFFFF ), (U16)( (U32)HOMING_VELOCITY_FWD & 0xFFFF ), 0, 2, 0, FALSE }, { PINCH_VALVE_PMD_CMD_UPDATE, 0, 0, 0, 0, 0, FALSE }, { PINCH_VALVE_PMD_CMD_GET_ACTIVITY_STATUS, 0, 0, 0, 0, 1, FALSE }, { PINCH_VALVE_PMD_CMD_GET_EVENT_STATUS, 0, 0, 0, 0, 1, FALSE }, { PINCH_VALVE_PMD_CMD_SET_ACTUAL_POSITION, 0, 0, 0, 2, 0, FALSE }, { PINCH_VALVE_PMD_CMD_RESET_EVENT_STATUS, PINCH_VALVE_RESET_EVENT_STATUS_VALUE, 0, 0, 1, 0, FALSE }, - { PINCH_VALVE_PMD_CMD_SET_VELOCITY, (HOMING_VELOCITY_REV >> 16), (HOMING_VELOCITY_REV & 0xFFFF), 0, 2, 0, FALSE }, + { PINCH_VALVE_PMD_CMD_SET_VELOCITY, (U16)( ( (U32)HOMING_VELOCITY_REV >> 16 ) & 0xFFFF ),(U16)( (U32)HOMING_VELOCITY_REV & 0xFFFF ), 0, 2, 0, FALSE }, { PINCH_VALVE_PMD_CMD_UPDATE, 0, 0, 0, 0, 0, FALSE }, { PINCH_VALVE_PMD_CMD_GET_ACTUAL_POSITION, 0, 0, 0, 0, 2, FALSE }, { PINCH_VALVE_PMD_CMD_RESET_EVENT_STATUS, PINCH_VALVE_RESET_EVENT_STATUS_VALUE, 0, 0, 1, 0, FALSE } @@ -196,7 +167,7 @@ static PINCH_VALVE_COMMAND_T positionCommands[ NUM_OF_PINCH_VALVE_POSITION_COMMANDS ] = { { PINCH_VALVE_PMD_CMD_SET_PROFILE_MODE, PINCH_VALVE_PROFILE_MODE_S_CURVE, 0, 0, 1, 0, FALSE }, - { PINCH_VALVE_PMD_CMD_SET_VELOCITY, 0, 0, 0, 2, 0, FALSE }, + { PINCH_VALVE_PMD_CMD_SET_VELOCITY, (U16)( ( (U32)POSITION_VELOCITY >> 16 ) & 0xFFFF ), (U16)( (U32)POSITION_VELOCITY & 0xFFFF ), 0, 2, 0, FALSE }, { PINCH_VALVE_PMD_CMD_GET_ACTIVITY_STATUS, 0, 0, 0, 0, 1, FALSE }, { PINCH_VALVE_PMD_CMD_GET_EVENT_STATUS, 0, 0, 0, 0, 1, FALSE }, { PINCH_VALVE_PMD_CMD_RESET_EVENT_STATUS, PINCH_VALVE_RESET_EVENT_STATUS_VALUE, 0, 0, 1, 0, FALSE }, @@ -207,53 +178,55 @@ { PINCH_VALVE_PMD_CMD_RESET_EVENT_STATUS, PINCH_VALVE_RESET_EVENT_STATUS_VALUE, 0, 0, 1, 0, FALSE } }; -static PINCH_VALVE_FUNCTION_STATE_T functionState; ///< Current function state. -static PINCH_VALVE_CMD_STATE_T commandState; ///< Current command state. -static PINCH_VALVE_FUNCTION_T activeFunction; +static PINCH_VALVE_FUNCTION_STATE_T functionState[ NUM_OF_VALVES ]; +static PINCH_VALVE_CMD_STATE_T commandState[ NUM_OF_VALVES ]; -static VALVE_T activeValve; ///< Valve executing the current command. -static PINCH_VALVE_COMMAND_T pendingCommand; ///< Command waiting to be started. -static PINCH_VALVE_COMMAND_T activeCommand; ///< Command currently being executed. -static PINCH_VALVE_COMMAND_T *activeCommandArray; -static U08 activeCommandCount; -static U08 activeCommandIndex; +static PINCH_VALVE_COMMAND_T activeCommand[ NUM_OF_VALVES ]; +static const PINCH_VALVE_COMMAND_T *activeCommandArray[ NUM_OF_VALVES ]; +static U08 activeCommandCount[ NUM_OF_VALVES ]; +static U08 activeCommandIndex[ NUM_OF_VALVES ]; -static PINCH_VALVE_RESPONSE_T currentResponse; ///< Response for the active command. -static PINCH_VALVE_RESPONSE_T lastResponse[ NUM_OF_VALVES ]; ///< Last response for each valve. +static BOOL pendingValveHomeRequest[ NUM_OF_VALVES ]; +static BOOL pendingValvePositionRequest[ NUM_OF_VALVES ]; +static BOOL commandFailed[ NUM_OF_VALVES ]; +static BOOL commandCompleted[ NUM_OF_VALVES ]; -static PINCH_VALVE_CMD_RESULT_T commandResult; ///< Latest driver result. -static U08 enableResetValue[ NUM_OF_VALVES ]; ///< Last enable/reset value written per valve. -static U08 errorCountAtCommandStart; ///< Error counter captured before command start. +static S32 pendingValvePosition[ NUM_OF_VALVES ]; static S32 currentValvePosition[ NUM_OF_VALVES ]; -static U32 executeStartTime; ///< Execute transaction start time. -static U32 statusPollStartMSCount; ///< Status polling interval start time. +static U16 commandOutputWord1[ NUM_OF_VALVES ]; +static U16 commandOutputWord2[ NUM_OF_VALVES ]; +static U08 commandSpiStatus[ NUM_OF_VALVES ]; +static U08 commandErrorCount[ NUM_OF_VALVES ]; +static U08 errorCountAtCommandStart[ NUM_OF_VALVES ]; +static U08 enableResetValue[ NUM_OF_VALVES ]; + +static U32 executeStartTime[ NUM_OF_VALVES ]; +static U32 statusPollStartMSCount[ NUM_OF_VALVES ]; + + // ********** private function prototypes ********** -static PINCH_VALVE_CMD_RESULT_T getPinchValveCommandResult( void ); -static BOOL getPinchValveResponse( VALVE_T valve, PINCH_VALVE_RESPONSE_T *response ); static BOOL setPinchValveCommand( VALVE_T valve, const PINCH_VALVE_COMMAND_T *command ); +static BOOL isPinchValveCommandCompleted( VALVE_T valve, BOOL *repeatCommand ); -static void writePinchValveCommandRegisters( void ); -static BOOL transmitPinchValveCommand( void ); -static void readPinchValveCommandResponse( void ); -static void clearPinchValveFpgaCommand( void ); +static void writePinchValveCommandRegisters( VALVE_T valve ); +static BOOL transmitPinchValveCommand( VALVE_T valve ); +static void readPinchValveCommandResponse( VALVE_T valve ); +static void clearPinchValveFpgaCommand( VALVE_T valve ); static BOOL setPinchValveFpgaCommandByte( const PINCH_VALVE_COMMAND_T *command, U08 *fpgaCommand ); -static BOOL isPinchValveCommandDone( void ); -static BOOL isPinchValveControllerFaultActive( void ); -static BOOL didPinchValveErrorCountChange( void ); -static BOOL arePinchValveWordCountsValid( void ); +static BOOL isPinchValveCommandDone( VALVE_T valve ); +static BOOL isPinchValveControllerFaultActive( VALVE_T valve ); +static BOOL didPinchValveErrorCountChange( VALVE_T valve ); +static BOOL arePinchValveWordCountsValid( VALVE_T valve ); -static U08 readPinchValveErrorCount( VALVE_T valve ); +static U08 readPinchValveErrorCount( VALVE_T valve ); static BOOL isValidPinchValve( VALVE_T valve ); static BOOL isValidPinchValveCommand( const PINCH_VALVE_COMMAND_T *command ); -static void clearPinchValveResponse( PINCH_VALVE_RESPONSE_T *response ); - static void setSigned32CommandWords( PINCH_VALVE_COMMAND_T *command, S32 value ); -static S32 getSigned32ResponseValue( const PINCH_VALVE_RESPONSE_T *response ); -static BOOL isPinchValveCommandCompleted( BOOL *repeatCommand ); +static S32 getSigned32OutputValue( VALVE_T valve ); /*********************************************************************//** * @brief @@ -265,39 +238,44 @@ *************************************************************************/ void initPinchValveDriver( void ) { - U32 valve; + VALVE_T valve; - functionState = PINCH_VALVE_FUNCTION_IDLE_STATE; - commandState = PINCH_VALVE_CMD_IDLE_STATE; - activeFunction = PINCH_VALVE_FUNCTION_NONE; - activeValve = H1_VALV; - commandResult = PINCH_VALVE_CMD_RESULT_IDLE; + setSigned32CommandWords( &homingCommands[ PINCH_VALVE_HOME_CMD_SET_VELOCITY_B ], HOMING_VELOCITY_FWD ); + setSigned32CommandWords( &homingCommands[ PINCH_VALVE_HOME_CMD_SET_VELOCITY_C ], HOMING_VELOCITY_REV ); + setSigned32CommandWords( &positionCommands[ PINCH_VALVE_POSITION_CMD_SET_VELOCITY ], POSITION_VELOCITY ); - activeCommandArray = 0; - activeCommandCount = 0; - activeCommandIndex = 0; - - clearPinchValveResponse( ¤tResponse ); - for ( valve = FIRST_VALVE; valve < NUM_OF_VALVES; valve++ ) { - clearPinchValveResponse( &lastResponse[ valve ] ); - enableResetValue[ valve ] = 0; - currentValvePosition[ valve ] = 0; - } + functionState[ valve ] = PINCH_VALVE_FUNCTION_IDLE_STATE; + commandState[ valve ] = PINCH_VALVE_CMD_IDLE_STATE; + activeCommandArray[ valve ] = 0; + activeCommandCount[ valve ] = 0; + activeCommandIndex[ valve ] = 0; + pendingValveHomeRequest[ valve ] = FALSE; + pendingValvePositionRequest[ valve ] = FALSE; + commandFailed[ valve ] = FALSE; + commandCompleted[ valve ] = FALSE; + pendingValvePosition[ valve ] = 0; + currentValvePosition[ valve ] = 0; + commandOutputWord1[ valve ] = 0; + commandOutputWord2[ valve ] = 0; + commandSpiStatus[ valve ] = 0; + commandErrorCount[ valve ] = 0; + errorCountAtCommandStart[ valve ] = 0; + enableResetValue[ valve ] = 0; + executeStartTime[ valve ] = 0; + statusPollStartMSCount[ valve ] = 0; - setSigned32CommandWords( &homingCommands[ PINCH_VALVE_HOME_CMD_SET_VELOCITY_B ], PINCH_VALVE_DEFAULT_VELOCITY ); - setSigned32CommandWords( &homingCommands[ PINCH_VALVE_HOME_CMD_SET_VELOCITY_C ], -PINCH_VALVE_DEFAULT_VELOCITY ); - setSigned32CommandWords( &homingCommands[ PINCH_VALVE_HOME_CMD_SET_ACTUAL_POSITION_ZERO ], 0 ); - setSigned32CommandWords( &positionCommands[ PINCH_VALVE_POSITION_CMD_SET_VELOCITY ], PINCH_VALVE_DEFAULT_VELOCITY ); - setSigned32CommandWords( &positionCommands[ PINCH_VALVE_POSITION_CMD_SET_POSITION ], 0 ); + activeCommand[ valve ].cmdHeader = 0; + activeCommand[ valve ].inputWord1 = 0; + activeCommand[ valve ].inputWord2 = 0; + activeCommand[ valve ].inputWord3 = 0; + activeCommand[ valve ].inputWordCount = 0; + activeCommand[ valve ].outputWordCount = 0; + activeCommand[ valve ].writeOnly = FALSE; - errorCountAtCommandStart = 0; - executeStartTime = 0; - statusPollStartMSCount = 0; - - setH1FPGACmd( 0 ); - setH19FPGACmd( 0 ); + clearPinchValveFpgaCommand( valve ); + } } /*********************************************************************//** @@ -311,87 +289,96 @@ *************************************************************************/ void execPinchValveCommand( void ) { - switch ( commandState ) + VALVE_T valve; + + for ( valve = FIRST_VALVE; valve < NUM_OF_VALVES; valve++ ) { - case PINCH_VALVE_CMD_IDLE_STATE: - execPinchValveFunction(); - break; + switch ( commandState[ valve ] ) + { + case PINCH_VALVE_CMD_IDLE_STATE: + break; - case PINCH_VALVE_CMD_SET_CMD_STATE: - writePinchValveCommandRegisters(); - if ( PINCH_VALVE_CMD_ERROR_STATE != commandState ) - { - errorCountAtCommandStart = readPinchValveErrorCount( activeValve ); - commandState = PINCH_VALVE_CMD_XMIT_CMD_STATE; - } - break; + case PINCH_VALVE_CMD_SET_CMD_STATE: + writePinchValveCommandRegisters( valve ); - case PINCH_VALVE_CMD_XMIT_CMD_STATE: - if ( TRUE == transmitPinchValveCommand() ) - { - executeStartTime = getMSTimerCount(); - statusPollStartMSCount = executeStartTime; - commandState = PINCH_VALVE_CMD_WAIT_DONE_STATE; - } - else - { - commandState = PINCH_VALVE_CMD_ERROR_STATE; - } - break; + if ( PINCH_VALVE_CMD_ERROR_STATE != commandState[ valve ] ) + { + errorCountAtCommandStart[ valve ] = readPinchValveErrorCount( valve ); + commandState[ valve ] = PINCH_VALVE_CMD_XMIT_CMD_STATE; + } + break; - case PINCH_VALVE_CMD_WAIT_DONE_STATE: - if ( TRUE == didTimeout( executeStartTime, PINCH_VALVE_COMMAND_TIMEOUT_MS ) ) - { - readPinchValveCommandResponse(); - commandState = PINCH_VALVE_CMD_ERROR_STATE; - } - else if ( TRUE == didTimeout( statusPollStartMSCount, PINCH_VALVE_STATUS_POLL_INTERVAL_MS ) ) - { - readPinchValveCommandResponse(); - statusPollStartMSCount = getMSTimerCount(); - if ( ( TRUE == didPinchValveErrorCountChange() ) || ( TRUE == isPinchValveControllerFaultActive() ) ) + case PINCH_VALVE_CMD_XMIT_CMD_STATE: + if ( TRUE == transmitPinchValveCommand( valve ) ) { - commandState = PINCH_VALVE_CMD_ERROR_STATE; + executeStartTime[ valve ] = getMSTimerCount(); + statusPollStartMSCount[ valve ] = executeStartTime[ valve ]; + commandState[ valve ] = PINCH_VALVE_CMD_WAIT_DONE_STATE; } - else if ( TRUE == isPinchValveCommandDone() ) + else { - commandState = PINCH_VALVE_CMD_READ_WORDS_STATE; + commandState[ valve ] = PINCH_VALVE_CMD_ERROR_STATE; } - } - break; + break; - case PINCH_VALVE_CMD_READ_WORDS_STATE: - readPinchValveCommandResponse(); - if ( ( TRUE == didPinchValveErrorCountChange() ) || ( TRUE == isPinchValveControllerFaultActive() ) || ( FALSE == arePinchValveWordCountsValid() ) ) - { - commandState = PINCH_VALVE_CMD_ERROR_STATE; - } - else - { - lastResponse[ activeValve ] = currentResponse; - clearPinchValveFpgaCommand(); - commandResult = PINCH_VALVE_CMD_RESULT_COMPLETE; - commandState = PINCH_VALVE_CMD_IDLE_STATE; - } - break; + case PINCH_VALVE_CMD_WAIT_DONE_STATE: + if ( TRUE == didTimeout( executeStartTime[ valve ], PINCH_VALVE_COMMAND_TIMEOUT_MS ) ) + { + readPinchValveCommandResponse( valve ); + commandState[ valve ] = PINCH_VALVE_CMD_ERROR_STATE; + } + else if ( TRUE == didTimeout( statusPollStartMSCount[ valve ], PINCH_VALVE_STATUS_POLL_INTERVAL_MS ) ) + { + readPinchValveCommandResponse( valve ); + statusPollStartMSCount[ valve ] = getMSTimerCount(); - case PINCH_VALVE_CMD_ERROR_STATE: - readPinchValveCommandResponse(); - lastResponse[ activeValve ] = currentResponse; - clearPinchValveFpgaCommand(); - commandResult = PINCH_VALVE_CMD_RESULT_ERROR; - commandState = PINCH_VALVE_CMD_IDLE_STATE; - break; + if ( ( TRUE == didPinchValveErrorCountChange( valve ) ) || ( TRUE == isPinchValveControllerFaultActive( valve ) ) ) + { + commandState[ valve ] = PINCH_VALVE_CMD_ERROR_STATE; + } + else if ( TRUE == isPinchValveCommandDone( valve ) ) + { + commandState[ valve ] = PINCH_VALVE_CMD_READ_WORDS_STATE; + } + } + break; - default: - clearPinchValveFpgaCommand(); - commandResult = PINCH_VALVE_CMD_RESULT_ERROR; - commandState = PINCH_VALVE_CMD_IDLE_STATE; - functionState = PINCH_VALVE_FUNCTION_IDLE_STATE; - activeFunction = PINCH_VALVE_FUNCTION_NONE; - break; + case PINCH_VALVE_CMD_READ_WORDS_STATE: + readPinchValveCommandResponse( valve ); + + if ( ( TRUE == didPinchValveErrorCountChange( valve ) ) || + ( TRUE == isPinchValveControllerFaultActive( valve ) ) || + ( FALSE == arePinchValveWordCountsValid( valve ) ) ) + { + commandState[ valve ] = PINCH_VALVE_CMD_ERROR_STATE; + } + else + { + clearPinchValveFpgaCommand( valve ); + commandFailed[ valve ] = FALSE; + commandCompleted[ valve ] = TRUE; + commandState[ valve ] = PINCH_VALVE_CMD_IDLE_STATE; + } + break; + + + case PINCH_VALVE_CMD_ERROR_STATE: + readPinchValveCommandResponse( valve ); + clearPinchValveFpgaCommand( valve ); + commandFailed[ valve ] = TRUE; + commandCompleted[ valve ] = TRUE; + commandState[ valve ] = PINCH_VALVE_CMD_IDLE_STATE; + break; + + default: + clearPinchValveFpgaCommand( valve ); + commandFailed[ valve ] = TRUE; + commandCompleted[ valve ] = TRUE; + commandState[ valve ] = PINCH_VALVE_CMD_IDLE_STATE; + break; + } } } @@ -409,15 +396,9 @@ { BOOL result = FALSE; - if ( ( TRUE == isValidPinchValve( valve ) ) && ( FALSE == isPinchValveBusy() ) ) + if ( ( TRUE == isValidPinchValve( valve ) ) && ( FALSE == isPinchValveBusy( valve ) ) ) { pendingValveHomeRequest[ valve ] = TRUE; - -// activeValve = valve; -// activeFunction = PINCH_VALVE_FUNCTION_HOME; -// activeCommandArray = homingCommands; -// commandResult = PINCH_VALVE_CMD_RESULT_BUSY; -// functionState = PINCH_VALVE_FUNCTION_SEND_STATE; result = TRUE; } @@ -438,17 +419,10 @@ { BOOL result = FALSE; - if ( ( TRUE == isValidPinchValve( valve ) ) && ( FALSE == isPinchValveBusy() ) ) + if ( ( TRUE == isValidPinchValve( valve ) ) && ( FALSE == isPinchValveBusy( valve ) ) ) { - setSigned32CommandWords( &positionCommands[ PINCH_VALVE_POSITION_CMD_SET_POSITION ], position ); - - activeValve = valve; - activeFunction = PINCH_VALVE_FUNCTION_SET_POSITION; - activeCommandArray = positionCommands; - activeCommandCount = (U08)NUM_OF_PINCH_VALVE_POSITION_COMMANDS; - activeCommandIndex = 0; - commandResult = PINCH_VALVE_CMD_RESULT_BUSY; - functionState = PINCH_VALVE_FUNCTION_SEND_STATE; + pendingValvePosition[ valve ] = position; + pendingValvePositionRequest[ valve ] = TRUE; result = TRUE; } @@ -502,18 +476,14 @@ if ( H1_VALV == valve ) { - enableResetValue[ H1_VALV ] = value; + enableResetValue[ valve ] = value; setH1EnableReset( value ); } else if ( H19_VALV == valve ) { - enableResetValue[ H19_VALV ] = value; + enableResetValue[ valve ] = value; setH19EnableReset( value ); } - else - { - // TODO: Check with Sean and update later (Invalid valve. The caller can verify the valve before calling) - } } /*********************************************************************//** @@ -544,10 +514,17 @@ * @details \b Outputs: none * @return TRUE if the driver is busy, FALSE otherwise. *************************************************************************/ -BOOL isPinchValveBusy( void ) +BOOL isPinchValveBusy( VALVE_T valve ) { - return ( ( PINCH_VALVE_FUNCTION_IDLE_STATE != functionState ) || - ( PINCH_VALVE_CMD_IDLE_STATE != commandState ) ); + BOOL result = TRUE; + + if ( TRUE == isValidPinchValve( valve ) ) + { + result = ( ( PINCH_VALVE_FUNCTION_IDLE_STATE != functionState[ valve ] ) || ( PINCH_VALVE_CMD_IDLE_STATE != commandState[ valve ] ) || + ( TRUE == pendingValveHomeRequest[ valve ] ) || ( TRUE == pendingValvePositionRequest[ valve ] ) ); + } + + return result; } @@ -563,158 +540,128 @@ { VALVE_T valve; - for ( valve = (VALVE_T)0; valve < NUM_OF_VALVES; valve++ ) + for ( valve = FIRST_VALVE; valve < NUM_OF_VALVES; valve++ ) { switch ( functionState[ valve ] ) { case PINCH_VALVE_FUNCTION_IDLE_STATE: if ( TRUE == pendingValveHomeRequest[ valve ] ) { - activeCommandCount = (U08)NUM_OF_PINCH_VALVE_HOMING_COMMANDS; - activeCommandIndex = 0; - activeCommandArray = &homingCommands[0]; - functinState[ valve ] = PINCH_VALVE_FUNCTION_SEND_STATE; + pendingValveHomeRequest[ valve ] = FALSE; + activeCommandArray[ valve ] = &homingCommands[ 0 ]; + activeCommandCount[ valve ] = (U08)NUM_OF_PINCH_VALVE_HOMING_COMMANDS; + activeCommandIndex[ valve ] = 0; + commandFailed[ valve ] = FALSE; + functionState[ valve ] = PINCH_VALVE_FUNCTION_SEND_STATE; } + else if ( TRUE == pendingValvePositionRequest[ valve ] ) + { + pendingValvePositionRequest[ valve ] = FALSE; + activeCommandArray[ valve ] = &positionCommands[ 0 ]; + activeCommandCount[ valve ] = (U08)NUM_OF_PINCH_VALVE_POSITION_COMMANDS; + activeCommandIndex[ valve ] = 0; + commandFailed[ valve ] = FALSE; + functionState[ valve ] = PINCH_VALVE_FUNCTION_SEND_STATE; + } + break; case PINCH_VALVE_FUNCTION_SEND_STATE: - if ( ( activeCommandArray != 0 ) && ( activeCommandIndex < activeCommandCount ) && - ( TRUE == setPinchValveCommand( valve, &activeCommandArray[ activeCommandIndex ] ) ) ) + if ( ( activeCommandArray[ valve ] != 0 ) && ( activeCommandIndex[ valve ] < activeCommandCount[ valve ] ) ) { - functionState = PINCH_VALVE_FUNCTION_WAIT_STATE; + if ( TRUE == setPinchValveCommand( valve, &activeCommandArray[ valve ][ activeCommandIndex[ valve ] ] ) ) + { + functionState[ valve ] = PINCH_VALVE_FUNCTION_WAIT_STATE; + } } else { - commandResult = PINCH_VALVE_CMD_RESULT_ERROR; - functionState = PINCH_VALVE_FUNCTION_IDLE_STATE; - //activeFunction = PINCH_VALVE_FUNCTION_NONE; + commandFailed[ valve ] = TRUE; + functionState[ valve ] = PINCH_VALVE_FUNCTION_IDLE_STATE; } + break; case PINCH_VALVE_FUNCTION_WAIT_STATE: - //PINCH_VALVE_CMD_RESULT_T cmdResult = getPinchValveCommandResult(); - - //if ( PINCH_VALVE_CMD_RESULT_COMPLETE == cmdResult ) - if ( IDLE_STATE == commandState[ valve ] ) + if ( ( PINCH_VALVE_CMD_IDLE_STATE == commandState[ valve ] ) && ( TRUE == commandCompleted[ valve ] ) ) { - if ( ++activeCommandIndex >= NUM_OF_>>>>> ) + BOOL repeatCommand = FALSE; + + commandCompleted[ valve ] = FALSE; + + if ( TRUE == commandFailed[ valve ] ) { functionState[ valve ] = PINCH_VALVE_FUNCTION_IDLE_STATE; } - else + else if ( FALSE == isPinchValveCommandCompleted( valve, &repeatCommand ) ) { + commandFailed[ valve ] = TRUE; + functionState[ valve ] = PINCH_VALVE_FUNCTION_IDLE_STATE; + } + else if ( TRUE == repeatCommand ) + { functionState[ valve ] = PINCH_VALVE_FUNCTION_SEND_STATE; } -// BOOL repeatCommand = FALSE; -// -// if ( TRUE == isPinchValveCommandCompleted( &repeatCommand ) ) -// { -// if ( TRUE == repeatCommand ) -// { -// commandResult = PINCH_VALVE_CMD_RESULT_BUSY; -// functionState = PINCH_VALVE_FUNCTION_SEND_STATE; -// } -// else -// { -// activeCommandIndex++; -// -// if ( activeCommandIndex >= activeCommandCount ) -// { -// commandResult = PINCH_VALVE_CMD_RESULT_COMPLETE; -// functionState = PINCH_VALVE_FUNCTION_IDLE_STATE; -// activeFunction = PINCH_VALVE_FUNCTION_NONE; -// } -// else -// { -// commandResult = PINCH_VALVE_CMD_RESULT_BUSY; -// functionState = PINCH_VALVE_FUNCTION_SEND_STATE; -// } -// } -// } -// else -// { -// commandResult = PINCH_VALVE_CMD_RESULT_ERROR; -// functionState = PINCH_VALVE_FUNCTION_IDLE_STATE; -// activeFunction = PINCH_VALVE_FUNCTION_NONE; -// } -// } -// else if ( PINCH_VALVE_CMD_RESULT_ERROR == cmdResult ) -// { -// functionState = PINCH_VALVE_FUNCTION_IDLE_STATE; -// activeFunction = PINCH_VALVE_FUNCTION_NONE; -// } + else + { + activeCommandIndex[ valve ]++; + + if ( activeCommandIndex[ valve ] >= activeCommandCount[ valve ] ) + { + functionState[ valve ] = PINCH_VALVE_FUNCTION_IDLE_STATE; + } + else + { + functionState[ valve ] = PINCH_VALVE_FUNCTION_SEND_STATE; + } + } + } break; default: - // TODO - s/w fault -// commandResult = PINCH_VALVE_CMD_RESULT_ERROR; -// functionState = PINCH_VALVE_FUNCTION_IDLE_STATE; -// activeFunction = PINCH_VALVE_FUNCTION_NONE; + commandFailed[ valve ] = TRUE; + functionState[ valve ] = PINCH_VALVE_FUNCTION_IDLE_STATE; break; } } } -/*********************************************************************//** -* @brief -* The getPinchValveCommandResult function returns the low-level result. -* @details \b Inputs: commandResult -* @details \b Outputs: none -* @return Latest command result. -*************************************************************************/ -static PINCH_VALVE_CMD_RESULT_T getPinchValveCommandResult( void ) -{ - return commandResult; -} /*********************************************************************//** * @brief -* The getPinchValveResponse function returns the last response for a valve. -* @details \b Inputs: lastResponse[] -* @details \b Outputs: response -* @param valve H1_VALV or H19_VALV. -* @param response Destination for the response data. -* @return TRUE if the response was returned, FALSE otherwise. -*************************************************************************/ -BOOL getPinchValveResponse( VALVE_T valve, PINCH_VALVE_RESPONSE_T *response ) -{ - BOOL result = FALSE; - - if ( ( TRUE == isValidPinchValve( valve ) ) && ( response != 0 ) ) - { - *response = lastResponse[ valve ]; - result = TRUE; - } - - return result; -} - -/*********************************************************************//** -* @brief * The setPinchValveCommand function requests execution * @details \b Inputs: valve, command * @details \b Outputs: pendingCommand, functionState, commandResult * @param valve H1_VALV or H19_VALV. * @return TRUE if the request was accepted, FALSE otherwise. *************************************************************************/ -BOOL setPinchValveCommand( VALVE_T valve, const PINCH_VALVE_COMMAND_T *command ) +static BOOL setPinchValveCommand( VALVE_T valve, const PINCH_VALVE_COMMAND_T *command ) { BOOL result = FALSE; if ( ( TRUE == isValidPinchValve( valve ) ) && ( TRUE == isValidPinchValveCommand( command ) ) && - ( PINCH_VALVE_FUNCTION_IDLE_STATE == functionState ) && ( PINCH_VALVE_CMD_IDLE_STATE == commandState ) ) + ( PINCH_VALVE_CMD_IDLE_STATE == commandState[ valve ] ) && ( FALSE == commandCompleted[ valve ] ) ) { - activeValve = valve; - pendingCommand = *command; - commandResult = PINCH_VALVE_CMD_RESULT_BUSY; - functionState = PINCH_VALVE_FUNCTION_SEND_STATE; - result = TRUE; + activeCommand[ valve ] = *command; + + if ( ( activeCommandArray[ valve ] == &positionCommands[ 0 ] ) && + ( PINCH_VALVE_POSITION_CMD_SET_POSITION == activeCommandIndex[ valve ] ) ) + { + setSigned32CommandWords( &activeCommand[ valve ], pendingValvePosition[ valve ] ); + } + + commandOutputWord1[ valve ] = 0; + commandOutputWord2[ valve ] = 0; + commandSpiStatus[ valve ] = 0; + commandErrorCount[ valve ] = 0; + commandFailed[ valve ] = FALSE; + commandState[ valve ] = PINCH_VALVE_CMD_SET_CMD_STATE; + result = TRUE; } return result; } - /*********************************************************************//** * @brief * The isPinchValveCommandCompleted function handles returned PMD data. @@ -723,79 +670,70 @@ * @param repeatCommand Set TRUE when the current status command shall repeat. * @return TRUE if the response is valid, FALSE if an error occurred. *************************************************************************/ -static BOOL isPinchValveCommandCompleted( BOOL *repeatCommand ) +static BOOL isPinchValveCommandCompleted( VALVE_T valve, BOOL *repeatCommand ) { - BOOL result = TRUE; - PINCH_VALVE_RESPONSE_T response; + BOOL result = FALSE; - if ( repeatCommand == 0 ) + if ( ( TRUE == isValidPinchValve( valve ) ) && ( repeatCommand != 0 ) ) { - result = FALSE; - } - else - { *repeatCommand = FALSE; + result = TRUE; - if ( FALSE == getPinchValveResponse( activeValve, &response ) ) + if ( activeCommandArray[ valve ] == &homingCommands[ 0 ] ) { - result = FALSE; - } - else if ( PINCH_VALVE_FUNCTION_HOME == activeFunction ) - { - if ( PINCH_VALVE_HOME_CMD_GET_ACTIVITY_STATUS == activeCommandIndex ) + if ( PINCH_VALVE_HOME_CMD_GET_ACTIVITY_STATUS == activeCommandIndex[ valve ] ) { U16 required = PINCH_VALVE_ACTIVITY_PHASE_INITIALIZED_MASK | PINCH_VALVE_ACTIVITY_AXIS_SETTLED_MASK; - if ( required != ( response.outputWord1 & required ) ) + if ( required != ( commandOutputWord1[ valve ] & required ) ) { *repeatCommand = TRUE; } } - else if ( ( PINCH_VALVE_HOME_CMD_GET_EVENT_STATUS_B == activeCommandIndex ) || - ( PINCH_VALVE_HOME_CMD_GET_EVENT_STATUS_C == activeCommandIndex ) ) + else if ( PINCH_VALVE_HOME_CMD_GET_EVENT_STATUS_B == activeCommandIndex[ valve ] ) { - if ( 0 == ( response.outputWord1 & ( PINCH_VALVE_EVENT_MOTION_COMPLETE_MASK | PINCH_VALVE_EVENT_MOTION_ERROR_MASK ) ) ) + if ( 0 == ( commandOutputWord1[ valve ] & ( PINCH_VALVE_EVENT_MOTION_COMPLETE_MASK | PINCH_VALVE_EVENT_MOTION_ERROR_MASK ) ) ) { *repeatCommand = TRUE; } } - else if ( PINCH_VALVE_HOME_CMD_GET_ACTUAL_POSITION_C == activeCommandIndex ) + else if ( PINCH_VALVE_HOME_CMD_GET_ACTUAL_POSITION_C == activeCommandIndex[ valve ] ) { - currentValvePosition[ activeValve ] = getSigned32ResponseValue( &response ); + currentValvePosition[ valve ] = getSigned32OutputValue( valve ); } } - else if ( PINCH_VALVE_FUNCTION_SET_POSITION == activeFunction ) + else if ( activeCommandArray[ valve ] == &positionCommands[ 0 ] ) { - if ( PINCH_VALVE_POSITION_CMD_GET_ACTIVITY_STATUS == activeCommandIndex ) + if ( PINCH_VALVE_POSITION_CMD_GET_ACTIVITY_STATUS == activeCommandIndex[ valve ] ) { U16 required = PINCH_VALVE_ACTIVITY_PHASE_INITIALIZED_MASK | PINCH_VALVE_ACTIVITY_AXIS_SETTLED_MASK; - if ( required != ( response.outputWord1 & required ) ) + if ( required != ( commandOutputWord1[ valve ] & required ) ) { *repeatCommand = TRUE; } } - else if ( PINCH_VALVE_POSITION_CMD_GET_EVENT_STATUS_BEFORE == activeCommandIndex ) + else if ( PINCH_VALVE_POSITION_CMD_GET_EVENT_STATUS_BEFORE == activeCommandIndex[ valve ] ) { - if ( 0 != ( response.outputWord1 & PINCH_VALVE_EVENT_MOTION_ERROR_MASK ) ) + if ( 0 != ( commandOutputWord1[ valve ] & PINCH_VALVE_EVENT_MOTION_ERROR_MASK ) ) { result = FALSE; } } - else if ( PINCH_VALVE_POSITION_CMD_GET_EVENT_STATUS_AFTER == activeCommandIndex ) + else if ( PINCH_VALVE_POSITION_CMD_GET_EVENT_STATUS_AFTER == activeCommandIndex[ valve ] ) { - if ( 0 != ( response.outputWord1 & PINCH_VALVE_EVENT_MOTION_ERROR_MASK ) ) + if ( 0 != ( commandOutputWord1[ valve ] & PINCH_VALVE_EVENT_MOTION_ERROR_MASK ) ) { result = FALSE; } - else if ( 0 == ( response.outputWord1 & PINCH_VALVE_EVENT_MOTION_COMPLETE_MASK ) ) + else if ( 0 == ( commandOutputWord1[ valve ] & PINCH_VALVE_EVENT_MOTION_COMPLETE_MASK ) ) { *repeatCommand = TRUE; } } - else if ( PINCH_VALVE_POSITION_CMD_GET_ACTUAL_POSITION == activeCommandIndex ) + else if ( PINCH_VALVE_POSITION_CMD_GET_ACTUAL_POSITION == activeCommandIndex[ valve ] ) { - currentValvePosition[ activeValve ] = getSigned32ResponseValue( &response ); + currentValvePosition[ valve ] = getSigned32OutputValue( valve ); } } else @@ -807,6 +745,7 @@ return result; } + /*********************************************************************//** * @brief * The writePinchValveCommandRegisters function writes the command header and @@ -815,25 +754,25 @@ * @details \b Outputs: FPGA command header and input registers * @return none *************************************************************************/ -static void writePinchValveCommandRegisters( void ) +static void writePinchValveCommandRegisters( VALVE_T valve ) { - if ( H1_VALV == activeValve ) + if ( H1_VALV == valve ) { - setH1CmdHeader( activeCommand.cmdHeader ); - setH1InputWord1( activeCommand.inputWord1 ); - setH1InputWord2( activeCommand.inputWord2 ); - setH1InputWord3( activeCommand.inputWord3 ); + setH1CmdHeader( activeCommand[ valve ].cmdHeader ); + setH1InputWord1( activeCommand[ valve ].inputWord1 ); + setH1InputWord2( activeCommand[ valve ].inputWord2 ); + setH1InputWord3( activeCommand[ valve ].inputWord3 ); } - else if ( H19_VALV == activeValve ) + else if ( H19_VALV == valve ) { - setH19CmdHeader( activeCommand.cmdHeader ); - setH19InputWord1( activeCommand.inputWord1 ); - setH19InputWord2( activeCommand.inputWord2 ); - setH19InputWord3( activeCommand.inputWord3 ); + setH19CmdHeader( activeCommand[ valve ].cmdHeader ); + setH19InputWord1( activeCommand[ valve ].inputWord1 ); + setH19InputWord2( activeCommand[ valve ].inputWord2 ); + setH19InputWord3( activeCommand[ valve ].inputWord3 ); } else { - commandState = PINCH_VALVE_CMD_ERROR_STATE; + commandState[ valve ] = PINCH_VALVE_CMD_ERROR_STATE; } } @@ -845,32 +784,29 @@ * @details \b Outputs: FPGA command register * @return TRUE if the command byte was valid and written. *************************************************************************/ -static BOOL transmitPinchValveCommand( void ) +static BOOL transmitPinchValveCommand( VALVE_T valve ) { BOOL result = FALSE; U08 fpgaCommand; - if ( TRUE == setPinchValveFpgaCommandByte( &activeCommand, &fpgaCommand ) ) + if ( TRUE == setPinchValveFpgaCommandByte( &activeCommand[ valve ], &fpgaCommand ) ) { - if ( H1_VALV == activeValve ) + if ( H1_VALV == valve ) { setH1FPGACmd( fpgaCommand ); result = TRUE; } - else if ( H19_VALV == activeValve ) + else if ( H19_VALV == valve ) { setH19FPGACmd( fpgaCommand ); result = TRUE; } - else - { - //TODO: Check with Sean and remove later - } } return result; } + /*********************************************************************//** * @brief * The readPinchValveCommandResponse function reads the active valve response @@ -879,30 +815,22 @@ * @details \b Outputs: currentResponse * @return none *************************************************************************/ -static void readPinchValveCommandResponse( void ) +static void readPinchValveCommandResponse( VALVE_T valve ) { - if ( H1_VALV == activeValve ) + if ( H1_VALV == valve ) { - currentResponse.spiCmdStatus = getH1SPICmdStatus(); - currentResponse.readCount = getH1ReadCount(); - currentResponse.errorCount = getH1ErrorCount(); - currentResponse.outputWord1 = getH1OutputWord1(); - currentResponse.outputWord2 = getH1OutputWord2(); - currentResponse.outputWord3 = getH1OutputWord3(); + commandSpiStatus[ valve ] = getH1SPICmdStatus(); + commandErrorCount[ valve ] = getH1ErrorCount(); + commandOutputWord1[ valve ] = getH1OutputWord1(); + commandOutputWord2[ valve ] = getH1OutputWord2(); } - else if ( H19_VALV == activeValve ) + else if ( H19_VALV == valve ) { - currentResponse.spiCmdStatus = getH19SPICmdStatus(); - currentResponse.readCount = getH19ReadCount(); - currentResponse.errorCount = getH19ErrorCount(); - currentResponse.outputWord1 = getH19OutputWord1(); - currentResponse.outputWord2 = getH19OutputWord2(); - currentResponse.outputWord3 = getH19OutputWord3(); + commandSpiStatus[ valve ] = getH19SPICmdStatus(); + commandErrorCount[ valve ] = getH19ErrorCount(); + commandOutputWord1[ valve ] = getH19OutputWord1(); + commandOutputWord2[ valve ] = getH19OutputWord2(); } - else - { - clearPinchValveResponse( ¤tResponse ); - } } /*********************************************************************//** @@ -913,21 +841,18 @@ * @details \b Outputs: FPGA command register * @return none *************************************************************************/ -static void clearPinchValveFpgaCommand( void ) +static void clearPinchValveFpgaCommand( VALVE_T valve ) { - if ( H1_VALV == activeValve ) + if ( H1_VALV == valve ) { setH1FPGACmd( 0 ); } - else if ( H19_VALV == activeValve ) + else if ( H19_VALV == valve ) { setH19FPGACmd( 0 ); } } - - - /*********************************************************************//** * @brief * The setPinchValveFpgaCommandBytePinchValveFpgaCommandByte function builds the FPGA command byte. @@ -971,13 +896,13 @@ /*********************************************************************//** * @brief * The isPinchValveCommandDone function checks the SPI command-done bit. -* @details \b Inputs: currentResponse -* @details \b Outputs: none +* @details \b Inputs: +* @details \b Outputs: * @return TRUE if the FPGA transaction is complete. *************************************************************************/ -static BOOL isPinchValveCommandDone( void ) +static BOOL isPinchValveCommandDone( VALVE_T valve ) { - return ( ( currentResponse.spiCmdStatus & PINCH_VALVE_SPI_DONE_BIT_MASK ) != 0 ); + return ( ( commandSpiStatus[ valve ] & PINCH_VALVE_SPI_DONE_BIT_MASK ) != 0 ); } /*********************************************************************//** @@ -988,9 +913,9 @@ * @details \b Outputs: none * @return TRUE if the controller fault bit is active. *************************************************************************/ -static BOOL isPinchValveControllerFaultActive( void ) +static BOOL isPinchValveControllerFaultActive( VALVE_T valve ) { - return ( ( currentResponse.spiCmdStatus & PINCH_VALVE_SPI_CONTROLLER_FAULT_BIT_MASK ) != 0 ); + return ( ( commandSpiStatus[ valve ] & PINCH_VALVE_SPI_CONTROLLER_FAULT_BIT_MASK ) != 0 ); } /*********************************************************************//** @@ -1001,9 +926,9 @@ * @details \b Outputs: none * @return TRUE if the error count changed. *************************************************************************/ -static BOOL didPinchValveErrorCountChange( void ) +static BOOL didPinchValveErrorCountChange( VALVE_T valve ) { - return ( currentResponse.errorCount != errorCountAtCommandStart ); + return ( commandErrorCount[ valve ] != errorCountAtCommandStart[ valve ] ); } /*********************************************************************//** @@ -1014,20 +939,20 @@ * @details \b Outputs: none * @return TRUE if reported counts match the command. *************************************************************************/ -static BOOL arePinchValveWordCountsValid( void ) +static BOOL arePinchValveWordCountsValid( VALVE_T valve ) { - U08 expectedTransmitCount = (U08)( activeCommand.inputWordCount + 1 ); - U08 transmittedCount = (U08)( ( currentResponse.spiCmdStatus & PINCH_VALVE_SPI_TX_COUNT_MASK ) >> PINCH_VALVE_SPI_TX_COUNT_SHIFT ); - U08 receivedCount = (U08)( ( currentResponse.spiCmdStatus & PINCH_VALVE_SPI_RX_COUNT_MASK ) >> PINCH_VALVE_SPI_RX_COUNT_SHIFT ); + U08 expectedTransmitCount = (U08)( activeCommand[ valve ].inputWordCount + 1U ); + U08 transmittedCount = (U08)( ( commandSpiStatus[ valve ] & PINCH_VALVE_SPI_TX_COUNT_MASK ) >> PINCH_VALVE_SPI_TX_COUNT_SHIFT ); + U08 receivedCount = (U08)( ( commandSpiStatus[ valve ] & PINCH_VALVE_SPI_RX_COUNT_MASK ) >> PINCH_VALVE_SPI_RX_COUNT_SHIFT ); - return ( ( transmittedCount == expectedTransmitCount ) && ( receivedCount == activeCommand.outputWordCount ) ); + return ( ( transmittedCount == expectedTransmitCount ) && ( receivedCount == activeCommand[ valve ].outputWordCount ) ); } /*********************************************************************//** * @brief * The readPinchValveErrorCount function returns the current error count for * the selected valve. -* @details \b Inputs: FPGA response registers +* @details \b Inputs: * @details \b Outputs: none * @param valve H1_VALV or H19_VALV. * @return Current error count, or 0 for an invalid valve. @@ -1044,10 +969,6 @@ { result = getH19ErrorCount(); } - else - { - // TODO: Check with Sean and Remove later ( Invalid valve ) - } return result; } @@ -1089,26 +1010,6 @@ return result; } -/*********************************************************************//** -* @brief -* The clearPinchValveResponse function clears a response structure. -* @details \b Inputs: response -* @details \b Outputs: response -* @param response Response structure to clear. -* @return none -*************************************************************************/ -static void clearPinchValveResponse( PINCH_VALVE_RESPONSE_T *response ) -{ - if ( response != 0 ) - { - response->outputWord1 = 0; - response->outputWord2 = 0; - response->outputWord3 = 0; - response->spiCmdStatus = 0; - response->readCount = 0; - response->errorCount = 0; - } -} /*********************************************************************//** * @brief @@ -1125,30 +1026,22 @@ U32 rawValue = (U32)value; command->inputWord1 = (U16)( ( rawValue >> 16 ) & 0xFFFF ); - command->inputWord2 = (U16)( rawValue & 0xFFFFU ); + command->inputWord2 = (U16)( rawValue & 0xFFFF ); } } /*********************************************************************//** * @brief * The getSigned32ResponseValue function combines two PMD output words. -* @details \b Inputs: response +* @details \b Inputs: * @details \b Outputs: none -* @param response PMD response. * @return Signed 32-bit value. *************************************************************************/ -static S32 getSigned32ResponseValue( const PINCH_VALVE_RESPONSE_T *response ) +static S32 getSigned32OutputValue( VALVE_T valve ) { - S32 result = 0; + U32 rawValue = ( (U32)commandOutputWord1[ valve ] << 16 ) | (U32)commandOutputWord2[ valve ]; - if ( response != 0 ) - { - U32 rawValue = ( (U32)response->outputWord1 << 16 ) | (U32)response->outputWord2; - - result = (S32)rawValue; - } - - return result; + return (S32)rawValue; } /**@}*/ Index: firmware/App/Drivers/PinchValve.h =================================================================== diff -u -r5b9b3a6bbbdc9257ddf01fdbe781a8f6748beafa -r73e17d7f9edcedb40fef1d905267ae629b8ace42 --- firmware/App/Drivers/PinchValve.h (.../PinchValve.h) (revision 5b9b3a6bbbdc9257ddf01fdbe781a8f6748beafa) +++ firmware/App/Drivers/PinchValve.h (.../PinchValve.h) (revision 73e17d7f9edcedb40fef1d905267ae629b8ace42) @@ -46,7 +46,7 @@ void setPinchValveEnableReset( VALVE_T valve, BOOL enable, BOOL reset ); U08 getPinchValveEnableReset( VALVE_T valve ); -BOOL isPinchValveBusy( void ); +BOOL isPinchValveBusy( VALVE_T valve ); /**@}*/