自学教程：C++ HAL_TIM_ReadCapturedValue函数代码示例

/**  * @brief  Conversion complete callback in non blocking mode   * @param  htim: TIM handle  * @retval None  */void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim){  if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2)  {    if(uhCaptureIndex == 0)    {      /* Get the 1st Input Capture value */      uwIC2Value1 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_2);      uhCaptureIndex = 1;    }    else if(uhCaptureIndex == 1)    {      /* Get the 2nd Input Capture value */      uwIC2Value2 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_2);             /* Capture computation */      if (uwIC2Value2 > uwIC2Value1)      {        uwDiffCapture = (uwIC2Value2 - uwIC2Value1);       }      else  /* (uwIC2Value2 <= uwIC2Value1) */      {        uwDiffCapture = ((0xFFFF - uwIC2Value1) + uwIC2Value2);       }      /* Frequency computation: for this example TIMx (TIM1) is clocked by         2xAPB2Clk */            uwFrequency = (2*HAL_RCC_GetPCLK2Freq()) / uwDiffCapture;      uhCaptureIndex = 0;    }   }}

/**  * @brief  Conversion complete callback in non blocking mode   * @param  htim : htim handle  * @retval None  */void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim){  if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_4)  {    if(uhCaptureIndex == 0)    {      /* Get the 1st Input Capture value */      uwIC2Value1 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_4);      uhCaptureIndex = 1;    }    else if(uhCaptureIndex == 1)    {      /* Get the 2nd Input Capture value */      uwIC2Value2 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_4);             /* Capture computation */      if (uwIC2Value2 > uwIC2Value1)      {        uwDiffCapture = (uwIC2Value2 - uwIC2Value1);       }      else if (uwIC2Value2 < uwIC2Value1)      {        uwDiffCapture = ((0xFFFF - uwIC2Value1) + uwIC2Value2);       }      else      {        uwDiffCapture = 0;      }      /* Compute the pulse width in us */      uwMeasuredPulse = (uint32_t)(((uint64_t) uwDiffCapture * 1000000) / HAL_RCC_GetPCLK1Freq());      uhCaptureIndex = 0;    }      }}

/**  * @brief  Output Compare callback in non blocking mode   * @param  htim : TIM OC handle  * @retval None  */void HAL_TIM_OC_DelayElapsedCallback(TIM_HandleTypeDef *htim){  /* TIM3_CH1 toggling with frequency = 195 Hz */  if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1)  {    uhCapture = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);    /* Set the Capture Compare Register value */    __HAL_TIM_SET_COMPARE(&TimHandle, TIM_CHANNEL_1, (uhCapture + uhCCR1_Val));  }    /* TIM3_CH2 toggling with frequency = 390 Hz */  if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2)  {    uhCapture = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_2);    /* Set the Capture Compare Register value */    __HAL_TIM_SET_COMPARE(&TimHandle, TIM_CHANNEL_2, (uhCapture + uhCCR2_Val));     }    /* TIM3_CH3 toggling with frequency = 780 Hz */  if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_3)  {    uhCapture = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_3);    /* Set the Capture Compare Register value */    __HAL_TIM_SET_COMPARE(&TimHandle, TIM_CHANNEL_3, (uhCapture + uhCCR3_Val));  }    /* TIM3_CH4 toggling with frequency = 1560 Hz */  if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_4)  {    uhCapture = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_4);    /* Set the Capture Compare Register value */    __HAL_TIM_SET_COMPARE(&TimHandle, TIM_CHANNEL_4, (uhCapture + uhCCR4_Val));  }}

