Пример #1
0
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);
}
Пример #3
0
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);
}
Пример #4
0
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
            }
        }
    }
}
Пример #5
0
// 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;
}
Пример #7
0
// 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;
}
Пример #9
0
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
}
Пример #10
0
/* 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 */ 
}
Пример #11
0
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;
            }
        }
    }
}
Пример #12
0
// 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;
}
Пример #13
0
// 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;
}
Пример #14
0
/**
 * @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);
	}


}
Пример #15
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
        }
    }
}
Пример #16
0
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();
	}
Пример #17
0
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);
}
Пример #18
0
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);
}	
Пример #19
0
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);
		}
	}
}
Пример #20
0
/**
  * @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;
    }  
  }
}