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);
}