/**  * @brief  获得两次时间间隔中的编码器读数差.  * @param  None  * @retval None  */	void Get_Speed(void){  uint32_t TempL,TempR;    TempL=HAL_TIM_ReadCapturedValue(&TimHandleT9, TIM_CHANNEL_1);//编码器读取    Speed_L=TempL;	/*	Speed_L=TempL-Pre_Speed_L;    Pre_Speed_L=TempL;      if(Speed_L<-20000){       Speed_L+=65535;}    else   if(Speed_L>20000){    Speed_L-=65535;} 	*/    TempR=HAL_TIM_ReadCapturedValue(&TimHandleT5, TIM_CHANNEL_1);//编码器读取				Speed_R=TempR;		/*    Speed_R=TempR-Pre_Speed_R;    Pre_Speed_R=TempR;      if(Speed_R<-20000){       Speed_R+=65535;}    else   if(Speed_R>20000){    Speed_R-=65535;} 		//一阶低通滤波    Speed_A_Last=(Speed_L-Speed_R)/2;		Speed_A*=0.7;    Speed_A+=Speed_A_Last*0.3;  		*/}

/**  * @brief  Conversion complete callback in non blocking mode  * @param  htim: TIM handle  * @retval None  */void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim){	uint16_t captureVal;	if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1) {		captureVal = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);		motorHallTimoutCnt[0] = 0;		motorHallPeriode[0] = captureVal - motorHallLastCapVal[0];		motorHallLastCapVal[0] = captureVal;	}	if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2) {		captureVal = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_2);		motorHallTimoutCnt[0] = 0;		motorHallPeriode[0] = captureVal - motorHallLastCapVal[1];		motorHallLastCapVal[1] = captureVal;	}	if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_3) {		captureVal = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_3);		motorHallTimoutCnt[1] = 0;		motorHallPeriode[1] = captureVal - motorHallLastCapVal[2];		motorHallLastCapVal[2] = captureVal;	}	if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_4) {		captureVal = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_4);		motorHallTimoutCnt[1] = 0;		motorHallPeriode[1] =  captureVal - motorHallLastCapVal[3];		motorHallLastCapVal[3] = captureVal;	}}

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim){    if(edge == TIM_INPUTCHANNELPOLARITY_RISING) {        edge = TIM_INPUTCHANNELPOLARITY_FALLING;        capture_value_raising = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);    }    else if(edge == TIM_INPUTCHANNELPOLARITY_FALLING) {        capture_value_falling = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);        float capture_value = capture_value_falling - capture_value_raising;        distance = ((sonic_velocity * (capture_value / tim_clock)) / 2.0) * 10000; // mm        USBD_CUSTOM_HID_SendReport(&hUsbDeviceFS, (uint8_t*)&distance, CUSTOM_HID_EPOUT_SIZE);    }}

// Callback for sonar echovoid HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim){	int idx;	uint32_t ic_val = 0;	// >>>>> Which sonar has received the echo?	if (htim->Instance == TIM2)	{		idx = SONAR_0;		elapsed_tick[idx] = HAL_GetTick() - trigger_tick[COUPLE_0_2];		// Update Input Capture times		ic_val = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_2);	}	else if (htim->Instance == TIM3)	{		idx = SONAR_1;		elapsed_tick[idx] = HAL_GetTick() - trigger_tick[COUPLE_0_2];		// Update Input Capture times		ic_val = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_2);	}	else if (htim->Instance == TIM4)	{		idx = SONAR_2;		elapsed_tick[idx] = HAL_GetTick() - trigger_tick[COUPLE_1_3];		// Update Input Capture times		ic_val = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_2);	}	else if (htim->Instance == TIM5)	{		idx = SONAR_3;		elapsed_tick[idx] = HAL_GetTick() - trigger_tick[COUPLE_1_3];		// Update Input Capture times		ic_val = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);	}	else		return; // Should never be here!!!	// <<<<< Which sonar has received the echo?	// >>>>> Durations update	if (ic_val > MAX_DURATION_10_USEC)		distValid[idx] = 0;	else		distValid[idx] = 1;	echo_duration[idx] = ic_val;	// <<<<< Durations update}

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim){    uint32_t CCRx_tn=0, CCRx_tn_1=0;    if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1) {        CCRx_tn = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);        if(htim->Instance == TIM3x) {            RC2_tn = CCRx_tn;            intflag2 = 0;        } else if(htim->Instance == TIM4x) {            RC3_tn = CCRx_tn;            intflag3 = 0;        }    } else if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2) {        CCRx_tn_1 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_2);	// Input capture value        if(htim->Instance == TIM3x) {            RC2_tn_1 = CCRx_tn_1;            intflag2 = 1;        } else if(htim->Instance == TIM4x) {            RC3_tn_1 = CCRx_tn_1;            intflag3 = 1;        }    } else if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_3) {        CCRx_tn = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_3);        if(htim->Instance == TIM3x) {            RC1_tn = CCRx_tn;            intflag1 = 0;        } else if(htim->Instance == TIM4x) {            RC4_tn = CCRx_tn;            intflag4 = 0;        }    } else if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_4) {        CCRx_tn_1 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_4);	// Input capture value        if(htim->Instance == TIM3x) {            RC1_tn_1 = CCRx_tn_1;            intflag1 = 1;        } else if(htim->Instance == TIM4x) {            RC4_tn_1 = CCRx_tn_1;            intflag4 = 1;        }//		ExpLedToggle(GREEN_LED);    }}

