void set_compare(uint16_t count) { TimMasterHandle.Instance = TIM_MST; // Set new output compare value __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_1, count); // Enable IT __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC1); }
void lp_ticker_set_interrupt(uint32_t now, uint32_t time) { (void)now; // Set new output compare value __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_1, time); // Enable IT __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC1); }
void us_ticker_set_interrupt(timestamp_t timestamp) { // Set new output compare value __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_1, (uint32_t)timestamp); // Enable IT __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC1); }
void timer_irq_handler(void) { // Channel 1 for mbed timeout if (__HAL_TIM_GET_FLAG(&TimMasterHandle, TIM_FLAG_CC1) == SET) { if (__HAL_TIM_GET_IT_SOURCE(&TimMasterHandle, TIM_IT_CC1) == SET) { __HAL_TIM_CLEAR_IT(&TimMasterHandle, TIM_IT_CC1); us_ticker_irq_handler(); } } // Channel 2 for HAL tick if (__HAL_TIM_GET_FLAG(&TimMasterHandle, TIM_FLAG_CC2) == SET) { if (__HAL_TIM_GET_IT_SOURCE(&TimMasterHandle, TIM_IT_CC2) == SET) { __HAL_TIM_CLEAR_IT(&TimMasterHandle, TIM_IT_CC2); uint32_t val = __HAL_TIM_GetCounter(&TimMasterHandle); if ((val - PreviousVal) >= HAL_TICK_DELAY) { // Increment HAL variable HAL_IncTick(); // Prepare next interrupt __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_2, val + HAL_TICK_DELAY); PreviousVal = val; #if 0 // For DEBUG only HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_6); #endif } } } }
// Reconfigure the HAL tick using a standard timer instead of systick. HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority) { // Enable timer clock TIM_MST_RCC; // Reset timer TIM_MST_RESET_ON; TIM_MST_RESET_OFF; // Update the SystemCoreClock variable SystemCoreClockUpdate(); // Configure time base TimMasterHandle.Instance = TIM_MST; TimMasterHandle.Init.Period = 0xFFFF; TimMasterHandle.Init.Prescaler = (uint32_t)(SystemCoreClock / 1000000) - 1; // 1 us tick TimMasterHandle.Init.ClockDivision = 0; TimMasterHandle.Init.CounterMode = TIM_COUNTERMODE_UP; HAL_TIM_Base_Init(&TimMasterHandle); // Configure output compare channel 1 for mbed timeout (enabled later when used) HAL_TIM_OC_Start(&TimMasterHandle, TIM_CHANNEL_1); // Configure output compare channel 2 for HAL tick HAL_TIM_OC_Start(&TimMasterHandle, TIM_CHANNEL_2); PreviousVal = __HAL_TIM_GetCounter(&TimMasterHandle); __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_2, PreviousVal + HAL_TICK_DELAY); // Configure interrupts // Update interrupt used for 32-bit counter // Output compare channel 1 interrupt for mbed timeout // Output compare channel 2 interrupt for HAL tick NVIC_SetVector(TIM_MST_UP_IRQ, (uint32_t)timer_update_irq_handler); NVIC_EnableIRQ(TIM_MST_UP_IRQ); NVIC_SetPriority(TIM_MST_UP_IRQ, 0); NVIC_SetVector(TIM_MST_OC_IRQ, (uint32_t)timer_oc_irq_handler); NVIC_EnableIRQ(TIM_MST_OC_IRQ); NVIC_SetPriority(TIM_MST_OC_IRQ, 1); // Enable interrupts __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_UPDATE); // For 32-bit counter __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC2); // For HAL tick // Enable timer HAL_TIM_Base_Start(&TimMasterHandle); #if 0 // For DEBUG only __GPIOB_CLK_ENABLE(); GPIO_InitTypeDef GPIO_InitStruct; GPIO_InitStruct.Pin = GPIO_PIN_6; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); #endif return HAL_OK; }
int timer_set_pwm_width_us(hacs_pwm_chan_t pwm, uint32_t us) { hacs_timer_t tim = (pwm > HACS_PWM_CHAN_4) ? HACS_PWM_TIMER_1 : HACS_PWM_TIMER_0; TIM_HandleTypeDef *htim = &tim_handles[tim]; __HAL_TIM_SetCompare(htim, pwm_chan_to_tim_chan[pwm], us); return HACS_NO_ERROR; }
// Reconfigure the HAL tick using a standard timer instead of systick. HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority) { RCC_ClkInitTypeDef RCC_ClkInitStruct; uint32_t PclkFreq; // Get clock configuration // Note: PclkFreq contains here the Latency (not used after) HAL_RCC_GetClockConfig(&RCC_ClkInitStruct, &PclkFreq); // Get TIM5 clock value PclkFreq = HAL_RCC_GetPCLK1Freq(); // Enable timer clock TIM_MST_RCC; // Reset timer TIM_MST_RESET_ON; TIM_MST_RESET_OFF; // Configure time base TimMasterHandle.Instance = TIM_MST; TimMasterHandle.Init.Period = 0xFFFFFFFF; // TIMxCLK = PCLKx when the APB prescaler = 1 else TIMxCLK = 2 * PCLKx if (RCC_ClkInitStruct.APB1CLKDivider == RCC_HCLK_DIV1) TimMasterHandle.Init.Prescaler = (uint16_t)((PclkFreq) / 1000000) - 1; // 1 us tick else TimMasterHandle.Init.Prescaler = (uint16_t)((PclkFreq * 2) / 1000000) - 1; // 1 us tick TimMasterHandle.Init.ClockDivision = 0; TimMasterHandle.Init.CounterMode = TIM_COUNTERMODE_UP; TimMasterHandle.Init.RepetitionCounter = 0; HAL_TIM_OC_Init(&TimMasterHandle); NVIC_SetVector(TIM_MST_IRQ, (uint32_t)timer_irq_handler); NVIC_EnableIRQ(TIM_MST_IRQ); // Channel 1 for mbed timeout HAL_TIM_OC_Start(&TimMasterHandle, TIM_CHANNEL_1); // Channel 2 for HAL tick HAL_TIM_OC_Start(&TimMasterHandle, TIM_CHANNEL_2); PreviousVal = __HAL_TIM_GetCounter(&TimMasterHandle); __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_2, PreviousVal + HAL_TICK_DELAY); __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC2); #if 0 // For DEBUG only __GPIOB_CLK_ENABLE(); GPIO_InitTypeDef GPIO_InitStruct; GPIO_InitStruct.Pin = GPIO_PIN_6; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FAST; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); #endif return HAL_OK; }
int timer_set_pwm_duty(hacs_pwm_chan_t pwm, float percent) { hacs_timer_t tim = (pwm > HACS_PWM_CHAN_4) ? HACS_PWM_TIMER_1 : HACS_PWM_TIMER_0; TIM_HandleTypeDef *htim = &tim_handles[tim]; uint32_t period = __HAL_TIM_GetAutoreload(htim); uint32_t compare = (uint32_t)((float)period*percent); __HAL_TIM_SetCompare(htim, pwm_chan_to_tim_chan[pwm], compare); return HACS_NO_ERROR; }
void HAL_PWM_Set_Rate(int channel, uint32_t frequency_us, uint32_t duty_cycle_us) { #ifdef ENABLE_PWM_GENERATION uint32_t frequency = frequency_us * TIMER_TICKS_PER_MICROSECOND; uint32_t duty_cycle = duty_cycle_us * TIMER_TICKS_PER_MICROSECOND; if ( channel < sizeof(pwm_timer_channels)/sizeof(pwm_timer_channels[0])) { __HAL_TIM_SetAutoreload(pwm_timer_channels[channel].p_tim_handle, duty_cycle); __HAL_TIM_SetCompare(pwm_timer_channels[channel].p_tim_handle, pwm_timer_channels[channel].tim_channel_number, frequency); } #endif }
/* StartDefaultTask function */ void StartDefaultTask(void const * argument) { /* USER CODE BEGIN 5 */ /* Infinite loop */ for(;;) { // HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET); // osDelay(1000); // HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET); __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, servo1); __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, servo2); HAL_SPI_Receive(&hspi1, &(message.bytes.byte1), sizeof(uint32_t), 1000); if(message.all != 0){ if((message.bytes.byte1 != 0) && (message.bytes.byte1 != 255) && (message.bytes.byte1 == message.bytes.byte2)){ servo1 = (uint16_t) message.bytes.byte1 * 20; message.bytes.byte1 = 0; message.bytes.byte2 = 0; } if((message.bytes.byte3 != 0) && (message.bytes.byte3 != 255) && (message.bytes.byte3 == message.bytes.byte4)){ servo2 = (uint16_t) message.bytes.byte3 * 20; message.bytes.byte3 = 0; message.bytes.byte4 = 0; } } // if(message.tasks.servo1 != 0){ // servo1 = message.tasks.servo1; // } // if(message.tasks.servo2 != 0){ // servo2 = message.tasks.servo2; // } //osDelay(1); } /* USER CODE END 5 */ }
void timer_irq_handler(void) { uint16_t cnt_val = TIM_MST->CNT; TimMasterHandle.Instance = TIM_MST; // Clear Update interrupt flag if (__HAL_TIM_GET_FLAG(&TimMasterHandle, TIM_FLAG_UPDATE) == SET) { if (__HAL_TIM_GET_IT_SOURCE(&TimMasterHandle, TIM_IT_UPDATE) == SET) { __HAL_TIM_CLEAR_IT(&TimMasterHandle, TIM_IT_UPDATE); SlaveCounter++; } } // Channel 1 for mbed timeout if (__HAL_TIM_GET_FLAG(&TimMasterHandle, TIM_FLAG_CC1) == SET) { if (__HAL_TIM_GET_IT_SOURCE(&TimMasterHandle, TIM_IT_CC1) == SET) { __HAL_TIM_CLEAR_IT(&TimMasterHandle, TIM_IT_CC1); if (oc_rem_part > 0) { set_compare(oc_rem_part); // Finish the remaining time left oc_rem_part = 0; } else { if (oc_int_part > 0) { set_compare(0xFFFF); oc_rem_part = cnt_val; // To finish the counter loop the next time oc_int_part--; } else { us_ticker_irq_handler(); } } } } // Channel 2 for HAL tick if (__HAL_TIM_GET_FLAG(&TimMasterHandle, TIM_FLAG_CC2) == SET) { if (__HAL_TIM_GET_IT_SOURCE(&TimMasterHandle, TIM_IT_CC2) == SET) { __HAL_TIM_CLEAR_IT(&TimMasterHandle, TIM_IT_CC2); uint32_t val = __HAL_TIM_GetCounter(&TimMasterHandle); if ((val - PreviousVal) >= HAL_TICK_DELAY) { // Increment HAL variable HAL_IncTick(); // Prepare next interrupt __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_2, val + HAL_TICK_DELAY); PreviousVal = val; } } } }
// Reconfigure the HAL tick using a standard timer instead of systick. HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority) { // Enable timer clock TIM_MST_RCC; // Reset timer TIM_MST_RESET_ON; TIM_MST_RESET_OFF; // Configure time base TimMasterHandle.Instance = TIM_MST; TimMasterHandle.Init.Period = 0xFFFFFFFF; if ( SystemCoreClock == 16000000 ) { TimMasterHandle.Init.Prescaler = (uint32_t)( SystemCoreClock / 1000000) - 1; // 1 µs tick } else { TimMasterHandle.Init.Prescaler = (uint32_t)( SystemCoreClock / 2 / 1000000) - 1; // 1 µs tick } TimMasterHandle.Init.ClockDivision = 0; TimMasterHandle.Init.CounterMode = TIM_COUNTERMODE_UP; TimMasterHandle.Init.RepetitionCounter = 0; HAL_TIM_OC_Init(&TimMasterHandle); NVIC_SetVector(TIM_MST_IRQ, (uint32_t)timer_irq_handler); NVIC_EnableIRQ(TIM_MST_IRQ); // Channel 1 for mbed timeout HAL_TIM_OC_Start(&TimMasterHandle, TIM_CHANNEL_1); // Channel 2 for HAL tick HAL_TIM_OC_Start(&TimMasterHandle, TIM_CHANNEL_2); PreviousVal = __HAL_TIM_GetCounter(&TimMasterHandle); __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_2, PreviousVal + HAL_TICK_DELAY); __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC2); #if 0 // For DEBUG only __GPIOB_CLK_ENABLE(); GPIO_InitTypeDef GPIO_InitStruct; GPIO_InitStruct.Pin = GPIO_PIN_6; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FAST; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); #endif return HAL_OK; }
// Reconfigure the HAL tick using a standard timer instead of systick. HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority) { // Enable timer clock TIM_MST_RCC; // Reset timer TIM_MST_RESET_ON; TIM_MST_RESET_OFF; // Update the SystemCoreClock variable SystemCoreClockUpdate(); // Configure time base TimMasterHandle.Instance = TIM_MST; TimMasterHandle.Init.Period = 0xFFFFFFFF; TimMasterHandle.Init.Prescaler = (uint32_t)(SystemCoreClock / 1000000) - 1; // 1 us tick TimMasterHandle.Init.ClockDivision = 0; TimMasterHandle.Init.CounterMode = TIM_COUNTERMODE_UP; HAL_TIM_Base_Init(&TimMasterHandle); // Configure output compare channel 1 for mbed timeout (enabled later when used) HAL_TIM_OC_Start(&TimMasterHandle, TIM_CHANNEL_1); // Configure output compare channel 2 for HAL tick HAL_TIM_OC_Start(&TimMasterHandle, TIM_CHANNEL_2); PreviousVal = __HAL_TIM_GetCounter(&TimMasterHandle); __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_2, PreviousVal + HAL_TICK_DELAY); // Configure interrupts // Update interrupt used for 32-bit counter // Output compare channel 1 interrupt for mbed timeout // Output compare channel 2 interrupt for HAL tick NVIC_SetVector(TIM_MST_IRQ, (uint32_t)timer_irq_handler); NVIC_EnableIRQ(TIM_MST_IRQ); // Enable interrupts __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_UPDATE); // For 32-bit counter __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC2); // For HAL tick // Enable timer HAL_TIM_Base_Start(&TimMasterHandle); return HAL_OK; }
/** * @brief Sets the motor with a new value * @param motorNr number of the motor * @param value motor value from -255 to +255 * @retval None */ void MOTOR_SetVal(int motorNr, int value, uint8_t current) { uint32_t unsignedValue; uint32_t channelLeft, channelRight; TIM_HandleTypeDef htim; int sign; // get absolute value and sign if (value > 0) { unsignedValue = value; sign = 1; } else if (value < 0) { unsignedValue = -value; sign = -1; } else { unsignedValue = 0; sign = 0; } // Set current and the references if (motorNr == MOTOR_M1) { MOTOR_CURR_PORT->ODR = (MOTOR_CURR_PORT->ODR & (~MOTOR_M1_MASK)) | (MOTOR_CURRENT_TAB[current] << MOTOR_M1_SHIFT); htim = htimMotor; channelLeft = TIM_CHANNEL_3; channelRight = TIM_CHANNEL_4; } else if (motorNr == MOTOR_M2) { MOTOR_CURR_PORT->ODR = (MOTOR_CURR_PORT->ODR & (~MOTOR_M2_MASK)) | (MOTOR_CURRENT_TAB[current] << MOTOR_M2_SHIFT); htim = htimMotor; channelLeft = TIM_CHANNEL_1; channelRight = TIM_CHANNEL_2; } else if (motorNr == MOTOR_PUMP) { htim = htimPump; channelLeft = TIM_CHANNEL_1; channelRight = TIM_CHANNEL_2; } // Set the PWM if (sign == 1) { __HAL_TIM_SetCompare(&htim, channelLeft, unsignedValue); __HAL_TIM_SetCompare(&htim, channelRight, 0); } else if (sign == -1) { __HAL_TIM_SetCompare(&htim, channelLeft, 0); __HAL_TIM_SetCompare(&htim, channelRight, unsignedValue); } else { __HAL_TIM_SetCompare(&htim, channelLeft, 0); __HAL_TIM_SetCompare(&htim, channelRight, 0); } }
// Used for mbed timeout (channel 1) and HAL tick (channel 2) void timer_oc_irq_handler(void) { uint16_t cval = TIM_MST->CNT; TimMasterHandle.Instance = TIM_MST; // Channel 1 for mbed timeout if (__HAL_TIM_GET_FLAG(&TimMasterHandle, TIM_FLAG_CC1) == SET) { __HAL_TIM_CLEAR_FLAG(&TimMasterHandle, TIM_FLAG_CC1); if (oc_rem_part > 0) { set_compare(oc_rem_part); // Finish the remaining time left oc_rem_part = 0; } else { if (oc_int_part > 0) { set_compare(0xFFFF); oc_rem_part = cval; // To finish the counter loop the next time oc_int_part--; } else { us_ticker_irq_handler(); } } } // Channel 2 for HAL tick if (__HAL_TIM_GET_FLAG(&TimMasterHandle, TIM_FLAG_CC2) == SET) { __HAL_TIM_CLEAR_FLAG(&TimMasterHandle, TIM_FLAG_CC2); uint32_t val = __HAL_TIM_GetCounter(&TimMasterHandle); if ((val - PreviousVal) >= HAL_TICK_DELAY) { // Increment HAL variable HAL_IncTick(); // Prepare next interrupt __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_2, val + HAL_TICK_DELAY); PreviousVal = val; #if 0 // For DEBUG only HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_6); #endif } } }
void ultrasound_generator( uint32_t chanel ){ /* ##-1- Configure the TIM peripheral **************************************************************************** TIM2 Configuration: generate 4 PWM signals with 4 different duty cycles. In this example TIM2 input clock (TIM2CLK) is set to APB1 clock (PCLK1), since APB1 prescaler is equal to 1. TIM2CLK = PCLK1 PCLK1 = HCLK => TIM2CLK = HCLK = SystemCoreClock To get TIM2 counter clock at 16 MHz, the prescaler is computed as follows: Prescaler = (TIM2CLK / TIM2 counter clock) - 1 Prescaler = ((SystemCoreClock) /16 MHz) - 1 To get TIM2 output clock at 24 KHz, the period (ARR)) is computed as follows: ARR = (TIM2 counter clock / TIM2 output clock) - 1 = 665 TIM2 Channel1 duty cycle = (TIM2_CCR1/ TIM2_ARR + 1)* 100 = 50% ************************** 20KHz-> Prescaler = ( (48MHz) / 20KHz) - 1=799 30KHz-> Prescaler = ( (48MHz) / 30KHz) - 1=399 */ SystemClock_Config_48MHz(); MX_TIM3_Init(); HAL_TIM_PWM_Init(&htim3); sConfigOC.Pulse=0; HAL_GPIO_WritePin( DCDC_EN_GPIO_Port , DCDC_EN_Pin , 1 ); ///DCDC konverter engedélyezése (+15V) HAL_TIM_PWM_ConfigChannel( &htim3 , &sConfigOC , TIM_CHANNEL_1); HAL_TIM_PWM_ConfigChannel( &htim3 , &sConfigOC , TIM_CHANNEL_2); HAL_TIM_PWM_ConfigChannel( &htim3 , &sConfigOC , TIM_CHANNEL_3); HAL_TIM_PWM_ConfigChannel( &htim3 , &sConfigOC , TIM_CHANNEL_4); HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1); HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_2); HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_3); HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_4); for(int i=400; i < 700; i++){ //HAL_TIM_PWM_Stop(&htim3,chanel); __HAL_TIM_SetAutoreload(&htim3,i*2); __HAL_TIM_SetCompare(&htim3,chanel, i); //HAL_TIM_OC_Init(&htim3); //TIM_OC2_SetConfig( TIM3, &sConfigOC); //HAL_TIM_PWM_Start( &htim3 , chanel ); HAL_Delay(30); } __HAL_TIM_SetCompare(&htim3,chanel, 0); HAL_TIM_PWM_Stop( &htim3 , chanel ); HAL_TIM_PWM_DeInit( &htim3 ); HAL_TIM_Base_DeInit(&htim3); GPIO_TIM3_OFF(); HAL_GPIO_WritePin( DCDC_EN_GPIO_Port , DCDC_EN_Pin , 0); SystemClock_Config_8MHz(); }
void ultrasound (uint8_t bridge){ //ez a fv egyszerre csak egy hidat hajt meg! uint16_t i,old_i,temp_i,f; uint32_t CH1,CH2,CHx,CHy,tim,tim_now; //bridge1=0,bridge2=1-> hogy melyik hidat hajtsa meg if(bridge){ //bridge1 CH1=(uint32_t)TIM_CHANNEL_1; CH2=(uint32_t)TIM_CHANNEL_2; CHx=(uint32_t)TIM_CHANNEL_3; CHy=(uint32_t)TIM_CHANNEL_4; }else{ //bridge2 CH1=(uint32_t)TIM_CHANNEL_3; CH2=(uint32_t)TIM_CHANNEL_4; CHx=(uint32_t)TIM_CHANNEL_1; CHy=(uint32_t)TIM_CHANNEL_2; } SystemClock_Config_48MHz(); HAL_Delay(20); MX_TIM3_Init(); HAL_TIM_PWM_Init(&htim3); sConfigOC.OCMode = TIM_OCMODE_PWM1; sConfigOC.Pulse = 0; sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW; sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; HAL_TIM_PWM_ConfigChannel( &htim3 , &sConfigOC , CH1); sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; HAL_TIM_PWM_ConfigChannel( &htim3 , &sConfigOC , CH2); HAL_TIM_PWM_ConfigChannel( &htim3 , &sConfigOC , CHx); HAL_TIM_PWM_ConfigChannel( &htim3 , &sConfigOC , CHy); HAL_TIM_PWM_Start(&htim3, CH1); HAL_TIM_PWM_Start(&htim3, CH2); HAL_TIM_PWM_Start(&htim3, CHx); HAL_TIM_PWM_Start(&htim3, CHy); //csattanás csökkentés, 19khz kiadás eloszor HAL_GPIO_WritePin( DCDC_EN_GPIO_Port , DCDC_EN_Pin , 0 ); // HAL_GPIO_WritePin( DCDC_PWR_GPIO_Port , DCDC_PWR_Pin , 0 ); //open drain kimenet,pch fet, //***************************************** /*for( i=900 ; i >= 620 ; i-=3){ __HAL_TIM_SetAutoreload(&htim3,i*2); __HAL_TIM_SetCompare(&htim3,CH1, i); __HAL_TIM_SetCompare(&htim3,CH2, i); HAL_Delay(1); }*/ /*********************************** HAL_Delay(100); __HAL_TIM_SetAutoreload(&htim3,i*2); __HAL_TIM_SetCompare(&htim3,CH1, i); __HAL_TIM_SetCompare(&htim3,CH2, i); HAL_Delay(1000);*/ HAL_GPIO_WritePin( DCDC_EN_GPIO_Port , DCDC_EN_Pin , 1 ); HAL_Delay(100); //19KHz-620 // 27KHz-440 old_i=i; for(uint8_t x=0; x < soundNum; x++){ // a következo hanghoz kis lépésenként jutunk, ígty nincs csattanás srand(HAL_GetTick()); i=(rand()%210)+440; //i=210+440; /* if( old_i < i){ // ha az új hang kissebb frekvenciájó -> nagyobb i for( temp_i=old_i ; i >= temp_i; temp_i++){ __HAL_TIM_SetAutoreload(&htim3,temp_i*2); __HAL_TIM_SetCompare(&htim3,CH1, temp_i); __HAL_TIM_SetCompare(&htim3,CH2, temp_i); HAL_Delay(1); } }else{ //ha az uj hang nagypbb frekvenciáju-> kisebb i for( temp_i=old_i ; i <= temp_i; temp_i--){ __HAL_TIM_SetAutoreload(&htim3,temp_i*2); __HAL_TIM_SetCompare(&htim3,CH1, temp_i); __HAL_TIM_SetCompare(&htim3,CH2, temp_i); HAL_Delay(1); } } */ __HAL_TIM_SetAutoreload(&htim3,i*2); __HAL_TIM_SetCompare(&htim3,CH1, i); __HAL_TIM_SetCompare(&htim3,CH2, i); old_i=i; tim=HAL_GetTick(); //jelenlegi ido lekérdezés tim_now=HAL_GetTick(); f=i%5; while( sDelay >= (tim_now-tim) && tim <= tim_now ){ ///késleltetés if(f==3){ for(temp_i=0 ; temp_i < 10 ;temp_i++){ //itt nagyobb lesz a frekvencia i+=1; __HAL_TIM_SetAutoreload(&htim3,i*2); __HAL_TIM_SetCompare(&htim3,CH1, i); __HAL_TIM_SetCompare(&htim3,CH2, i); HAL_Delay(1); } for(temp_i=0 ; temp_i < 10 ;temp_i++){ //itt kissebb lesz a frekvencia i-=1; __HAL_TIM_SetAutoreload(&htim3,i*2); __HAL_TIM_SetCompare(&htim3,CH1, i); __HAL_TIM_SetCompare(&htim3,CH2, i); HAL_Delay(1); } } tim_now=HAL_GetTick(); } // HAL_Delay(sDelay); randCount++; } //csattanás csökkentés, 19khz kiadás eloszor HAL_GPIO_WritePin( DCDC_EN_GPIO_Port , DCDC_EN_Pin , 0); for( i=i ; i <= 900 ; i+=3){ __HAL_TIM_SetAutoreload(&htim3,i*2); __HAL_TIM_SetCompare(&htim3,CH1, i); __HAL_TIM_SetCompare(&htim3,CH2, i); HAL_Delay(1); } HAL_Delay(100); HAL_TIM_PWM_Stop( &htim3 , CH1 ); HAL_TIM_PWM_Stop( &htim3 , CH2 ); HAL_TIM_PWM_Stop( &htim3 , CHx ); HAL_TIM_PWM_Stop( &htim3 , CHy ); HAL_TIM_PWM_DeInit( &htim3 ); // HAL_GPIO_WritePin( DCDC_PWR_GPIO_Port , DCDC_PWR_Pin , 1); //open drain kimenet,pch fet, HAL_Delay(100); SystemClock_Config_8MHz(); GPIO_TIM3_OFF(); HAL_Delay(100); }
void beeps (uint8_t num,uint8_t bridge){ uint16_t temp1; uint32_t CH1,CH2,CHx,CHy; // HAL_GPIO_WritePin( DCDC_PWR_GPIO_Port , DCDC_PWR_Pin , 0 ); //open drain kimenet,pch fet, HAL_Delay(100); HAL_GPIO_WritePin( DCDC_EN_GPIO_Port , DCDC_EN_Pin , 1 ); //open drain kimenet,pch fet, //bridge1=0,bridge2=1-> hogy melyik hidat hajtsa meg if(bridge){ //bridge1 CH1=(uint32_t)TIM_CHANNEL_1; CH2=(uint32_t)TIM_CHANNEL_2; CHx=(uint32_t)TIM_CHANNEL_3; CHy=(uint32_t)TIM_CHANNEL_4; }else{ //bridge2 CH1=(uint32_t)TIM_CHANNEL_3; CH2=(uint32_t)TIM_CHANNEL_4; CHx=(uint32_t)TIM_CHANNEL_1; CHy=(uint32_t)TIM_CHANNEL_2; } //SystemClock_Config_48MHz(); MX_TIM3_Init(); HAL_TIM_PWM_Init(&htim3); sConfigOC.OCMode = TIM_OCMODE_PWM1; sConfigOC.Pulse = 0; sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW; sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; HAL_TIM_PWM_ConfigChannel( &htim3 , &sConfigOC , CH1); sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; HAL_TIM_PWM_ConfigChannel( &htim3 , &sConfigOC , CH2); HAL_TIM_PWM_ConfigChannel( &htim3 , &sConfigOC , CHx); HAL_TIM_PWM_ConfigChannel( &htim3 , &sConfigOC , CHy); HAL_TIM_PWM_Start(&htim3, CH1); HAL_TIM_PWM_Start(&htim3, CH2); HAL_TIM_PWM_Start(&htim3, CHx); HAL_TIM_PWM_Start(&htim3, CHy); __HAL_TIM_SetCompare(&htim3,CH2,0); for( uint8_t i=0 ; i<num ; i++){ temp1=3500; for(uint8_t ii=0; ii<10 ; ii++){ __HAL_TIM_SetAutoreload(&htim3,temp1*2); __HAL_TIM_SetCompare(&htim3,CH1, temp1); //__HAL_TIM_SetCompare(&htim3,CH2,temp1); temp1 -=6; HAL_Delay(18); }/* for(uint8_t ii=0; ii<10 ; ii++){ __HAL_TIM_SetAutoreload(&htim3,temp1*2); __HAL_TIM_SetCompare(&htim3,CH1, temp1); // __HAL_TIM_SetCompare(&htim3,CH2,temp1); temp1 +=15; HAL_Delay(9); }*/ __HAL_TIM_SetCompare(&htim3,CH1, 0); // __HAL_TIM_SetCompare(&htim3,CH2,0); HAL_Delay(340); } __HAL_TIM_SetCompare(&htim3,CH1, 0); HAL_TIM_PWM_Stop( &htim3 , CH1 ); HAL_TIM_PWM_Stop( &htim3 , CH2 ); HAL_TIM_PWM_Stop( &htim3 , CHx ); HAL_TIM_PWM_Stop( &htim3 , CHy ); HAL_TIM_PWM_DeInit( &htim3 ); HAL_TIM_Base_DeInit(&htim3); GPIO_TIM3_OFF(); HAL_GPIO_WritePin( DCDC_EN_GPIO_Port , DCDC_EN_Pin , 0 ); //open drain kimenet,pch fet, HAL_Delay(100); // HAL_GPIO_WritePin( DCDC_PWR_GPIO_Port , DCDC_PWR_Pin , 0 ); HAL_Delay(1000); }
void uartTester(){ //UART fogadás, teszteléshez --------------------------------------------------------- uint8_t pData; PutString("S"); HAL_UART_Receive(&huart1,&pData,1,100); if(pData=='O'){ HAL_GPIO_TogglePin(Kimenet_GPIO_Port,Kimenet_Pin); PutString("R"); HAL_UART_Receive(&huart1,&pData,1,1000); while(pData != 'A') HAL_UART_Receive(&huart1,&pData,1,1000); HAL_GPIO_WritePin( DCDC_EN_GPIO_Port , DCDC_EN_Pin , 1 ); PutString("R"); HAL_UART_Receive(&huart1,&pData,8,1000); while(pData != 'B') HAL_UART_Receive(&huart1,&pData,8,1000); soundNum=1; sounDelay=10; SystemClock_Config_48MHz(); HAL_Delay(2); MX_TIM3_Init(); HAL_TIM_PWM_Init(&htim3); sConfigOC.OCMode = TIM_OCMODE_PWM1; sConfigOC.Pulse = 0; sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW; sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; HAL_TIM_PWM_ConfigChannel( &htim3 , &sConfigOC , TIM_CHANNEL_1); sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; HAL_TIM_PWM_ConfigChannel( &htim3 , &sConfigOC , TIM_CHANNEL_2); HAL_GPIO_TogglePin(Kimenet_GPIO_Port,Kimenet_Pin); HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1); HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_2); uint16_t i=630; __HAL_TIM_SetAutoreload(&htim3,i*2); __HAL_TIM_SetCompare(&htim3,TIM_CHANNEL_1, i); __HAL_TIM_SetCompare(&htim3,TIM_CHANNEL_2, i); HAL_Delay(500); PutString("R"); HAL_UART_Receive(&huart1,&pData,8,1000); while(pData != 'C') HAL_UART_Receive(&huart1,&pData,8,1000); HAL_GPIO_WritePin( DCDC_EN_GPIO_Port , DCDC_EN_Pin , 0); HAL_TIM_PWM_Stop( &htim3 , TIM_CHANNEL_1 ); HAL_TIM_PWM_Stop( &htim3 , TIM_CHANNEL_2 ); HAL_TIM_PWM_DeInit( &htim3 ); SystemClock_Config_8MHz(); HAL_ADC_MspDeInit(&hadc); HAL_UART_MspDeInit(&huart1); HAL_TIM_Base_DeInit(&htim3); while(1){ HAL_GPIO_TogglePin(Kimenet_GPIO_Port,Kimenet_Pin); HAL_Delay(200); } } }
/** * @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 accelration X_Offset and Y_Offset are divide by 40 to fir with ARR range */ NewARR_X = TIM_ARR - ABS(X_Offset/3); NewARR_Y = TIM_ARR - ABS(Y_Offset/3); /* Calculation of Max acceleration detected on X or Y axis */ Temp_X = ABS(X_Offset/3); Temp_Y = ABS(Y_Offset/3); 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_SetCounter(&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_SetCompare(&htim4, TIM_CHANNEL_1, NewARR_X/2); /* Time base configuration */ __HAL_TIM_SetAutoreload(&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_SetCompare(&htim4, TIM_CHANNEL_3, NewARR_X/2); /* Time base configuration */ __HAL_TIM_SetAutoreload(&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_SetCompare(&htim4, TIM_CHANNEL_2,NewARR_Y/2); /* Time base configuration */ __HAL_TIM_SetAutoreload(&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_SetCompare(&htim4, TIM_CHANNEL_4, NewARR_Y/2); /* Time base configuration */ __HAL_TIM_SetAutoreload(&htim4, NewARR_Y); /* Enable TIM4 Capture Compare Channel4 */ HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_4); } } Counter = 0x00; } } }