/**
* @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 PWM pulse finish callback function
*/
void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim)
{
if (toggle_tim == RESET)
{
__HAL_TIM_SET_COMPARE(&htim2_gen,TIM_CH1,(65000/(1000000/4500)));
HAL_Delay(500);
toggle_tim = SET;
}
else if (toggle_tim == SET)
{
__HAL_TIM_SET_COMPARE(&htim2_gen,TIM_CH1,(65000/(1000000/500)));
HAL_Delay(500);
toggle_tim = RESET;
}
}
void us_ticker_set_interrupt(timestamp_t timestamp)
{
// Set new output compare value
__HAL_TIM_SET_COMPARE(&TimMasterHandle, TIM_CHANNEL_1, (uint32_t)timestamp);
// Enable IT
__HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC1);
}
/**
* @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));
}
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);
}
}
}
void STM32FrequencyChannel::Enable (bool enable)
{
if (enable)
{
__HAL_TIM_SET_COMPARE (timer.handle, channel,
__HAL_TIM_GetCompare (timer.handle, channel) +
reloadValue);
HAL_TIM_OC_Start_IT (timer.handle, channel);
}
else
{
HAL_TIM_OC_Stop_IT (timer.handle, channel);
}
}
/**
* @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));
}
void STM32FrequencyChannel::ISR ()
{
pinState = !pinState;
auto capture = __HAL_TIM_GET_COMPARE (timer.handle, channel);
if (!pinState)
{
if (CycleCompleted != nullptr)
{
EventArgs args;
CycleCompleted (this, args);
}
if (stopRequested)
{
Enable (false);
stopRequested = false;
}
}
__HAL_TIM_SET_COMPARE (timer.handle, channel, capture + reloadValue);
}
// Output Compare callback in non blocking mode
void 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));
}
/* TIM4 打开触发脉冲 */
void HAL_TIM_OC_DelayElapsedCallback(TIM_HandleTypeDef *htim)
{
uint32_t compare = 0;
/* TIM4 */
if (htim->Instance == TIM4) {
// 1
// 排烟风机 通道
if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1) {
// 排烟风机 delay_on， 打开输出
if (!is_lower_blow) {
__HAL_TIM_DISABLE_IT(&htim4, TIM_IT_CC1);
}
ON_SMOKE;
// 延时关断
compare = __HAL_TIM_GET_COUNTER(&htim2) + uS_DELAY_OFF;
__HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_1, compare);
__HAL_TIM_ENABLE_IT(&htim2, TIM_IT_CC1);
// 下一个半波
if (is_lower_blow) {
is_lower_blow = false;
compare = __HAL_TIM_GET_COUNTER(&htim4) + HALF_T1;
__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_1, compare);
//__HAL_TIM_ENABLE_IT(&htim4, TIM_IT_CC1);
}
}
// 2
// 循环风机通道
if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2) {
// 循环风机 delay_on， 打开输出
if (!is_lower_exchange){
__HAL_TIM_DISABLE_IT(&htim4, TIM_IT_CC2);
}
ON_EXCHANGE;
// 延时关断
compare = __HAL_TIM_GET_COUNTER(&htim2) + uS_DELAY_OFF;
__HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_2, compare);
__HAL_TIM_ENABLE_IT(&htim2, TIM_IT_CC2);
// 下一个半波
if (is_lower_exchange) {
is_lower_exchange = false;
compare = __HAL_TIM_GET_COUNTER(&htim4) + HALF_T1;
__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_2, compare);
//__HAL_TIM_ENABLE_IT(&htim4, TIM_IT_CC2);
}
}
// 3
// 送料电机 通道
if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_3) {
// 送料
if (!is_lower_feed) {
__HAL_TIM_DISABLE_IT(&htim4, TIM_IT_CC3);
}
ON_FEED;
// 延时关断
compare = __HAL_TIM_GET_COUNTER(&htim2) + uS_DELAY_OFF;
__HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_3, compare);
__HAL_TIM_ENABLE_IT(&htim4, TIM_IT_CC3);
// 下一个半波
if (is_lower_feed){
is_lower_feed = false;
compare = __HAL_TIM_GET_COUNTER(&htim4) + HALF_T1;
__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_3, compare);
//__HAL_TIM_ENABLE_IT(&htim4, TIM_IT_CC3);
}
}
//
}
/* TIM2 关闭触发脉冲 */
// 延时x us关闭触发
if (htim->Instance == TIM2) {
// 1
if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1) {
OFF_SMOKE;
__HAL_TIM_DISABLE_IT(&htim2, TIM_IT_CC1);
}
// 2
if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2) {
// 输出 循环：Off
OFF_EXCHANGE;
__HAL_TIM_DISABLE_IT(&htim2, TIM_IT_CC2);
}
// 3
if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_3) {
// 输出 送料： Off
OFF_FEED;
__HAL_TIM_DISABLE_IT(&htim2, TIM_IT_CC3);
}
} // TIM2
//
}
/* 过零点触发中断 回调函数 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
if (GPIO_Pin != ZERO)
return;
bool wave_is_rise;
// 读Pin，判断是上升沿还是下降沿
if (HAL_GPIO_ReadPin(PORT_ZERO, ZERO) == GPIO_PIN_RESET) {
wave_is_rise = true;
}
else {
wave_is_rise = false;
}
// t 顺序： 1 3 4 6
// 上升沿
if (wave_is_rise) {
t4 = __HAL_TIM_GET_COUNTER(&htim3);
// 上升沿是否valid?
// if (!it_is_valid(t4_prev, t4)) {
// t4_prev = t4;
// r++;
// return;
// }
//r++;
}
else {
// 下降沿
t6 = __HAL_TIM_GET_COUNTER(&htim3);
// 下降沿是否valid?
// if (!it_is_valid(t6_prev, t6)) {
// t6_prev = t6;
// f++;
// return;
// }
//f++;
}
if (wave_is_rise) // 只在波谷计算，否则退出
return;
is_lower_blow = true; // 设置波谷flag
is_lower_exchange = true;
is_lower_feed = true;
/* 下降沿时计算下一个零点 */
// t2
if (t3 < t1)
t2 = (0xffff + t1 + t3) / 2;
else
t2 = (t1 + t3) / 2;
// t5
if (t6 < t4)
t5 = (0xffff + t4 + t6) / 2;
else
t5 = (t4 + t6) / 2;
// 交流电源周期
if (t5 < t2)
T1 = 0xffff + t5 - t2;
else
T1 = t5 - t2;
// 下一个零点
if (t5 < t4)
t7 = t5 + 0xffff - t4 + (T1 / 4); /* 计算不对 ！ */
else
t7 = t5 - t4 + (T1 / 4);
// counter++;
// if (counter >=299) {
// //printf("t4:%d,t5:%d,t6:%d,t7:%d,T1:%d\r\n", t4,t5,t6,t7,T1);
// printf("delay:%d\r\n", t7 + TOTAL_TIME - triac_cur.fan_smoke_delay * 100);
// counter = 0;
// }
// 更新数值
t1 = t4;
t2 = t5;
t3 = t6;
// 计数器复位
__HAL_TIM_SET_COUNTER (&htim1, 0);
__HAL_TIM_SET_COUNTER (&htim4, 0);
// 检查Q_Triac队列，更新输出的控制状态
if (Q_TriacHandle != NULL) {
// 读取值
osEvent evt = osMessageGet(Q_TriacHandle, 0);
if (evt.status == osEventMessage) {
triac_cur = *((Triac *)evt.value.p);
// 更新送料duty
on_count = triac_cur.feed_duty * 100;
off_count = 1000 - on_count; // 10s = 10000ms 10000 / 10 = 1000
// 返还内存
osStatus status = osPoolFree(pool_TriacHandle, evt.value.p);
if (status != osOK)
printf("Free Triac memory error:%x\r\n", status);
}
}
// 设置period
__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_1, t7 + TOTAL_TIME - triac_cur.fan_smoke_delay * 100); // 80÷100×10×1000 ＝ 80×100
__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_2, t7 + TOTAL_TIME - triac_cur.fan_exchange_delay * 100);
__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_3, t7);
/* 输出: 条件判断 */
HAL_StatusTypeDef status;
//排烟通道
if (triac_cur.fan_smoke_is_on) {
status = HAL_TIM_OC_Start_IT(&htim4, TIM_CHANNEL_1);
if (status != HAL_OK)
printf("time4 c1 failed at zero:%x\r\n", status);
}
//循环通道
if (triac_cur.fan_exchange_is_on) {
status = HAL_TIM_OC_Start_IT(&htim4, TIM_CHANNEL_2);
if (status != HAL_OK)
printf("time4 c2 failed:%x\r\n", status);
}
//送料通道 ON计数 OFF计数
if (triac_cur.feed_is_on) {
// 送料
if (running_feed) {
if (on_cnt < on_count) {
// 输出 送料： On
HAL_TIM_OC_Start_IT(&htim4, TIM_CHANNEL_3);
on_cnt++;
}
else {
on_cnt = 0;
off_cnt = 0;
running_feed = false;
waiting_feed = true;
}
}
// 不送料
if (waiting_feed) {
off_cnt ++;
if (off_cnt >= off_count) {
on_cnt = 0;
off_cnt = 0;
running_feed = true;
waiting_feed = false;
}
}
}
//
}
/**
* @brief SYSTICK callback.
* @param None
* @retval None
*/
void HAL_SYSTICK_Callback(void)
{
uint8_t *buf;
uint16_t Temp_X, Temp_Y = 0x00;
uint16_t NewARR_X, NewARR_Y = 0x00;
if (DemoEnterCondition != 0x00)
{
buf = USBD_HID_GetPos();
if((buf[1] != 0) ||(buf[2] != 0))
{
USBD_HID_SendReport (&hUSBDDevice,
buf,
4);
}
Counter ++;
if (Counter == 10)
{
/* Reset Buffer used to get accelerometer values */
Buffer[0] = 0;
Buffer[1] = 0;
/* Disable All TIM4 Capture Compare Channels */
HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_1);
HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_2);
HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_3);
HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_4);
/* Read Acceleration*/
BSP_ACCELERO_GetXYZ(Buffer);
/* Set X and Y positions */
X_Offset = Buffer[0];
Y_Offset = Buffer[1];
/* Update New autoreload value in case of X or Y acceleration*/
/* Basic acceleration X_Offset and Y_Offset are divide by 40 to fir with ARR range */
NewARR_X = TIM_ARR - ABS(X_Offset/40);
NewARR_Y = TIM_ARR - ABS(Y_Offset/40);
/* Calculation of Max acceleration detected on X or Y axis */
Temp_X = ABS(X_Offset/40);
Temp_Y = ABS(Y_Offset/40);
MaxAcceleration = MAX_AB(Temp_X, Temp_Y);
if(MaxAcceleration != 0)
{
/* Reset CNT to a lowest value (equal to min CCRx of all Channels) */
__HAL_TIM_SET_COUNTER(&htim4,(TIM_ARR-MaxAcceleration)/2);
if (X_Offset < ThreadholdAcceleroLow)
{
/* Sets the TIM4 Capture Compare for Channel1 Register value */
/* Equal to NewARR_X/2 to have duty cycle equal to 50% */
__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_1, NewARR_X/2);
/* Time base configuration */
__HAL_TIM_SET_AUTORELOAD(&htim4, NewARR_X);
/* Enable TIM4 Capture Compare Channel1 */
HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_1);
}
else if (X_Offset > ThreadholdAcceleroHigh)
{
/* Sets the TIM4 Capture Compare for Channel3 Register value */
/* Equal to NewARR_X/2 to have duty cycle equal to 50% */
__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_3, NewARR_X/2);
/* Time base configuration */
__HAL_TIM_SET_AUTORELOAD(&htim4, NewARR_X);
/* Enable TIM4 Capture Compare Channel3 */
HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_3);
}
if (Y_Offset > ThreadholdAcceleroHigh)
{
/* Sets the TIM4 Capture Compare for Channel2 Register value */
/* Equal to NewARR_Y/2 to have duty cycle equal to 50% */
__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_2,NewARR_Y/2);
/* Time base configuration */
__HAL_TIM_SET_AUTORELOAD(&htim4, NewARR_Y);
/* Enable TIM4 Capture Compare Channel2 */
HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_2);
}
else if (Y_Offset < ThreadholdAcceleroLow)
{
/* Sets the TIM4 Capture Compare for Channel4 Register value */
/* Equal to NewARR_Y/2 to have duty cycle equal to 50% */
__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_4, NewARR_Y/2);
/* Time base configuration */
__HAL_TIM_SET_AUTORELOAD(&htim4, NewARR_Y);
/* Enable TIM4 Capture Compare Channel4 */
HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_4);
}
}
Counter = 0x00;
}
}
}
// 输出比较 回调函数
void HAL_TIM_OC_DelayElapsedCallback(TIM_HandleTypeDef *htim)
{
uint16_t delay_new = 0;
// TIM4
if (htim->Instance == TIM4) {
// 1
// 排烟风机 通道
if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1) {
// 排烟风机 delay_on， 打开输出
// 输出：On
HAL_GPIO_WritePin(PORT_SCR, SCR0_smoke, GPIO_PIN_RESET);
HAL_TIM_OC_Stop_IT( &htim4, TIM_CHANNEL_1);
// 启动波峰
if (is_lower_blow) {
is_lower_blow = false;
delay_new = __HAL_TIM_GET_COMPARE(&htim4, TIM_CHANNEL_1);
__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_1, delay_new + 10000 - 1);
HAL_TIM_OC_Start_IT( &htim4, TIM_CHANNEL_1);
}
//设置停止时间
delay_new = __HAL_TIM_GET_COMPARE(&htim1, TIM_CHANNEL_1);
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, delay_new + uS_DELAY_OFF);
// 启动定时器
HAL_TIM_OC_Start_IT( &htim1, TIM_CHANNEL_1);
}
// 2
// 循环风机通道
if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2) {
// 循环风机 delay_on， 打开输出
// 输出：On
HAL_GPIO_WritePin(PORT_SCR, SCR1_exchange, GPIO_PIN_RESET);
HAL_TIM_OC_Stop_IT( &htim4, TIM_CHANNEL_2);
// 启动波峰
if (is_lower_exchange) {
is_lower_exchange = false;
delay_new = __HAL_TIM_GET_COMPARE(&htim4, TIM_CHANNEL_2);
__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_2, delay_new + 10000 - 1);
HAL_TIM_OC_Start_IT( &htim4, TIM_CHANNEL_2);
}
//设置停止时间
uint16_t delay_new = __HAL_TIM_GET_COMPARE(&htim1, TIM_CHANNEL_2);
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_2, delay_new + uS_DELAY_OFF);
// 启动定时器
HAL_TIM_OC_Start_IT( &htim1, TIM_CHANNEL_2);
}
// 3
// 送料电机 通道
if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_3) {
HAL_GPIO_WritePin(PORT_SCR, SCR2_feed, GPIO_PIN_RESET);
HAL_TIM_OC_Stop_IT( &htim4, TIM_CHANNEL_3);
// 启动波峰
if (is_lower_feed) {
is_lower_feed = false;
uint16_t delay_new = __HAL_TIM_GET_COMPARE(&htim4, TIM_CHANNEL_3);
__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_3, delay_new + 10000 - 1);
HAL_TIM_OC_Start_IT( &htim4, TIM_CHANNEL_3);
}
//设置停止时间
uint16_t delay_new = __HAL_TIM_GET_COMPARE(&htim1, TIM_CHANNEL_3);
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_3, delay_new + uS_DELAY_OFF);
}
}
// TIM1
// 延时1ms关闭触发
if (htim->Instance == TIM1) {
// 1
if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1) {
HAL_GPIO_WritePin(PORT_SCR, SCR0_smoke, GPIO_PIN_SET);
HAL_TIM_OC_Stop_IT( &htim1, TIM_CHANNEL_1);
}
// 2
if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2) {
// 输出 循环：Off
HAL_GPIO_WritePin(PORT_SCR, SCR1_exchange, GPIO_PIN_SET);
HAL_TIM_OC_Stop_IT( &htim1, TIM_CHANNEL_2);
}
// 3
if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_3) {
// 输出 送料： Off
HAL_GPIO_WritePin(PORT_SCR, SCR2_feed, GPIO_PIN_SET);
HAL_TIM_OC_Stop_IT( &htim1, TIM_CHANNEL_3);
}
} // TIM1
//
}
/* USER CODE BEGIN 0 */
void set_led_brightness(TIM_HandleTypeDef * timer, uint32_t channel,
float brightness) {
int32_t value = powf((brightness), 2.2) * 10000;
__HAL_TIM_SET_COMPARE(timer, channel, value);
}
HAL_StatusTypeDef _servo_setPulse(uint32_t channel, uint32_t pulse) {
__HAL_TIM_SET_COMPARE(&SERVO_TIMER, channel, pulse);
return HAL_OK;
}
int main(void) {
HAL_Init();
Nucleo_BSP_Init();
MX_TIM1_Init();
MX_TIM3_Init();
HAL_TIM_Encoder_Start(&htim3, TIM_CHANNEL_ALL);
HAL_TIM_OC_Start(&htim1, TIM_CHANNEL_1);
HAL_TIM_OC_Start(&htim1, TIM_CHANNEL_2);
cnt1 = __HAL_TIM_GET_COUNTER(&htim3);
tick = HAL_GetTick();
while (1) {
if (HAL_GetTick() - tick > 1000L) {
cnt2 = __HAL_TIM_GET_COUNTER(&htim3);
if (__HAL_TIM_IS_TIM_COUNTING_DOWN(&htim3)) {
if (cnt2 < cnt1) /* Check for counter underflow */
diff = cnt1 - cnt2;
else
diff = (65535 - cnt2) + cnt1;
} else {
if (cnt2 > cnt1) /* Check for counter overflow */
diff = cnt2 - cnt1;
else
diff = (65535 - cnt1) + cnt2;
}
sprintf(msg, "Difference: %d\r\n", diff);
HAL_UART_Transmit(&huart2, (uint8_t*) msg, strlen(msg), HAL_MAX_DELAY);
speed = ((diff / PULSES_PER_REVOLUTION) / 60);
/* If the first three bits of SMCR register are set to 0x3
* then the timer is set in X4 mode (TIM_ENCODERMODE_TI12)
* and we need to divide the pulses counter by two, because
* they include the pulses for both the channels */
if ((TIM3->SMCR & 0x3) == 0x3)
speed /= 2;
sprintf(msg, "Speed: %d RPM\r\n", speed);
HAL_UART_Transmit(&huart2, (uint8_t*) msg, strlen(msg), HAL_MAX_DELAY);
dir = __HAL_TIM_IS_TIM_COUNTING_DOWN(&htim3);
sprintf(msg, "Direction: %d\r\n", dir);
HAL_UART_Transmit(&huart2, (uint8_t*) msg, strlen(msg), HAL_MAX_DELAY);
tick = HAL_GetTick();
cnt1 = __HAL_TIM_GET_COUNTER(&htim3);
}
if (HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_13) == GPIO_PIN_RESET) {
/* Invert rotation by swapping CH1 and CH2 CCR value */
tim1_ch1_pulse = __HAL_TIM_GET_COMPARE(&htim1, TIM_CHANNEL_1);
tim1_ch2_pulse = __HAL_TIM_GET_COMPARE(&htim1, TIM_CHANNEL_2);
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, tim1_ch2_pulse);
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_2, tim1_ch1_pulse);
}
}
}
/*change pulse width for MTx2 pin PB9/TIM4_CH4*/
void PWM_MTx2_per(TIM_HandleTypeDef *htim, int PercentWidth)
{
int width = (PercentWidth/100.0)*htim->Init.Period;
__HAL_TIM_SET_COMPARE(htim, TIM_CHANNEL_4, width);
}
/* 过零点触发中断 回调函数 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
if (GPIO_Pin != ZERO)
return;
bool rising_edge;
// 读Pin，判断是上升沿还是下降沿
if (HAL_GPIO_ReadPin(PORT_ZERO, ZERO) == GPIO_PIN_SET) {
rising_edge = true;
}
else {
rising_edge = false;
}
// t 顺序： 1 3 4 6
// 上升沿
if (rising_edge) {
t6 = __HAL_TIM_GET_COUNTER(&htim3);
}
else {
// 下降沿
t4 = __HAL_TIM_GET_COUNTER(&htim3);
}
if (!rising_edge) // 只在波谷计算，否则退出
return;
/*----------------------------------------------------------------------------*/
is_lower_blow = true; // 设置波谷flag
is_lower_exchange = true;
is_lower_feed = true;
/* 下降沿时计算下一个零点 */
// t1 t3 t4 t6
if ((t1<t3) && (t3<t4) && (t4<t6)) {
t2 = (t1+t3) / 2;
t5 = (t4+t6) / 2;
}
else if(t3<t1) {
t2 = (t1+t3+0xffff) / 2;
t5 = (t4+t6)/2 + 0xffff;
}
else if(t4<t3) {
t2 = (t1+t3) / 2;
t5 = (t4+t6)/2 + 0xffff;
}
else if(t6<t4) {
t2 = (t1+t3) / 2;
t5 = (t4+t6+0xffff) / 2;
}
T1 = t5 - t2;
// 下一个零点
if (t6<t5) {
t7 = t5 + T1/4 - t6 -0xffff;
}
else {
t7 = t5 + T1/4 - t6;
}
// debug
// counter++;
// if (counter >= 149) {
// Zero *z;
// z = (Zero*)osPoolAlloc(pool_ZeroHandle);
// if (z!=NULL) {
// z->t1 = t1;
// z->t3 = t3;
// z->t4 = t4;
// z->t6 = t6;
// z->t7 = t7;
// z->T1 = T1;
// osMessagePut(Q_ErrorHandle, (uint32_t)z, 0);
// }
//
// counter = 0;
// }
//
// 更新数值
t1 = t4;
t3 = t6;
/*--------------------------------------------------------------------------*/
// 只处理下半波
if (t7 == 0) {
t7 = 220;
}
is_lower_blow = true; // 设置波谷flag
is_lower_exchange = true;
is_lower_feed = true;
//uint32_t compare = 0;
// 检查Q_Triac队列，更新输出的控制状态
if (Q_TriacHandle != NULL) {
// 读取值
osEvent evt = osMessageGet(Q_TriacHandle, 0);
if (evt.status == osEventMessage) {
Triac *p = (Triac *)evt.value.p;
triac_cur.fan_exchange_delay = p->fan_exchange_delay;
triac_cur.fan_exchange_is_on = p->fan_exchange_is_on;
triac_cur.fan_smoke_is_on = p->fan_smoke_is_on;
triac_cur.fan_smoke_power = p->fan_smoke_power;
triac_cur.feed_by_manual = p->feed_by_manual;
triac_cur.feed_duty = p->feed_duty;
triac_cur.feed_full = p->feed_full;
triac_cur.feed_is_on = p->feed_is_on;
// 更新送料duty
if (triac_cur.feed_duty != 0) {
// 500×triac_cur.feed_duty÷100
on_count = 5 * triac_cur.feed_duty;
off_count = 500 - on_count; // 10s = 10000ms 10000 / 20 = 500
}
// 返还内存
osStatus status = osPoolFree(pool_TriacHandle, evt.value.p);
if (status != osOK)
printf("Free Triac memory error:%x\r\n", status);
}
}
/*----------------------------------------------------------------------------*/
// 设置period
if (triac_cur.fan_smoke_power == 0) {
triac_cur.fan_smoke_power = 60;
}
// 最低延时2.5ms，最高延时6ms
uint32_t delay = t7 + triac_cur.fan_smoke_power;
if (delay>8999) {
delay = last_delay;
}
else {
last_delay = delay;
}
// 计数器复位
__HAL_TIM_SET_COUNTER (&htim2, 0);
__HAL_TIM_SET_COUNTER (&htim4, 0);
__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_1, delay);
__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_2, t7+T1/4);
__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_3, t7+T1/4);
/* 输出: 条件判断 */
//排烟通道
if (triac_cur.fan_smoke_is_on) {
__HAL_TIM_ENABLE_IT(&htim4, TIM_IT_CC1);
}
//循环通道
if (triac_cur.fan_exchange_is_on) {
__HAL_TIM_ENABLE_IT(&htim4, TIM_IT_CC2);
}
//送料通道
if ((triac_cur.feed_by_manual || triac_cur.feed_full) && (!triac_cur.feed_is_on)) {
__HAL_TIM_ENABLE_IT(&htim4, TIM_IT_CC3);
}
//送料通道 ON计数 OFF计数
if (triac_cur.feed_is_on && (!triac_cur.feed_by_manual)) { // 0
// 送料
if (feed_run) {
__HAL_TIM_ENABLE_IT(&htim4, TIM_IT_CC3);
count_feed ++;
if (count_feed >= on_count) {
count_feed = 0;
feed_run = false;
}
}
else {
// 不送料
count_feed ++;
if (count_feed >= off_count) {
count_feed = 0;
feed_run = true;
}
}
} // if 0
}
/*change pulse width for MTx2 pin PB9/TIM4_CH4*/
void PWM_MTx2(TIM_HandleTypeDef *htim, float pwm)
{
__HAL_TIM_SET_COMPARE(htim, TIM_CHANNEL_4, pwm*htim->Init.Period);
}