// Timer 17 update and capture compare interruptvoid TIM1_TRG_COM_TIM17_IRQHandler(void){  if(__HAL_TIM_GET_FLAG(&TimHandle[0], TIM_FLAG_CC1) != RESET)  {    if(__HAL_TIM_GET_ITSTATUS(&TimHandle[0], TIM_IT_CC1) !=RESET)    {      {        __HAL_TIM_CLEAR_IT(&TimHandle[0], TIM_IT_CC1);                encoderSpeed[0] = HAL_TIM_ReadCapturedValue(&TimHandle[0], TIM_CHANNEL_1);                TIM17->CNT = 0;      }    }  }    if(__HAL_TIM_GET_FLAG(&TimHandle[0], TIM_FLAG_UPDATE) != RESET)  {    if(__HAL_TIM_GET_ITSTATUS(&TimHandle[0], TIM_IT_UPDATE) !=RESET)    {       __HAL_TIM_CLEAR_IT(&TimHandle[0], TIM_IT_UPDATE);      encoderSpeed[0] = PERIOD;    // If timer expires we have got no pulse during measurment period, set max time    }  }}

/* USER CODE BEGIN 0 */void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim){	uint8_t i;	uint16_t temp;	temp = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);	if ((temp > 5000) && (!data_ready))	{		pointer = 0;		for (i = 0; i < 4; i++)		{			if (captured_value[i] < 1000)				captured_value[i] = 1000;			else if (captured_value[i] > 2000)				captured_value[i] = 2000;			rc_data[i] = captured_value[i]-1000;		};		rc_data[4] = 0;		if (captured_value[4] > 1500)			rc_data[4] |= (1<<4);		if (captured_value[5] > 1500)			rc_data[4] |= (1<<5);		if (captured_value[6] > 1500)			rc_data[4] |= (1<<6);		if (captured_value[7] > 1500)			rc_data[4] |= (1<<7);		data_ready = 1;	}	else	{		captured_value[pointer] = temp;		pointer++;	};	if (pointer == 8) 		pointer = 0;	};

/**  * @brief  Output Compare callback in non blocking mode   * @param  htim: TIM OC handle  * @retval None  */void HAL_TIM_OC_DelayElapsedCallback(TIM_HandleTypeDef *htim){  uint32_t capture = 0;   /* Get the TIM4 Input Capture 1 value */  capture = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);    /* Set the TIM4 Capture Compare1 Register value */  __HAL_TIM_SET_COMPARE(htim, TIM_CHANNEL_1, (CCR1Val + capture));}

