void POLOLU_MOTOR_Break_InIn(DRIVER_InitTypeDef *driver, MOTOR_InitTypeDef *motor) { HAL_TIM_PWM_Stop(motor->htimIn1, motor->ChannelIn1); HAL_TIM_PWM_Stop(motor->htimIn2, motor->ChannelIn2); motor->GPIOxIn1->BSRR = motor->PinIn1; motor->GPIOxIn2->BSRR = motor->PinIn2; }
void test_Beeper(void) { if(HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_4) != HAL_OK) { /* Starting Error */ // Error_Handler(); } HAL_Delay(100); if(HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_4) != HAL_OK) { /* Starting Error */ // Error_Handler(); } HAL_Delay(100); if(HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_4) != HAL_OK) { /* Starting Error */ // Error_Handler(); } HAL_Delay(200); if(HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_4) != HAL_OK) { /* Starting Error */ // Error_Handler(); } }
/** * @brief Deactivate the PWM functionality for the channel * @param None * @retval None */ static void prvDeactivatePwmFunctionality() { HAL_GPIO_DeInit(GPIO0_PORT, GPIO0_PIN); TIM_HandleTypeDef timerHandle; timerHandle.Instance = PWM_TIMER; HAL_TIM_PWM_Stop(&timerHandle, PWM_TIMER_CHANNEL); }
void BSP_Radio_ServoStatus(FunctionalState state) { _servo = state; if (state == ENABLE && _signalDetected == SET) { HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_4); } else { HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_4); } }
/* --- Stop motor PWM --- */ void StopMotor(uint8_t motorPort) { switch (motorPort) { case P1 : HAL_TIM_PWM_Stop(&htim15, TIM_CHANNEL_1); break; case P3 : HAL_TIM_PWM_Stop(&htim3, TIM_CHANNEL_1); break; case P4 : HAL_TIM_PWM_Stop(&htim3, TIM_CHANNEL_3); break; default: break; } }
void Time3Disable(void) { if(HAL_TIM_PWM_Stop(&TimHandle, TIM_CHANNEL_3) != HAL_OK) { /* Starting Error */ Error_Handler(); } }
/* conv_boot * Initialize all converter pins to off */ void conv_init(batpins batx) { /* First battery */ HAL_GPIO_WritePin(batx.chg_port, batx.chg_pin, GPIO_PIN_RESET); // Charging off pwm_Set(batx.pwm_tims.dchg_timer, batx.dchg_pin, 0); HAL_TIM_PWM_Stop(&batx.pwm_tims.dchg_timer, batx.dchg_pin); // Discharge off HAL_TIM_PWM_Stop_DMA(&batx.pwm_tims.conv_timer, batx.conv_chg_pin); // Conv chg off HAL_TIM_PWM_Stop_DMA(&batx.pwm_tims.conv_timer, batx.conv_dchg_pin); // Conv dchg off }
void HAL_PWM_Enable(int channel, int enable) { #ifdef ENABLE_PWM_GENERATION if ( channel < sizeof(pwm_timer_channels)/sizeof(pwm_timer_channels[0])) { if ( enable != 0 ) { HAL_TIM_PWM_Start(pwm_timer_channels[channel].p_tim_handle, pwm_timer_channels[channel].tim_channel_number); } else { HAL_TIM_PWM_Stop(pwm_timer_channels[channel].p_tim_handle, pwm_timer_channels[channel].tim_channel_number); } } #endif }
// Arduino tone() compatible void tone(int note, int duration) { int uwPrescalerValue = 1800; uwPrescalerValue = (uint32_t) ((SystemCoreClock /2) / (note * 1000)) - 1; htim11.Instance = TIM11; htim11.Init.Prescaler = uwPrescalerValue; htim11.Init.CounterMode = TIM_COUNTERMODE_UP; htim11.Init.Period = 1000-1; htim11.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; HAL_TIM_Base_Init(&htim11); HAL_TIM_PWM_Init(&htim11); HAL_TIM_PWM_Start(&htim11, TIM_CHANNEL_1); HAL_Delay(duration); HAL_TIM_PWM_Stop(&htim11, TIM_CHANNEL_1); }
void POLOLU_MOTOR_Run_InIn(DRIVER_InitTypeDef *driver, MOTOR_InitTypeDef *motor, uint32_t mode, uint32_t speed) { if (mode == MOTOR_IN_IN_BREAK) { POLOLU_MOTOR_Break_InIn(driver, motor); return; } TIM_OC_InitTypeDef sConfigOC; sConfigOC.OCMode = TIM_OCMODE_PWM1; sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; sConfigOC.OCFastMode = TIM_OCFAST_ENABLE; switch (mode) { case MOTOR_IN_IN_COAST: HAL_TIM_PWM_Stop(motor->htimIn1, motor->ChannelIn1); HAL_TIM_PWM_Stop(motor->htimIn2, motor->ChannelIn2); motor->GPIOxIn1->BSRR = (uint32_t)(motor->PinIn1) << 16; motor->GPIOxIn2->BSRR = (uint32_t)(motor->PinIn2) << 16; break; case MOTOR_IN_IN_REVERSE_COAST: HAL_TIM_PWM_Stop(motor->htimIn1, motor->ChannelIn1); motor->GPIOxIn1->BSRR = (uint32_t)(motor->PinIn1) << 16; sConfigOC.Pulse = count_pulse(motor->htimIn2->Init.Period, speed); HAL_TIM_PWM_ConfigChannel(motor->htimIn2, &sConfigOC, motor->ChannelIn2); HAL_TIM_MspPostInit(motor->htimIn2); HAL_TIM_PWM_Start(motor->htimIn2, motor->ChannelIn2); break; case MOTOR_IN_IN_FORWARD_COAST: HAL_TIM_PWM_Stop(motor->htimIn2, motor->ChannelIn2); motor->GPIOxIn2->BSRR = (uint32_t)(motor->PinIn2) << 16; sConfigOC.Pulse = count_pulse(motor->htimIn1->Init.Period, speed); HAL_TIM_MspPostInit(motor->htimIn1); HAL_TIM_PWM_Start(motor->htimIn1, motor->ChannelIn2); break; case MOTOR_IN_IN_REVERSE: HAL_TIM_PWM_Stop(motor->htimIn2, motor->ChannelIn2); motor->GPIOxIn2->BSRR = motor->PinIn2; sConfigOC.Pulse = count_pulse(motor->htimIn1->Init.Period, speed); HAL_TIM_MspPostInit(motor->htimIn1); HAL_TIM_PWM_Start(motor->htimIn1, motor->ChannelIn2); break; case MOTOR_IN_IN_FORWARD: HAL_TIM_PWM_Stop(motor->htimIn1, motor->ChannelIn1); motor->GPIOxIn1->BSRR = motor->PinIn1; sConfigOC.Pulse = count_pulse(motor->htimIn2->Init.Period, speed); HAL_TIM_PWM_ConfigChannel(motor->htimIn2, &sConfigOC, motor->ChannelIn2); HAL_TIM_MspPostInit(motor->htimIn2); HAL_TIM_PWM_Start(motor->htimIn2, motor->ChannelIn2); } }
/** * @brief This function will disable the PWM * @param port : the gpio port to use * @param pin : the gpio pin to use * @retval None */ void pwm_stop(PinName pin) { TIM_HandleTypeDef timHandle; uint32_t timChannel; timHandle.Instance = pinmap_peripheral(pin, PinMap_PWM); if (timHandle.Instance == NP) return; timChannel = get_pwm_channel(pin); if (!IS_TIM_CHANNELS(timChannel)) return; #if !defined(STM32L0xx) && !defined(STM32L1xx) if (STM_PIN_INVERTED(pinmap_function(pin, PinMap_PWM))) { HAL_TIMEx_PWMN_Stop(&timHandle, timChannel); } else #endif { HAL_TIM_PWM_Stop(&timHandle, timChannel); } HAL_TIM_PWM_DeInit(&timHandle); }
/** * 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; } } } }
void tonesplayer(int *note, int *duration, int size, int tempo) { int FREQ_NOTE=240; int uwPrescalerValue=1800; for (int ii=0;ii<size;ii++) { FREQ_NOTE = note[ii]; uwPrescalerValue = (uint32_t) ((SystemCoreClock /2) / (FREQ_NOTE * 1000)) - 1; htim11.Instance = TIM11; htim11.Init.Prescaler = uwPrescalerValue; htim11.Init.CounterMode = TIM_COUNTERMODE_UP; htim11.Init.Period = 1000; htim11.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; HAL_TIM_Base_Init(&htim11); HAL_TIM_PWM_Init(&htim11); HAL_TIM_PWM_Start(&htim11, TIM_CHANNEL_1); HAL_Delay(60000*duration[ii] / (tempo*4) - 60); HAL_TIM_PWM_Stop(&htim11, TIM_CHANNEL_1); HAL_Delay(60); } }
void DisablePWM(void) { HAL_TIM_PWM_Stop(&TimHandle,TIM_CHANNEL_1); }
/** * @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; } } }
/** * @brief Deintialize the buzzer * @param None * @retval None */ void BUZZER_DeInit() { HAL_GPIO_DeInit(BUZZER_PORT, BUZZER_PIN); HAL_TIM_PWM_Stop(&prvTimerHandle, BUZZER_TIMER_CHANNEL); HAL_TIM_PWM_DeInit(&prvTimerHandle); }
Status_t xMotorStop(TIM_HandleTypeDef* pxTIMHandle, MotorChannel_t xChannel) { /*##- Stop PWM signals generation #######################################*/ switch(xChannel) { case MOTOR_CHANNEL_1: /* Start channel 1 */ if(HAL_TIM_PWM_Stop(pxTIMHandle, TIM_CHANNEL_1) != HAL_OK) { /* PWM Generation Error */ return STATUS_ERROR; } break; case MOTOR_CHANNEL_2: /* Start channel 2 */ if(HAL_TIM_PWM_Stop(pxTIMHandle, TIM_CHANNEL_2) != HAL_OK) { /* PWM Generation Error */ return STATUS_ERROR; } break; case MOTOR_CHANNEL_3: /* Start channel 3 */ if(HAL_TIM_PWM_Stop(pxTIMHandle, TIM_CHANNEL_3) != HAL_OK) { /* PWM Generation Error */ return STATUS_ERROR; } break; case MOTOR_CHANNEL_4: /* Start channel 4 */ if(HAL_TIM_PWM_Stop(pxTIMHandle, TIM_CHANNEL_4) != HAL_OK) { /* PWM Generation Error */ return STATUS_ERROR; } break; case MOTOR_CHANNEL_ALL: /* Start channel 1 */ if(HAL_TIM_PWM_Stop(pxTIMHandle, TIM_CHANNEL_1) != HAL_OK) { /* PWM Generation Error */ return STATUS_ERROR; } /* Start channel 2 */ if(HAL_TIM_PWM_Stop(pxTIMHandle, TIM_CHANNEL_2) != HAL_OK) { /* PWM Generation Error */ return STATUS_ERROR; } /* Start channel 3 */ if(HAL_TIM_PWM_Stop(pxTIMHandle, TIM_CHANNEL_3) != HAL_OK) { /* PWM Generation Error */ return STATUS_ERROR; } /* Start channel 4 */ if(HAL_TIM_PWM_Stop(pxTIMHandle, TIM_CHANNEL_4) != HAL_OK) { /* PWM Generation Error */ return STATUS_ERROR; } break; default: return STATUS_ERROR; } /* Return OK */ return STATUS_OK; }
void POLOLU_MOTOR_Break_EnablePhase(DRIVER_InitTypeDef *driver, MOTOR_InitTypeDef *motor) { HAL_TIM_PWM_Stop(motor->htimIn2, motor->ChannelIn2); (motor->GPIOxIn2)->BSRR = (uint32_t)(motor->PinIn2) << 16; }
void test_Motor_Move() { GPIO_InitTypeDef GPIO_InitStruct; TIM_ClockConfigTypeDef sClockSourceConfig; TIM_OC_InitTypeDef sConfigOC; TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig; TIM_MasterConfigTypeDef sMasterConfig; ADXRS620_Init(); init_display(); uint32_t coef = 6; uint32_t correct = 0; long K1 = 1571; long K2 = 1532; long K3 = 225; // 1571 // 1532 // 225 // 23562 // 22982 // 225 int PWMOld = 0; int PWM =0; int error =0; int errorOld=0; int consigne = 0; htim8.Instance = TIM8; htim8.Init.Prescaler = 4; htim8.Init.CounterMode = TIM_COUNTERMODE_UP; htim8.Init.Period = 1000-1; htim8.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; htim8.Init.RepetitionCounter = 0; HAL_TIM_Base_Init(&htim8); sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL; HAL_TIM_ConfigClockSource(&htim8, &sClockSourceConfig); HAL_TIM_PWM_Init(&htim8); sConfigOC.OCMode = TIM_OCMODE_PWM1; sConfigOC.Pulse = 500; sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; sConfigOC.OCNPolarity = TIM_OCPOLARITY_LOW; sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET; HAL_TIM_PWM_ConfigChannel(&htim8, &sConfigOC, TIM_CHANNEL_1); // HAL_TIM_PWM_ConfigChannel(&htim8, &sConfigOC, TIM_CHANNEL_2); // HAL_TIM_PWM_ConfigChannel(&htim8, &sConfigOC, TIM_CHANNEL_3); HAL_TIM_PWM_ConfigChannel(&htim8, &sConfigOC, TIM_CHANNEL_4); sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE; sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE; sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF; sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE; sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH; sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE; HAL_TIMEx_ConfigBreakDeadTime(&htim8, &sBreakDeadTimeConfig); sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; HAL_TIMEx_MasterConfigSynchronization(&htim8, &sMasterConfig); GPIO_InitStruct.Pin = GPIO_PIN_7|GPIO_PIN_8; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); HAL_GPIO_WritePin(GPIOC, GPIO_PIN_7, SET); HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, SET); uint32_t Pulses[2] = {50,50}; HAL_GPIO_WritePin(GPIOA, GPIO_PIN_11, RESET); // sConfigOC.OCMode = TIM_OCMODE_PWM1; // sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; // sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; // sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET; HAL_GPIO_WritePin(GPIOA, GPIO_PIN_11, SET); //for(int y = 0; y < 4000; y++) consigne = 200; PWM = consigne; // PWM_R = consigne; while(1) { PWMOld = PWM; errorOld = error; error = (int32_t) gyro_Current_Angle; PWM = (K1*error - K2*errorOld + K3*PWMOld)/256; if ((((consigne - PWM) + consigne) > 0) && (((PWM - consigne) + consigne) > 0)) { Pulses[0] = (consigne - PWM) + consigne; Pulses[1] = (PWM - consigne) + consigne; } // HAL_TIM_PWM_Stop(&htim8, TIM_CHANNEL_1); // HAL_TIM_PWM_Stop(&htim8, TIM_CHANNEL_4); sConfigOC.Pulse = Pulses[0]; HAL_TIM_PWM_ConfigChannel(&htim8, &sConfigOC, TIM_CHANNEL_1); sConfigOC.Pulse = (1000 - Pulses[1]); HAL_TIM_PWM_ConfigChannel(&htim8, &sConfigOC, TIM_CHANNEL_4); HAL_TIM_PWM_Start(&htim8, TIM_CHANNEL_1); HAL_TIM_PWM_Start(&htim8, TIM_CHANNEL_4); HAL_Delay(1); ssd1306ClearScreen(); ssd1306PrintInt(10, 5, "Correct = ", error, &Font_5x8); ssd1306PrintInt(10, 15, "Pulses[0] = ", Pulses[0], &Font_5x8); ssd1306PrintInt(10, 25, "Pulses[1] = ", Pulses[1], &Font_5x8); ssd1306Refresh(); } HAL_GPIO_WritePin(GPIOC, GPIO_PIN_7, RESET); HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, RESET); HAL_GPIO_WritePin(GPIOA, GPIO_PIN_11, RESET); HAL_TIM_PWM_Stop(&htim8, TIM_CHANNEL_1); HAL_TIM_PWM_Stop(&htim8, TIM_CHANNEL_4); // HAL_Delay(1); }
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 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); } } }
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); }
/** * @brief Commutation event callback in non blocking mode * @param htim : hadc handle * @retval None */ void HAL_TIMEx_CommutationCallback(TIM_HandleTypeDef *htim) { /* Entry state */ if (uwStep == 0) { /* Next step: Step 1 Configuration -------------------------------------- */ sConfig.OCMode = TIM_OCMODE_PWM1; HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); HAL_TIMEx_OCN_Stop(&TimHandle, TIM_CHANNEL_1); /* Channel3 configuration */ sConfig.OCMode = TIM_OCMODE_PWM1; HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3); HAL_TIMEx_OCN_Start(&TimHandle, TIM_CHANNEL_3); HAL_TIM_PWM_Stop(&TimHandle, TIM_CHANNEL_3); /* Channel2 configuration */ HAL_TIM_OC_Stop(&TimHandle, TIM_CHANNEL_2); HAL_TIMEx_OCN_Stop(&TimHandle, TIM_CHANNEL_2); uwStep = 1; } if (uwStep == 1) { /* Next step: Step 2 Configuration -------------------------------------- */ /* Channel1 configuration */ /* Same configuration as the previous step */ /* Channel2 configuration */ sConfig.OCMode = TIM_OCMODE_PWM1; HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2); HAL_TIMEx_OCN_Start(&TimHandle, TIM_CHANNEL_2); /* Channel3 configuration */ HAL_TIMEx_OCN_Stop(&TimHandle, TIM_CHANNEL_3); uwStep++; } else if (uwStep == 2) { /* Next step: Step 3 Configuration -------------------------------------- */ /* Channel2 configuration */ /* Same configuration as the previous step */ /* Channel3 configuration */ sConfig.OCMode = TIM_OCMODE_PWM1; HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_3); /* Channel1 configuration */ HAL_TIM_OC_Stop(&TimHandle, TIM_CHANNEL_1); uwStep++; } else if (uwStep == 3) { /* Next step: Step 4 Configuration -------------------------------------- */ /* Channel3 configuration */ /* Same configuration as the previous step */ /* Channel2 configuration */ HAL_TIMEx_OCN_Stop(&TimHandle, TIM_CHANNEL_2); /* Channel1 configuration */ sConfig.OCMode = TIM_OCMODE_PWM1; HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIMEx_OCN_Start(&TimHandle, TIM_CHANNEL_1); uwStep++; } else if (uwStep == 4) { /* Next step: Step 5 Configuration -------------------------------------- */ /* Channel3 configuration */ HAL_TIM_OC_Stop(&TimHandle, TIM_CHANNEL_3); /* Channel1 configuration */ /* Same configuration as the previous step */ /* Channel2 configuration */ sConfig.OCMode = TIM_OCMODE_PWM1; HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); uwStep++; } else if (uwStep == 5) { /* Next step: Step 6 Configuration -------------------------------------- */ /* Channel3 configuration */ sConfig.OCMode = TIM_OCMODE_PWM1; HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3); HAL_TIMEx_OCN_Start(&TimHandle, TIM_CHANNEL_3); /* Channel1 configuration */ HAL_TIMEx_OCN_Stop(&TimHandle, TIM_CHANNEL_1); /* Channel2 configuration */ /* Same configuration as the previous step */ uwStep++; } else { /* Next step: Step 1 Configuration -------------------------------------- */ /* Channel1 configuration */ sConfig.OCMode = TIM_OCMODE_PWM1; HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); /* Channel3 configuration */ /* Same configuration as the previous step */ /* Channel2 configuration */ HAL_TIM_OC_Stop(&TimHandle, TIM_CHANNEL_2); uwStep = 1; } }
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 TIM3_StopPWM(uint32_t channel) { HAL_TIM_PWM_Stop(&htim3, channel); }