MANEJO DE TEMPORIZADORES

1. Objetivo General
Desarrollar una aplicación con el uso de temporizadores para su
funcionamiento.
A. Objetivos específicos
Al finalizar la práctica el estudiante:
• Será capaz de configurar temporizadores básicos en un
STM32.
• Será capaz de configurar un STM32 para medir la
frecuencia de un evento externo (Modo Captura).
• Será capaz de configurar un STM32 para controlar una
forma de onda de salida, o para indicar cuando ha
trascurrido un periodo de tiempo (Modo Comparador).

2. Integrantes del Grupo

Adrian Del Castillo Velasco

3. Marco teórico
● Un temporizador es un contador con una frecuencia de conteo que es
una fracción de su reloj fuente.
● Dependiendo del tipo de temporizador, su fuente de reloj puede ser un
reloj interno, un reloj externo u otro temporizador usado como maestro.
● Puede contar de manera incremental, decremental o ambas.
● Los temporizadores de los STM32 se pueden agrupar en varias
categorías.
● Temporizadores básicos – Basic timers: Timers de 16 bits usados como
generadores de bases de tiempo, que no tienen pines de entrada/salida.
También se pueden usar para alimentar el DAC y para actuar como
maestros para otros timers. TIM6, TIM7, TIM18.
Temporizadores de propósito general–General purpose timers:
Timers de 16 o 32 bits, con las mismas características que los
básicos,pero además pueden ser usados para captura y comparación,
captura de entrada (medición de frecuencia de entrada), modulación da
ancho de pulso – PWM, interfaz con sensores (encoder, sensor Hall), etc.
Proveen cuatro canales de entrada/salida programables. TIM2, TIM3,
TIM4, TIM5, TIM19, TIM22.
Temporizadores avanzados – Advanced timers:
Tienen las mismas funcionalidades que los de propósito general, pero
añaden varias otras, relacionadas con aplicaciones de control de motores
y la conversión digital de potencia (tres señales complementarias con
inserción de tiempo muerto y entrada de apagado de emergencia). TIM1,
TIM8, TIM20.

Temporizador de alta resolución – High resolution timer: Solamente en

algunos microcontroladores, normalmente dedicado al control de motores
y conversión de potencia HRTIM1.
Temporizadores de bajo consumo – Low power Timers: Especialmente
diseñados para aplicaciones de bajo consumo. LPTIM1, LPTIM2.
Relación entre las tres principales categorías de temporizadores de los
STM32.

Estructura
TIM_Base_InitTypeDef
typedef struct {
uint32_t Prescaler;
uint32_t CounterMode;
uint32_t Period;
uint32_t ClockDivision;
uint32_t RepetitionCounter;
 } TIM_Base_InitTypeDef;
Prescaler: Divide el reloj del timer por un factor entre 1 y 65535 (16 bits
de resolución).
CounterMode: Define la dirección de la cuenta. Para los temporizadores
básicos solamente puede ser hacia arriba.
Period: Valor máximo para el contador antes de reiniciarse. 1 a 65535
para un timer de 16 bits. Si su valor es cero, el timer no inicia.

4. Diseño
B. Enunciados

Parte 4.1 Realizar un programa que rote a la izquierda el

encendido de uno de ocho LEDs conectados a un puerto
configurado como salida. El salto de la rotación de LED a
LED debe ser en primera instancia cada 0,0625 segundos
durante 4 segundos y luego de 0,25 segundos durante los
siguientes 4 segundos.

Parte 4.2 Realizar un programa que incremente y

decremente la intensidad lumínica de un LED conectado a
un PIN de salida del STM32. Para tal efecto utilice una
salida PWM.

C. Cálculos

𝑃𝑒𝑟𝑖𝑜𝑑 + 1
0.0625 =
20000
Period=1249

8𝑀
20000 =
𝑃𝑟𝑒𝑠𝑐𝑎𝑙𝑒𝑟+1
Prescaler=399
D. Código
Parte 1
#include "main.h"
#include "stm32f1xx_hal.h"

TIM_HandleTypeDef htim2;
TIM_HandleTypeDef htim3
uint8_t con=0;
uint8_t con1=0;
uint8_t val=0;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_TIM2_Init(void);
static void MX_TIM3_Init(void);
int main(void)
{
Systick. */
HAL_Init();

SystemClock_Config();

MX_GPIO_Init();
MX_TIM2_Init();
MX_TIM3_Init();
/* USER CODE BEGIN 2 */

HAL_TIM_Base_Start_IT(&htim2);
HAL_TIM_Base_Start_IT(&htim3);

uint32_t tabla[8]={1,2,4,8,16,32,64,128};

/* USER CODE END 2 */

/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
GPIOA->ODR=tabla[val];
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}

void
HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef*htim){

if(htim->Instance==TIM2){
con++;
if(con<64){
val++;
if(val==8)
val=0;
}
if(con>64){

__HAL_TIM_SET_PRESCALER(&htim2,799);

__HAL_TIM_SET_AUTORELOAD(&htim2,2499);
val++;
if(val==8)
val=0;
}
 if(con==80){
con=0;

__HAL_TIM_SET_PRESCALER(&htim2,399);

__HAL_TIM_SET_AUTORELOAD(&htim2,1249);
}
}

}
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