void detect(DETECTORSTATUS *st, TIM_HandleTypeDef *htim){	int8_t		shift;	int16_t		diff;	uint16_t	lastDelta;	uint16_t	capturedValue;	if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1)	{		capturedValue = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);		if(st->initialized)		{			lastDelta = capturedValue - st->prevCapture;			st->accumulator += lastDelta;			//st->debug[st->counter] = lastDelta;			if(++st->counter == g_config.mccount)			{				//HAL_GPIO_TogglePin(ACTIVE1_GPIO_Port, ACTIVE1_Pin);				st->lastMeasured = st->accumulator;				st->accumulator = 0;				st->counter = 0;				if(!st->sum)					st->sum = (uint32_t)st->lastMeasured << g_config.sumshift;				else				{					st->avg = st->sum >> g_config.sumshift;					st->threshold = st->avg / g_config.thdiv;					st->diff = (int32_t)st->lastMeasured - st->avg;					st->tolerance = st->threshold >> SHIFT_TOLERANCE;					diff = -st->diff;					if (diff < 0)						st->state = st->tolerance + diff < 0 ? BELOW:BASE;					else if(diff < st->tolerance)						st->state = BASE;					else if(diff < st->threshold)						st->state = ABOVE;					else if(st->state < ACTIVE) {	//!ACTIVE && !TIMEOUT						st->activeStart = HAL_GetTick();						st->state = ACTIVE;					} else if(HAL_GetTick() - st->activeStart > g_config.tlimit * 1000)						st->state = TIMEOUT;					shift = g_config.shifts[st->state];					if(shift != SCHAR_MIN) {						st->correction = (shift >= 0) ? (((int32_t)st->diff) << shift) : (((int32_t)st->diff) >> -shift);						st->sum += st->correction;					} else

/**  * @brief  Conversion complete callback in non blocking mode   * @param  htim : hadc handle  * @retval None  */void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim){  if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2)  {    if(uhCaptureIndex == 0)    {      /* Get the 1st Input Capture value */      uwIC2Value1 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_2);      uhCaptureIndex = 1;    }    else if(uhCaptureIndex == 1)    {      /* Get the 2nd Input Capture value */      uwIC2Value2 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_2);       /* Capture computation */      if (uwIC2Value2 > uwIC2Value1)      {        uwDiffCapture = (uwIC2Value2 - uwIC2Value1);       }      else if (uwIC2Value2 < uwIC2Value1)      {        /* 0xFFFF is max TIM3_CCRx value */        uwDiffCapture = ((0xFFFF - uwIC2Value1) + uwIC2Value2) + 1;      }      else      {        /* If capture values are equal, we have reached the limit of frequency           measures */        Error_Handler();      }      /* Frequency computation: for this example TIMx (TIM3) is clocked by         2xAPB1Clk */            uwFrequency = (2*HAL_RCC_GetPCLK1Freq()) / uwDiffCapture;      uhCaptureIndex = 0;    }  }}

/** * Callback function implementation. * @param htim timer handle which trigger the callback */void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim) {	static uint8_t steerRise = 0;	if (htim->Instance == TIM4) {		if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1) {			/* TIM4 Channel 1 (Motor input) */			uwIC1Value = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);		} else if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_3) {			/* TIM4 Channel 3 (Steer input) */			uwIC2Value = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_3) - uwIC1Value;			steerRise = 1;			if (_signalDetected == RESET) {				_signalDetected = SET;				if (_servo == ENABLE)					HAL_TIM_PWM_Start_IT(&htim4, TIM_CHANNEL_4);			}			/* Connect to servo output */			if (_connected == ENABLE) {				BSP_Radio_SetSteer(uwIC2Value - 1500);			}		} else if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2) {			/* TIM4 Channel 2 (Motor input, fall edge) */			if (!steerRise && _signalDetected == SET) {				_signalDetected = RESET;				HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_4);			} else if (steerRise) {				steerRise = 0;			}		}	}}

