motor_ctl-3/User/Src/cadence_sensor.c

#include "cadence_sensor.h"

//局部变量定义
const uint8_t ForwardDir_EncoderData[4] = {2,0,3,1};//判断正转用的编码顺序表,正转时信号为：2，0，1，3
const uint8_t BackwardDir_EncoderData[4] = {1,3,0,2};//判断反转用的编码顺序表，反转时信号为：3，1，0，2

//全局变量定义
MC_CadenceResult_Struct_t MC_CadenceResult = {0, MC_Cadence_Stop, TRUE};
uint16_t MC_Cadence_Array[10] = {0};

/**************************局部函数定义*************************/

/**************************全局函数定义*************************/
uint8_t Cadence_ReadHallState(void)
{
  uint8_t CadenceValue;
  GPIO_PinState hall_a, hall_b;
	
	hall_a = HAL_GPIO_ReadPin(CADENCE_2_GPIO_Port, CADENCE_2_Pin);
	CadenceValue  = (uint8_t)hall_a;
	hall_b = HAL_GPIO_ReadPin(CADENCE_1_GPIO_Port, CADENCE_1_Pin);
	CadenceValue |= (uint8_t)hall_b << 1;
	return(CadenceValue & 0x03);
}

//踏频传感器IO初始化
void CadenceSensor_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct;
	
	__HAL_RCC_GPIOA_CLK_ENABLE();
	__HAL_RCC_GPIOB_CLK_ENABLE();
	
	GPIO_InitStruct.Pin = CADENCE_1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(CADENCE_1_GPIO_Port, &GPIO_InitStruct);
	
	GPIO_InitStruct.Pin = CADENCE_2_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(CADENCE_2_GPIO_Port, &GPIO_InitStruct);
	
}

//踏频传感器检测处理
void CadenceSensor_Process(MC_CadenceResult_Struct_t* p_MC_CadenceResult, uint16_t StopDelayTime)
{
	static MC_CadenceSensorStatus_Struct_t MC_CadenceSensorStatus;
	static TrueOrFalse_Flag_Struct_t IsFirstEnterFalg = TRUE;
	
	static uint8_t CadenceTest = 0;
	
	//读取霍尔信号
	MC_CadenceSensorStatus.HallGropuStatus = Cadence_ReadHallState();
	CadenceTest = MC_CadenceSensorStatus.HallGropuStatus & 0x01;
	if(IsFirstEnterFalg == TRUE)
	{
	  MC_CadenceSensorStatus.HallGropuStatus_Old = MC_CadenceSensorStatus.HallGropuStatus;
		IsFirstEnterFalg = FALSE;
	}
	//判断踏频正反转
	static uint16_t BackwordDelayCnt1 = 0;
	static uint16_t BackwordDelayCnt2 = 0;
	
	if(MC_CadenceSensorStatus.HallGropuStatus != MC_CadenceSensorStatus.HallGropuStatus_Old)
	{
	  if(MC_CadenceSensorStatus.HallGropuStatus_Old == ForwardDir_EncoderData[MC_CadenceSensorStatus.HallGropuStatus & 0x03])//上一次的编码，与正转的编码顺序一致，则为正转
		{
		  //正转
			p_MC_CadenceResult->Cadence_Dir = MC_Cadence_Forward;
			BackwordDelayCnt1 = 0;
			BackwordDelayCnt2 = 0;
		}
		else if(MC_CadenceSensorStatus.HallGropuStatus_Old == BackwardDir_EncoderData[MC_CadenceSensorStatus.HallGropuStatus & 0x03])//反转做延时判断
		{
		  //反转
			BackwordDelayCnt1++;
			if(BackwordDelayCnt1 >= 4)//检测到连续4次反向脉冲则判断为反转，约4/120*360=12度
			{
			  p_MC_CadenceResult->Cadence_Dir = MC_Cadence_Backward;
				BackwordDelayCnt1 = 0;
			}
		}
		else//蹋频波形异常情况下，延时判断为反转
		{
		  //反转
			BackwordDelayCnt2++;
			if(BackwordDelayCnt2 > 10)
			{
			  p_MC_CadenceResult->Cadence_Dir = MC_Cadence_Backward;
				BackwordDelayCnt2 = 0;
			}
		}
	}
	
	//踏频计算及启动和停止判断
	static uint32_t CadenceCalTimeCnt = 0;
	
	static uint8_t CadenceStarFlagCnt = 0;                                  //用于判断启动
	
	static uint32_t CadenceStopJudgeTimeCnt = 0;
	
	if((MC_CadenceSensorStatus.HallGropuStatus & 0x01) != (MC_CadenceSensorStatus.HallGropuStatus_Old & 0x01))
	{
	  //踏频计算
		p_MC_CadenceResult->Cadence_Data = 1000 / (HAL_GetTick() - CadenceCalTimeCnt);
		CadenceCalTimeCnt = HAL_GetTick();
		
		//起步判断
		if(p_MC_CadenceResult->Cadence_Dir == MC_Cadence_Forward)
		{
		  CadenceStarFlagCnt++;
			if(CadenceStarFlagCnt >= 2)
			{
			  p_MC_CadenceResult->IsStopFlag = FALSE;
			}
		}
		else
		{
		  p_MC_CadenceResult->IsStopFlag = TRUE;
		}
		
		//更新停机计时数值
		CadenceStopJudgeTimeCnt = HAL_GetTick();
	}
	
	//停机判断
	if((HAL_GetTick() - CadenceStopJudgeTimeCnt) > StopDelayTime)
	{
		p_MC_CadenceResult->IsStopFlag = TRUE;
		p_MC_CadenceResult->Cadence_Dir = MC_Cadence_Stop;
		p_MC_CadenceResult->Cadence_Data = 0;
		CadenceStarFlagCnt =0;
	}
	
	MC_CadenceSensorStatus.HallGropuStatus_Old = MC_CadenceSensorStatus.HallGropuStatus;
}