单片机 ：STM32F407
开发板：DMF407电机开发板
平台：keil V5.31
HSE 为8MHZ
HSI为16MHZ
原理图：
接线如下：
主函数：
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration--------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* USER CODE BEGIN Init */
/* USER CODE END Init */
/* Configure the system clock */
SystemClock_Config();
/* USER CODE BEGIN SysInit */
/* USER CODE END SysInit */
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_ADC1_Init();
MX_ADC2_Init();
MX_TIM1_Init();
MX_TIM4_Init();
MX_TIM5_Init();
MX_TIM8_Init();
MX_USART1_UART_Init();
MX_MotorControl_Init();
/* Initialize interrupts */
MX_NVIC_Init();
/* USER CODE BEGIN 2 */
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}电机按键触发启动：
void EXTI4_IRQHandler (void)
{
/* USER CODE BEGIN START_STOP_BTN */
if ( LL_EXTI_ReadFlag_0_31(LL_EXTI_LINE_4) )
{
LL_EXTI_ClearFlag_0_31 (LL_EXTI_LINE_4);
printf("press button to start machine!\n");
UI_HandleStartStopButton_cb ();
}
}
__weak void UI_HandleStartStopButton_cb (void)
{
/* USER CODE BEGIN START_STOP_BTN */
if (MC_GetSTMStateMotor1() == IDLE)
{
/* Ramp parameters should be tuned for the actual motor */
MC_StartMotor1();
}
else
{
MC_StopMotor1();
}
/* 手动添加 */
if (MC_GetSTMStateMotor2() == IDLE)
{
/* Ramp parameters should be tuned for the actual motor */
MC_StartMotor2();
}
else
{
MC_StopMotor2();
}
/* USER CODE END START_STOP_BTN */
}
__weak State_t MC_GetSTMStateMotor1(void)
{
printf("check state!\n");
return MCI_GetSTMState( pMCI[M1] );
}
__weak State_t MCI_GetSTMState( MCI_Handle_t * pHandle )
{
return STM_GetState( pHandle->pSTM );
}
__weak State_t STM_GetState( STM_Handle_t * pHandle )
{
//printf("check state!\n");
return ( pHandle->bState );
}
__weak bool MC_StartMotor1(void)
{
printf("start!\n");
return MCI_StartMotor( pMCI[M1] );
}
__weak bool MCI_StartMotor( MCI_Handle_t * pHandle )
{
bool RetVal = STM_NextState( pHandle->pSTM, IDLE_START );
if ( RetVal == true )
{
// printf("start!\n");
pHandle->CommandState = MCI_COMMAND_NOT_ALREADY_EXECUTED;
}
return RetVal;
}
__weak void MCI_ExecBufferedCommands( MCI_Handle_t * pHandle )
{
if ( pHandle != MC_NULL )
{
if ( pHandle->CommandState == MCI_COMMAND_NOT_ALREADY_EXECUTED )
{
// printf("exec\n");
bool commandHasBeenExecuted = false;
switch ( pHandle->lastCommand )
{
case MCI_EXECSPEEDRAMP:
{
pHandle->pFOCVars->bDriveInput = INTERNAL;
STC_SetControlMode( pHandle->pSTC, STC_SPEED_MODE );
commandHasBeenExecuted = STC_ExecRamp( pHandle->pSTC, pHandle->hFinalSpeed, pHandle->hDurationms );
}
break;
case MCI_EXECTORQUERAMP:
{
pHandle->pFOCVars->bDriveInput = INTERNAL;
STC_SetControlMode( pHandle->pSTC, STC_TORQUE_MODE );
commandHasBeenExecuted = STC_ExecRamp( pHandle->pSTC, pHandle->hFinalTorque, pHandle->hDurationms );
}
break;
case MCI_SETCURRENTREFERENCES:
{
pHandle->pFOCVars->bDriveInput = EXTERNAL;
pHandle->pFOCVars->Iqdref = pHandle->Iqdref;
commandHasBeenExecuted = true;
}
break;
default:
break;
}
if ( commandHasBeenExecuted )
{
pHandle->CommandState = MCI_COMMAND_EXECUTED_SUCCESFULLY;
}
else
{
pHandle->CommandState = MCI_COMMAND_EXECUTED_UNSUCCESFULLY;
}
}
}
}
__weak void MCI_ExecSpeedRamp( MCI_Handle_t * pHandle, int16_t hFinalSpeed, uint16_t hDurationms )
{
printf("MCI_ExecSpeedRamp\n");
pHandle->lastCommand = MCI_EXECSPEEDRAMP;
pHandle->hFinalSpeed = hFinalSpeed;
pHandle->hDurationms = hDurationms;
pHandle->CommandState = MCI_COMMAND_NOT_ALREADY_EXECUTED;
pHandle->LastModalitySetByUser = STC_SPEED_MODE;
}电机：
__weak void MX_MotorControl_Init(void)
{
/* Reconfigure the SysTick interrupt to fire every 500 us. */
HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/SYS_TICK_FREQUENCY);
/* Initialize the Motor Control Subsystem */
MCboot(pMCI,pMCT);
mc_lock_pins();
/* Initialize the MC User Interface */
UI_TaskInit(wConfig,NBR_OF_MOTORS,pMCI,pMCT,s_fwVer);
}
__weak void MCboot( MCI_Handle_t* pMCIList[NBR_OF_MOTORS],MCT_Handle_t* pMCTList[NBR_OF_MOTORS] )
{
/* USER CODE BEGIN MCboot 0 */
/* USER CODE END MCboot 0 */
/**************************************/
/* State machine initialization */
/**************************************/
printf("MCboot\n");
STM_Init(&STM[M1]);
bMCBootCompleted = 0;
pCLM[M1] = &CircleLimitationM1;
pFW[M1] = &FW_M1; /* only if M1 has FW */
pCLM[M2] = &CircleLimitationM2;
pFW[M2] = &FW_M2; /* only if M2 has FW */
/**********************************************************/
/* PWM and current sensing component initialization */
/**********************************************************/
pwmcHandle[M1] = &PWM_Handle_M1._Super;
R3_2_Init(&PWM_Handle_M1);
pwmcHandle[M2] = &PWM_Handle_M2._Super;
R3_2_Init(&PWM_Handle_M2);
/* USER CODE BEGIN MCboot 1 */
/* USER CODE END MCboot 1 */
/**************************************/
/* Start timers synchronously */
/**************************************/
startTimers();
/******************************************************/
/* PID component initialization: speed regulation */
/******************************************************/
PID_HandleInit(&PIDSpeedHandle_M1);
pPIDSpeed[M1] = &PIDSpeedHandle_M1;
/******************************************************/
/* Main speed sensor component initialization */
/******************************************************/
pSTC[M1] = &SpeednTorqCtrlM1;
HALL_Init (&HALL_M1);
/******************************************************/
/* Speed & torque component initialization */
/******************************************************/
STC_Init(pSTC[M1],pPIDSpeed[M1], &HALL_M1._Super);
/********************************************************/
/* PID component initialization: current regulation */
/********************************************************/
PID_HandleInit(&PIDIqHandle_M1);
PID_HandleInit(&PIDIdHandle_M1);
pPIDIq[M1] = &PIDIqHandle_M1;
pPIDId[M1] = &PIDIdHandle_M1;
/********************************************************/
/* Bus voltage sensor component initialization */
/********************************************************/
pBusSensorM1 = &RealBusVoltageSensorParamsM1;
RVBS_Init(pBusSensorM1);
/*************************************************/
/* Power measurement component initialization */
/*************************************************/
pMPM[M1] = &PQD_MotorPowMeasM1;
pMPM[M1]->pVBS = &(pBusSensorM1->_Super);
pMPM[M1]->pFOCVars = &FOCVars[M1];
/*******************************************************/
/* Temperature measurement component initialization */
/*******************************************************/
NTC_Init(&TempSensorParamsM1);
pTemperatureSensor[M1] = &TempSensorParamsM1;
/*******************************************************/
/* Flux weakening component initialization */
/*******************************************************/
PID_HandleInit(&PIDFluxWeakeningHandle_M1);
FW_Init(pFW[M1],pPIDSpeed[M1],&PIDFluxWeakeningHandle_M1);
pREMNG[M1] = &RampExtMngrHFParamsM1;
REMNG_Init(pREMNG[M1]);
FOC_Clear(M1);
FOCVars[M1].bDriveInput = EXTERNAL;
FOCVars[M1].Iqdref = STC_GetDefaultIqdref(pSTC[M1]);
FOCVars[M1].UserIdref = STC_GetDefaultIqdref(pSTC[M1]).d;
oMCInterface[M1] = & Mci[M1];
MCI_Init(oMCInterface[M1], &STM[M1], pSTC[M1], &FOCVars[M1] );
MCI_ExecSpeedRamp(oMCInterface[M1],
STC_GetMecSpeedRefUnitDefault(pSTC[M1]),0); /*First command to STC*/
pMCIList[M1] = oMCInterface[M1];
MCT[M1].pPIDSpeed = pPIDSpeed[M1];
MCT[M1].pPIDIq = pPIDIq[M1];
MCT[M1].pPIDId = pPIDId[M1];
MCT[M1].pPIDFluxWeakening = &PIDFluxWeakeningHandle_M1; /* only if M1 has FW */
MCT[M1].pPWMnCurrFdbk = pwmcHandle[M1];
MCT[M1].pRevupCtrl = MC_NULL; /* only if M1 is not sensorless*/
MCT[M1].pSpeedSensorMain = (SpeednPosFdbk_Handle_t *) &HALL_M1;
MCT[M1].pSpeedSensorAux = MC_NULL;
MCT[M1].pSpeedSensorVirtual = MC_NULL;
MCT[M1].pSpeednTorqueCtrl = pSTC[M1];
MCT[M1].pStateMachine = &STM[M1];
MCT[M1].pTemperatureSensor = (NTC_Handle_t *) pTemperatureSensor[M1];
MCT[M1].pBusVoltageSensor = &(pBusSensorM1->_Super);
MCT[M1].pBrakeDigitalOutput = MC_NULL; /* brake is defined, oBrakeM1*/
MCT[M1].pNTCRelay = MC_NULL; /* relay is defined, oRelayM1*/
MCT[M1].pMPM = (MotorPowMeas_Handle_t*)pMPM[M1];
MCT[M1].pFW = pFW[M1];
MCT[M1].pFF = MC_NULL;
MCT[M1].pPosCtrl = MC_NULL;
MCT[M1].pSCC = MC_NULL;
MCT[M1].pOTT = MC_NULL;
pMCTList[M1] = &MCT[M1];
/******************************************************/
/* Motor 2 features initialization */
/******************************************************/
/**************************************/
/* State machine initialization */
/**************************************/
STM_Init(&STM[M2]);
/******************************************************/
/* PID component initialization: speed regulation */
/******************************************************/
PID_HandleInit(&PIDSpeedHandle_M2);
pPIDSpeed[M2] = &PIDSpeedHandle_M2;
/***********************************************************/
/* Main speed sensor initialization: speed regulation */
/***********************************************************/
pSTC[M2] = &SpeednTorqCtrlM2;
HALL_Init (&HALL_M2);
/******************************************************/
/* Speed & torque component initialization */
/******************************************************/
STC_Init(pSTC[M2],pPIDSpeed[M2], &HALL_M2._Super);
/********************************************************/
/* PID component initialization: current regulation */
/********************************************************/
PID_HandleInit(&PIDIqHandle_M2);
PID_HandleInit(&PIDIdHandle_M2);
pPIDIq[M2] = &PIDIqHandle_M2;
pPIDId[M2] = &PIDIdHandle_M2;
/**********************************************************/
/* Bus voltage sensor component initialization */
/**********************************************************/
pBusSensorM2 = &RealBusVoltageSensorParamsM2; /* powerboard configuration: Rdivider or Virtual*/
RVBS_Init(pBusSensorM2);
/*************************************************/
/* Power measurement component initialization */
/*************************************************/
pMPM[M2] = &PQD_MotorPowMeasM2;
pMPM[M2]->pVBS = &(pBusSensorM2->_Super);
pMPM[M2]->pFOCVars = &FOCVars[M2];
/*******************************************************/
/* Temperature measurement component initialization */
/*******************************************************/
NTC_Init(&TempSensorParamsM2);
pTemperatureSensor[M2] = &TempSensorParamsM2;
/*************************************************/
/* Flux weakening component initialization */
/*************************************************/
PID_HandleInit(&PIDFluxWeakeningHandle_M2);
FW_Init(pFW[M2],pPIDSpeed[M2],&PIDFluxWeakeningHandle_M2); /* only if M2 has FW */
pREMNG[M2] = &RampExtMngrHFParamsM2;
REMNG_Init(pREMNG[M2]);
FOC_Clear(M2);
FOCVars[M2].bDriveInput = EXTERNAL;
FOCVars[M2].Iqdref = STC_GetDefaultIqdref(pSTC[M2]);
FOCVars[M2].UserIdref = STC_GetDefaultIqdref(pSTC[M2]).d;
oMCInterface[M2] = &Mci[M2];
MCI_Init(oMCInterface[M2], &STM[M2], pSTC[M2], &FOCVars[M2] );
MCI_ExecSpeedRamp(oMCInterface[M2],
STC_GetMecSpeedRefUnitDefault(pSTC[M2]),0); /*First command to STC*/
pMCIList[M2] = oMCInterface[M2];
MCT[M2].pPIDSpeed = pPIDSpeed[M2];
MCT[M2].pPIDIq = pPIDIq[M2];
MCT[M2].pPIDId = pPIDId[M2];
MCT[M2].pPIDFluxWeakening = &PIDFluxWeakeningHandle_M2; /* only if M2 has FW */
MCT[M2].pPWMnCurrFdbk = pwmcHandle[M2];
MCT[M2].pRevupCtrl = MC_NULL; /* only if M2 is not sensorless*/
MCT[M2].pSpeedSensorMain = (SpeednPosFdbk_Handle_t *) &HALL_M2;
MCT[M2].pSpeedSensorAux = MC_NULL;
MCT[M2].pSpeedSensorVirtual = MC_NULL;
MCT[M2].pSpeednTorqueCtrl = pSTC[M2];
MCT[M2].pStateMachine = &STM[M2];
MCT[M2].pTemperatureSensor = (NTC_Handle_t *) pTemperatureSensor[M2];
MCT[M2].pBusVoltageSensor = &(pBusSensorM2->_Super);
MCT[M2].pBrakeDigitalOutput = MC_NULL; /* brake is defined, oBrakeM2*/
MCT[M2].pNTCRelay = MC_NULL; /* relay is defined, oRelayM2*/
MCT[M2].pMPM = (MotorPowMeas_Handle_t*)pMPM[M2];
MCT[M2].pFW = pFW[M2];
MCT[M2].pFF = MC_NULL;
MCT[M2].pPosCtrl = MC_NULL;
MCT[M2].pSCC = MC_NULL;
pMCTList[M2] = &MCT[M2];
/* USER CODE BEGIN MCboot 2 */
/* USER CODE END MCboot 2 */
bMCBootCompleted = 1;
}
__weak void STM_Init( STM_Handle_t * pHandle )
{
pHandle->bState = IDLE;
pHandle->hFaultNow = MC_NO_FAULTS;
pHandle->hFaultOccurred = MC_NO_FAULTS;
}
__weak void R3_2_Init( PWMC_R3_2_Handle_t * pHandle )
{
TIM_TypeDef * TIMx = pHandle->pParams_str->TIMx;
ADC_TypeDef * ADCx_1 = pHandle->pParams_str->ADCx_1;
ADC_TypeDef * ADCx_2 = pHandle->pParams_str->ADCx_2;
LL_TIM_DisableCounter( TIMx );
/* BKIN, if enabled */
if ( (pHandle->pParams_str->EmergencyStop) != DISABLE )
{
LL_TIM_ClearFlag_BRK(TIMx);
LL_TIM_EnableIT_BRK(TIMx);
}
/* Prepare timer for synchronization */
LL_TIM_GenerateEvent_UPDATE(TIMx);
if ( pHandle->pParams_str->bFreqRatio == 2u )
{
if ( pHandle->pParams_str->bIsHigherFreqTim == HIGHER_FREQ )
{
if ( pHandle->pParams_str->RepetitionCounter == 3u )
{
/* Set TIMx repetition counter to 1 */
LL_TIM_SetRepetitionCounter( TIMx, 1u );
LL_TIM_GenerateEvent_UPDATE( TIMx );
/* Repetition counter will be set to 3 at next Update */
LL_TIM_SetRepetitionCounter( TIMx, 3 );
}
}
LL_TIM_SetCounter( TIMx, ( uint32_t )( pHandle->Half_PWMPeriod ) - 1u );
}
else /* FreqRatio equal to 1 or 3 */
{
if ( pHandle->_Super.Motor == M1 )
{
LL_TIM_SetCounter( TIMx, ( uint32_t )( pHandle->Half_PWMPeriod ) - 1u );
}
}
/* Enable PWM channel */
LL_TIM_CC_EnableChannel( TIMx, TIMxCCER_MASK_CH123 );
if ( TIMx == TIM1 )
{
/* TIM1 Counter Clock stopped when the core is halted */
LL_DBGMCU_APB2_GRP1_FreezePeriph(LL_DBGMCU_APB2_GRP1_TIM1_STOP);
pHandle->ADC_ExternalTriggerInjected = LL_ADC_INJ_TRIG_EXT_TIM1_CH4;
}
else
{
/* TIM8 Counter Clock stopped when the core is halted */
LL_DBGMCU_APB2_GRP1_FreezePeriph(LL_DBGMCU_APB2_GRP1_TIM8_STOP);
pHandle->ADC_ExternalTriggerInjected = LL_ADC_INJ_TRIG_EXT_TIM8_CH4;
}
/* ADCs registers configuration ---------------------------------*/
/* Enable ADCx_1 and ADCx_2 */
LL_ADC_Enable( ADCx_1 );
LL_ADC_Enable( ADCx_2 );
/* ADCx_1 Injected conversions end interrupt enabling */
LL_ADC_ClearFlag_JEOS(ADCx_1);
LL_ADC_EnableIT_JEOS( ADCx_1 );
/* reset regular conversion sequencer length set by cubeMX */
LL_ADC_REG_SetSequencerLength( ADCx_1, LL_ADC_REG_SEQ_SCAN_DISABLE );
LL_ADC_INJ_SetSequencerLength( ADCx_1, LL_ADC_INJ_SEQ_SCAN_DISABLE );
LL_ADC_INJ_SetSequencerLength( ADCx_2, LL_ADC_INJ_SEQ_SCAN_DISABLE );
pHandle->ADCTriggerEdge = LL_ADC_INJ_TRIG_EXT_RISING;
pHandle->_Super.DTTest = 0u;
}定时器：
void SysTick_Handler(void)
{
#ifdef MC_HAL_IS_USED
static uint8_t SystickDividerCounter = SYSTICK_DIVIDER;
/* USER CODE BEGIN SysTick_IRQn 0 */
/* USER CODE END SysTick_IRQn 0 */
if (SystickDividerCounter == SYSTICK_DIVIDER)
{
HAL_IncTick();
HAL_SYSTICK_IRQHandler();
SystickDividerCounter = 0;
}
SystickDividerCounter ++;
#endif /* MC_HAL_IS_USED */
/* USER CODE BEGIN SysTick_IRQn 1 */
/* USER CODE END SysTick_IRQn 1 */
MC_RunMotorControlTasks();
/* USER CODE BEGIN SysTick_IRQn 2 */
/* USER CODE END SysTick_IRQn 2 */
}
__weak void MC_RunMotorControlTasks(void)
{
if ( bMCBootCompleted ) {
/* ** Medium Frequency Tasks ** */
MC_Scheduler();
/* Safety task is run after Medium Frequency task so that
* it can overcome actions they initiated if needed. */
TSK_SafetyTask();
/* ** User Interface Task ** */
UI_Scheduler();
}
}
__weak void MC_Scheduler(void)
{
/* USER CODE BEGIN MC_Scheduler 0 */
/* USER CODE END MC_Scheduler 0 */
if (bMCBootCompleted == 1)
{
if(hMFTaskCounterM1 > 0u)
{
hMFTaskCounterM1--;
}
else
{
TSK_MediumFrequencyTaskM1();
/* USER CODE BEGIN MC_Scheduler 1 */
/* USER CODE END MC_Scheduler 1 */
hMFTaskCounterM1 = MF_TASK_OCCURENCE_TICKS;
}
if(hMFTaskCounterM2 > 0u)
{
hMFTaskCounterM2--;
}
else
{
TSK_MediumFrequencyTaskM2();
/* USER CODE BEGIN MC_Scheduler MediumFrequencyTask M2 */
/* USER CODE END MC_Scheduler MediumFrequencyTask M2 */
hMFTaskCounterM2 = MF_TASK_OCCURENCE_TICKS2;
}
if(hBootCapDelayCounterM1 > 0u)
{
hBootCapDelayCounterM1--;
}
if(hStopPermanencyCounterM1 > 0u)
{
hStopPermanencyCounterM1--;
}
if(hBootCapDelayCounterM2 > 0u)
{
hBootCapDelayCounterM2--;
}
if(hStopPermanencyCounterM2 > 0u)
{
hStopPermanencyCounterM2--;
}
}
else
{
}
/* USER CODE BEGIN MC_Scheduler 2 */
/* USER CODE END MC_Scheduler 2 */
}
__weak void TSK_SafetyTask(void)
{
/* USER CODE BEGIN TSK_SafetyTask 0 */
/* USER CODE END TSK_SafetyTask 0 */
if (bMCBootCompleted == 1)
{
TSK_SafetyTask_PWMOFF(M1);
/* Second drive */
TSK_SafetyTask_PWMOFF(M2);
/* User conversion execution */
RCM_ExecUserConv ();
/* USER CODE BEGIN TSK_SafetyTask 1 */
/* USER CODE END TSK_SafetyTask 1 */
}
}
__weak void UI_Scheduler(void)
{
if(bUITaskCounter > 0u)
{
bUITaskCounter--;
}
if(bCOMTimeoutCounter > 1u)
{
bCOMTimeoutCounter--;
}
if(bCOMATRTimeCounter > 1u)
{
bCOMATRTimeCounter--;
}
}
__weak void TSK_MediumFrequencyTaskM1(void)
{
/* USER CODE BEGIN MediumFrequencyTask M1 0 */
/* USER CODE END MediumFrequencyTask M1 0 */
State_t StateM1;
int16_t wAux = 0;
bool IsSpeedReliable = HALL_CalcAvrgMecSpeedUnit( &HALL_M1, &wAux );
PQD_CalcElMotorPower( pMPM[M1] );
StateM1 = STM_GetState( &STM[M1] );
switch ( StateM1 )
{
case IDLE_START:
R3_2_TurnOnLowSides( pwmcHandle[M1] );
TSK_SetChargeBootCapDelayM1( CHARGE_BOOT_CAP_TICKS );
STM_NextState( &STM[M1], CHARGE_BOOT_CAP );
break;
case CHARGE_BOOT_CAP:
if ( TSK_ChargeBootCapDelayHasElapsedM1() )
{
PWMC_CurrentReadingCalibr( pwmcHandle[M1], CRC_START );
/* USER CODE BEGIN MediumFrequencyTask M1 Charge BootCap elapsed */
/* USER CODE END MediumFrequencyTask M1 Charge BootCap elapsed */
STM_NextState(&STM[M1],OFFSET_CALIB);
}
break;
case OFFSET_CALIB:
if ( PWMC_CurrentReadingCalibr( pwmcHandle[M1], CRC_EXEC ) )
{
STM_NextState( &STM[M1], CLEAR );
}
break;
case CLEAR:
HALL_Clear( &HALL_M1 );
if ( STM_NextState( &STM[M1], START ) == true )
{
FOC_Clear( M1 );
R3_2_SwitchOnPWM( pwmcHandle[M1] );
}
break;
case START:
{
STM_NextState( &STM[M1], START_RUN ); /* only for sensored*/
}
break;
case START_RUN:
{
/* USER CODE BEGIN MediumFrequencyTask M1 1 */
/* USER CODE END MediumFrequencyTask M1 1 */
FOC_InitAdditionalMethods(M1);
FOC_CalcCurrRef( M1 );
STM_NextState( &STM[M1], RUN );
}
STC_ForceSpeedReferenceToCurrentSpeed( pSTC[M1] ); /* Init the reference speed to current speed */
MCI_ExecBufferedCommands( oMCInterface[M1] ); /* Exec the speed ramp after changing of the speed sensor */
break;
case RUN:
/* USER CODE BEGIN MediumFrequencyTask M1 2 */
/* USER CODE END MediumFrequencyTask M1 2 */
MCI_ExecBufferedCommands( oMCInterface[M1] );
FOC_CalcCurrRef( M1 );
if( !IsSpeedReliable )
{
STM_FaultProcessing( &STM[M1], MC_SPEED_FDBK, 0 );
}
/* USER CODE BEGIN MediumFrequencyTask M1 3 */
/* USER CODE END MediumFrequencyTask M1 3 */
break;
case ANY_STOP:
R3_2_SwitchOffPWM( pwmcHandle[M1] );
FOC_Clear( M1 );
MPM_Clear( (MotorPowMeas_Handle_t*) pMPM[M1] );
TSK_SetStopPermanencyTimeM1( STOPPERMANENCY_TICKS );
/* USER CODE BEGIN MediumFrequencyTask M1 4 */
/* USER CODE END MediumFrequencyTask M1 4 */
STM_NextState( &STM[M1], STOP );
break;
case STOP:
if ( TSK_StopPermanencyTimeHasElapsedM1() )
{
STM_NextState( &STM[M1], STOP_IDLE );
}
break;
case STOP_IDLE:
/* USER CODE BEGIN MediumFrequencyTask M1 5 */
/* USER CODE END MediumFrequencyTask M1 5 */
STM_NextState( &STM[M1], IDLE );
break;
default:
break;
}
/* USER CODE BEGIN MediumFrequencyTask M1 6 */
/* USER CODE END MediumFrequencyTask M1 6 */
}