/**  * @brief  Input Capture callback in non blocking mode   * @param  htim : TIM IC handle  * @retval None  */void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim){  if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2)  {    /* Get the Input Capture value */    uwIC2Value = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_2);        if (uwIC2Value != 0)    {      /* Duty cycle computation */      uwDutyCycle = ((HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1)) * 100) / uwIC2Value;            /* uwFrequency computation      TIM4 counter clock = (RCC_Clocks.HCLK_Frequency)/2 */            uwFrequency = (HAL_RCC_GetHCLKFreq())/2 / uwIC2Value;    }    else    {      uwDutyCycle = 0;      uwFrequency = 0;    }  }}

/**  * @brief  Input Capture callback in non blocking mode   * @param  htim : TIM IC handle  * @retval None*/void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim){      /* Get the Input Capture value */  tmpCC4[uwCaptureNumber++] = HAL_TIM_ReadCapturedValue(&Input_Handle, TIM_CHANNEL_1);    if (uwCaptureNumber >= 2)  {    /* Compute the period length */    uwPeriodValue = (uint16_t)(0xFFFF - tmpCC4[0] + tmpCC4[1] + 1);        /* Frequency computation */     uwLsiFreq = (uint32_t) SystemCoreClock / uwPeriodValue;    uwLsiFreq *= 8;  }}

/**  * @brief  This function handles TIM5 global interrupt request.  * @param  None  * @retval None  */void TIM5_IRQHandler(void){   HAL_TIM_IRQHandler(&TimInputCaptureHandle);  {        /* Get the Input Capture value */    tmpCC4[uwCaptureNumber++] = HAL_TIM_ReadCapturedValue(&TimInputCaptureHandle, TIM_CHANNEL_4);        if (uwCaptureNumber >= 2)    {      /* Compute the period length */      uwPeriodValue = (uint16_t)(0xFFFF - tmpCC4[0] + tmpCC4[1] + 1);      uwMeasurementDone = 1;      uwCaptureNumber = 0;    }  }}

// Timer 1 capture compare interruptvoid TIM1_CC_IRQHandler(void){  if(__HAL_TIM_GET_FLAG(&TimHandle[1], TIM_FLAG_CC2) != RESET)  {    if(__HAL_TIM_GET_ITSTATUS(&TimHandle[1], TIM_IT_CC2) !=RESET)    {      {        __HAL_TIM_CLEAR_IT(&TimHandle[1], TIM_IT_CC2);                encoderSpeed[1] = HAL_TIM_ReadCapturedValue(&TimHandle[1], TIM_CHANNEL_2);                TIM1->CNT = 0;      }    }  }}

/**  * @brief  This function handles TIM16 global interrupt request.  * @param  None  * @retval None  */void TIM14_IRQHandler(void){   HAL_TIM_IRQHandler(&Input_Handle);  {        /* Get the Input Capture value */    tmpCC4[uwCaptureNumber++] = HAL_TIM_ReadCapturedValue(&Input_Handle, TIM_CHANNEL_1);        if (uwCaptureNumber >= 2)    {      /* Compute the period length */      uwPeriodValue = (uint16_t)(0xFFFF - tmpCC4[0] + tmpCC4[1] + 1);            /* Frequency computation */       uwLsiFreq = (uint32_t) SystemCoreClock / uwPeriodValue;      uwLsiFreq *= 8;    }  }}

/**  * @brief  Output Compare callback in non blocking mode   * @param  htim: TIM OC handle  * @retval None  */void HAL_TIM_OC_DelayElapsedCallback(TIM_HandleTypeDef *htim){  uint32_t capture = 0;     if(LEDsState == LED3_TOGGLE)  {    /* Toggling LED3 */    BSP_LED_Toggle(LED3);    BSP_LED_Off(LED6);    BSP_LED_Off(LED4);  }  else if(LEDsState == LED4_TOGGLE)  {    /* Toggling LED4 */    BSP_LED_Toggle(LED4);    BSP_LED_Off(LED6);    BSP_LED_Off(LED3);  }  else if(LEDsState == LED6_TOGGLE)  {    /* Toggling LED6 */    BSP_LED_Off(LED3);    BSP_LED_Off(LED4);    BSP_LED_Toggle(LED6);  }  else if(LEDsState == STOP_TOGGLE)  {    /* Turn ON LED6 */    BSP_LED_On(LED6);  }  else if(LEDsState == LEDS_OFF)  {    /* Turn OFF all LEDs */    BSP_LED_Off(LED3);    BSP_LED_Off(LED4);    BSP_LED_Off(LED5);    BSP_LED_Off(LED6);  }  /* Get the TIM4 Input Capture 1 value */  capture = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);    /* Set the TIM4 Capture Compare1 Register value */  __HAL_TIM_SET_COMPARE(htim, TIM_CHANNEL_1, (CCR1Val + capture));}