/** Initializes the CPU, AHB and APB busses clocks

*/
RCC_OscInitStruct.OscillatorType =
RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB busses clocks
*/
RCC_ClkInitStruct.ClockType =
RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK

|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSE;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct,
FLASH_LATENCY_0) != HAL_OK)
{
Error_Handler();
}
}

static void MX_TIM2_Init(void)

{

TIM_ClockConfigTypeDef sClockSourceConfig = {0};

TIM_MasterConfigTypeDef sMasterConfig = {0};

htim2.Instance = TIM2;
htim2.Init.Prescaler = 399;
htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
 htim2.Init.Period = 1249;
htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim2.Init.AutoReloadPreload =
TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource =
TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim2,
&sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode =
TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim2,
&sMasterConfig) != HAL_OK)
{
Error_Handler();
}

static void MX_TIM3_Init(void)

{

TIM_ClockConfigTypeDef sClockSourceConfig = {0};

TIM_MasterConfigTypeDef sMasterConfig = {0};

htim3.Instance = TIM3;
htim3.Init.Prescaler = 799;
htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
htim3.Init.Period = 2499;
htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim3.Init.AutoReloadPreload =
TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource =
TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim3,
&sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode =
TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim3,
&sMasterConfig) != HAL_OK)
{
 Error_Handler();
}
}

/**
* @brief GPIO Initialization Function
* @param None
* @retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};

/* GPIO Ports Clock Enable */

__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();

/*Configure GPIO pin Output Level */

HAL_GPIO_WritePin(GPIOA,
GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3

|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7,
GPIO_PIN_RESET);

GPIO_InitStruct.Pin =
GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3

|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

void Error_Handler(void)
{

#ifdef USE_FULL_ASSERT
void assert_failed(uint8_t *file, uint32_t line)
{
}
#endif /* USE_FULL_ASSERT */

Parte 2

#include "main.h"
#include "stm32f1xx_hal.h"

TIM_HandleTypeDef htim2;
int pwm=0;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_TIM2_Init(void);
int main(void)
{
HAL_Init();

SystemClock_Config();

MX_GPIO_Init();
MX_TIM2_Init();

HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_1);

while (1)
{
/* USER CODE END WHILE */
for (pwm=0;pwm<=999;pwm=pwm+1){
__HAL_TIM_SET_COMPARE(&htim2,
TIM_CHANNEL_1, pwm);
HAL_Delay(5);
}
HAL_Delay(500);
for (pwm=999;pwm>=0;pwm=pwm-1){
__HAL_TIM_SET_COMPARE(&htim2,
TIM_CHANNEL_1, pwm);
HAL_Delay(5);
}
HAL_Delay(500);

/* USER CODE BEGIN 3 */

}
/* USER CODE END 3 */
}

/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

/** Initializes the CPU, AHB and APB busses clocks

*/
RCC_OscInitStruct.OscillatorType =
RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB busses clocks
*/
RCC_ClkInitStruct.ClockType =
RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSE;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct,
FLASH_LATENCY_0) != HAL_OK)
{
Error_Handler();
}
}

/**
* @brief TIM2 Initialization Function
* @param None
* @retval None
*/
static void MX_TIM2_Init(void)
{

/* USER CODE BEGIN TIM2_Init 0 */

/* USER CODE END TIM2_Init 0 */

TIM_ClockConfigTypeDef sClockSourceConfig = {0};

TIM_MasterConfigTypeDef sMasterConfig = {0};
TIM_OC_InitTypeDef sConfigOC = {0};

/* USER CODE BEGIN TIM2_Init 1 */

/* USER CODE END TIM2_Init 1 */

htim2.Instance = TIM2;
htim2.Init.Prescaler = 39;
htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
htim2.Init.Period = 999;
htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim2.Init.AutoReloadPreload =
TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource =
TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim2,
&sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_Init(&htim2) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode =
TIM_MASTERSLAVEMODE_DISABLE;
 if (HAL_TIMEx_MasterConfigSynchronization(&htim2,
&sMasterConfig) != HAL_OK)
{
Error_Handler();
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 500;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC,
TIM_CHANNEL_1) != HAL_OK)
{
Error_Handler();
}

HAL_TIM_MspPostInit(&htim2);

static void MX_GPIO_Init(void)

{

/* GPIO Ports Clock Enable */

__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();

void Error_Handler(void)
{
}
#ifdef USE_FULL_ASSERT
void assert_failed(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
}

E. Simulación

Parte 1
 Parte 2

5. Conclusiones
*Se pudo implementar el TIM2 como temprizador para el conteo de 0.0625
s y 0.25 s por un periodo de 4 s , se realiao un cambio de period y
prescaler para lograrlo.
*Se programo el TIM2 el CHANNEL 1 para poder realizar la salida pwm.
*Se pudo implementar los conocimientos adquiridos en clase para poder
realizar cada una de las practicas.
6. Cuestionario
1. Explicar la diferencia de la captura y la comparación.
2. Explique la diferencia entre un temporizador básico y un contador de
eventos.
7. Bibliografía