/**  * @brief  Input Capture callback in non blocking mode   * @param  htim : TIM4 IC handle  * @retval None  */void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim){    /* Get the converted value */    ICReadValue = HAL_TIM_ReadCapturedValue(htim,TIM_CHANNEL_2);        /* Increment the counter */    ICCounter++;        /* sum up the samples */    SumICReadValue += ICReadValue;        if(ICCounter > 255)    {      /* Compute the average value for 256 samples */      AvrgICReadValue = SumICReadValue/256;      ICCounter = 0;      SumICReadValue = 0;    }}

int main(void) {  HAL_Init();  Nucleo_BSP_Init();  MX_TIM1_Init();  HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);  /* Connect a LED to PA8 pin to see the fading effect */  uint16_t dutyCycle = HAL_TIM_ReadCapturedValue(&htim1, TIM_CHANNEL_1);  while(1) {    while(dutyCycle < __HAL_TIM_GET_AUTORELOAD(&htim1)) {      __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, ++dutyCycle);      HAL_Delay(1);    }    while(dutyCycle > 0) {      __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, --dutyCycle);      HAL_Delay(1);    }  }}

// Output Compare callback in non blocking modevoid HAL_TIM_OC_DelayElapsedCallback(TIM_HandleTypeDef *htim) {	if (ledState == LED3_TOGGLE) {		BSP_LED_Toggle(LED3);		BSP_LED_Off(LED6);		BSP_LED_Off(LED4);	} else if (ledState == LED4_TOGGLE) {		BSP_LED_Toggle(LED4);		BSP_LED_Off(LED6);		BSP_LED_Off(LED3);	} else if (ledState == LED6_TOGGLE) {		BSP_LED_Off(LED3);		BSP_LED_Off(LED4);		BSP_LED_Toggle(LED6);	} else if (ledState == STOP_TOGGLE) {		BSP_LED_On(LED6);	} else if (ledState == LEDS_OFF) {		led_all_off();	}	/* Get the TIM4 Input Capture 1 value */	uint32_t capture = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);	/* Set the TIM4 Capture Compare1 Register value */	__HAL_TIM_SET_COMPARE(htim, TIM_CHANNEL_1, (CCR1Val + capture));}

/** * @brief Timer Capture Callback function for Frequency Calculations */void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim){  __HAL_TIM_DISABLE(htim);  if(htim->Instance == TIM9 || htim->Instance == TIM12)  {    /* Get the Input Capture value *///    if(tim9_12_flag == ENABLE)      uwIC2Value = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);//    else//      uwIC2Value = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_2);    if (uwIC2Value != 0)    {      /* Duty cycle computation *///      if(tim9_12_flag == ENABLE)        uwDutyCycle = ((HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_2)) * 100) / uwIC2Value;//      else//        uwDutyCycle = ((HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1)) * 100) / uwIC2Value;      /* uwFrequency computation      TIM4 counter clock = (RCC_Clocks.HCLK_Frequency)/2 */      if(htim->Instance == TIM9)        uwFrequency1 = (168000000UL)/(TimCapPsc+1) / uwIC2Value;      else if(htim->Instance == TIM12)        uwFrequency1 = (168000000UL)/(2*(TimCapPsc+1)) / uwIC2Value;    }    else    {      uwDutyCycle = 0;      uwFrequency1 = 0;    }  }  else if(htim->Instance == TIM10 || htim->Instance == TIM11 || htim->Instance == TIM14 || htim->Instance == TIM13)  {    if(uhCaptureIndex == 0)    {      /* Get the 1st Input Capture value */      uwIC2Value1 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);      uhCaptureIndex = 1;    }    else if(uhCaptureIndex == 1)    {      /* Get the 2nd Input Capture value */      uwIC2Value2 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);      /* Capture computation */      if (uwIC2Value2 > uwIC2Value1)      {        uwDiffCapture = (uwIC2Value2 - uwIC2Value1);      }      else  /* (uwIC2Value2 <= uwIC2Value1) */      {        uwDiffCapture = ((TimCapPeriod - uwIC2Value1) + uwIC2Value2);      }      /* Frequency computation: for this example TIMx (TIM1) is clocked by         2xAPB2Clk */      uwFrequency = (2*HAL_RCC_GetPCLK2Freq()) / uwDiffCapture;      if(htim->Instance == TIM10 || htim->Instance == TIM11)        uwFrequency = uwFrequency/(TimCapPsc+1);      else        uwFrequency = uwFrequency/(2*(TimCapPsc+1));      uhCaptureIndex = 0;    }  }  __HAL_TIM_ENABLE(htim);}

void DHT22_InterruptHandler(DHT22_HandleTypeDef* handle) {	uint16_t val = HAL_TIM_ReadCapturedValue(&handle->timHandle,			handle->timChannel);	uint32_t freq = HAL_RCC_GetPCLK2Freq();	uint16_t val2;	if (val > handle->lastVal)		val2 = val - handle->lastVal;	else		val2 = 65535 + val - handle->lastVal;	handle->lastVal = val;	float time = 1000000.0 * val2 / freq;	if (handle->bitPos < 0) {		if (time > 155.0 && time < 165.0) {			handle->bitPos = 0;		}	} else if (handle->bitPos >= 0 && handle->bitPos < 40) {		if (time > 78.0 && time < 97.0) {			handle->bitsRX[handle->bitPos / 8] &= ~(1					<< (7 - handle->bitPos % 8));			handle->bitPos++;		} else if (time > 120.0 && time < 145.0) {			handle->bitsRX[handle->bitPos / 8] |= 1 << (7 - handle->bitPos % 8);			handle->bitPos++;		} else {			handle->bitPos = -1;			HAL_TIM_IC_Stop_IT(&handle->timHandle, handle->timChannel);			handle->state = DHT22_READY;		}	}	if(handle->bitPos==40){		handle->bitPos = -1;		//TODO This was changed (commented out) recently i'm not sure why		HAL_TIM_IC_Stop_IT(&handle->timHandle, handle->timChannel);		uint8_t sum = 0;		for (int i = 0; i < 4; i++) {			sum += handle->bitsRX[i];		}		if (sum == handle->bitsRX[4]) {			handle->crcErrorFlag = 0;			int16_t temp10 = 0;			if ((handle->bitsRX[2] & 0x80) == 0x80) {				temp10 |= (handle->bitsRX[2] & 0x7F) << 8;				temp10 |= handle->bitsRX[3];				temp10 *= -1;			} else {				temp10 |= handle->bitsRX[2] << 8;				temp10 |= handle->bitsRX[3];			}			handle->temp = 0.1 * temp10;			int16_t hum10 = 0;			if ((handle->bitsRX[0] & 0x80) == 0x80) {				hum10 |= (handle->bitsRX[0] & 0x7F) << 8;				hum10 |= handle->bitsRX[1];				hum10 *= -1;			} else {				hum10 |= handle->bitsRX[0] << 8;				hum10 |= handle->bitsRX[1];			}			handle->hum = 0.1 * hum10;		} else {			handle->crcErrorFlag = 1;		}		handle->state = DHT22_RECEIVED;	}}