¿Cómo usar los temporizadores en la placa STM32 y la biblioteca HAL para medir la velocidad del motor?

La mejor manera es configurar un temporizador en modo codificador para contar los pulsos de su sensor. Si tiene pulsos A y B, elija el modo de codificador TIM_ENCODERMODE_TI12si solo tiene pulso A y luego TIM_ENCODERMODE_TI1. (Este código funciona bien en una placa Discovery STM32F4).

void MX_TIM3_Init(void)
{
    TIM_Encoder_InitTypeDef encoderConfig;

    __TIM3_CLK_ENABLE();

    htim3.Instance = TIM3;
    htim3.Init.Prescaler = 0;
    htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim3.Init.Period = 0xFFFF;
    htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

    encoderConfig.EncoderMode = TIM_ENCODERMODE_TI12;

    encoderConfig.IC1Polarity = TIM_ICPOLARITY_RISING;
    encoderConfig.IC1Selection = TIM_ICSELECTION_DIRECTTI;
    encoderConfig.IC1Prescaler = TIM_ICPSC_DIV1;
    encoderConfig.IC1Filter = 0x00;

    encoderConfig.IC2Polarity = TIM_ICPOLARITY_RISING;
    encoderConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;
    encoderConfig.IC2Prescaler = TIM_ICPSC_DIV1;
    encoderConfig.IC2Filter = 0x00;

    if(HAL_TIM_Encoder_Init(&htim3, &encoderConfig) != HAL_OK)
    {

    }
}

/**TIM3 GPIO Configuration - Encoder
PB4     ------> TIM3_CH1
PB5     ------> TIM3_CH2
*/
GPIO_InitStruct.Pin = GPIO_PIN_4 | GPIO_PIN_5;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF2_TIM3;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

En realidad, no nos dijo el tipo exacto de su STM32, por lo que debe verificar el temporizador, el pin y los valores de función alternativos para el suyo. Después de configurar el temporizador, se pueden usar las siguientes funciones simples.

Luego configure otro temporizador con interrupción periódica y llame a la Encoder_Readfunción en el ISR para consultar el valor de incremento actual.

uint32_t Encoder_Read(void)
{
    return TIM3->CNT;
}

void Encoder_Start(void)
{
    HAL_TIM_Encoder_Start(&htim3, TIM_CHANNEL_ALL);
}

void Encoder_Stop(void)
{
    HAL_TIM_Encoder_Stop(&htim3, TIM_CHANNEL_ALL);
}

En cada ISR puede calcular la diferencia entre el estado del contador anterior y el actual. Esa será la cantidad de pulsos durante el período a partir del cual puede calcular la velocidad (dado que sabe cuánto significa la distancia 1 incremento). Tenga en cuenta los posibles desbordamientos del contador.

actualización:
configuración de canal combinado: modo de codificador. Aquí hay una foto.

Puede usar un solo temporizador en el modo de captura de entrada para medir la velocidad de un motor a partir de los pulsos de tacómetro generados por el sensor. La señal del sensor debe enviarse a uno de los canales de captura de entrada del temporizador (es decir, un pin con una función alternativa para la captura de entrada del temporizador).

Configure el contador para contar a una velocidad constante que sea adecuada para el rango de velocidades que necesita medir. La frecuencia del contador debe ser lo suficientemente lenta como para no volcarse en el período entre los pulsos del tacómetro para la velocidad más lenta que pretende medir. Y la frecuencia del contador debe ser lo suficientemente rápida como para proporcionar suficiente resolución de tiempo entre pulsos de tacómetro para la velocidad más rápida que pretende medir.

En el modo de captura de entrada, el temporizador contará hasta el rango completo del valor del contador. Y el temporizador capturará el valor del contador y proporcionará una interrupción cada vez que se reciba un pulso de tacómetro. En el controlador de interrupciones, debe comparar el valor del temporizador recién capturado con el valor capturado anteriormente para determinar la cantidad de tics que se han producido entre los pulsos del tacómetro. Luego, con el número de tics entre los pulsos del tacómetro conocido, puede calcular la velocidad de rotación del motor.

Aquí hay un código de ejemplo. Deberá elegir el TACH_TMR_INSTANCE, TACH_TMR_TICK_RATE, TACH_TMR_IC_CHANNEL y la polaridad que sean apropiados para usted. Este ejemplo es para un contador de 16 bits, por lo que si está utilizando un contador de 32 bits, deberá ajustar el Periodvalor y el tipo de tach_timer_values, this_tach_timer_valuey prev_tach_timer_value. Tenga en cuenta que este ejemplo no muestra la HAL_TIM_IC_MspInit()función en la que se habilitan el temporizador y los relojes GPIO y el pin GPIO se configura para la función alternativa adecuada.

TIM_HandleTypeDef tach_timer_handle;
TIM_IC_InitTypeDef tach_timer_config;

HAL_StatusTypeDef TachInit()
{
    HAL_StatusTypeDef hal_status;

    tach_timer_handle.Instance = TACH_TMR_INSTANCE;

    tach_timer_handle.Init.Prescaler = (SystemCoreClock / TACH_TMR_TICK_RATE) - 1;
    tach_timer_handle.Init.Period = 0xFFFF;
    tach_timer_handle.Init.ClockDivision = 0;
    tach_timer_handle.Init.CounterMode = TIM_COUNTERMODE_UP;
    tach_timer_handle.Init.RepetitionCounter = 0;

    hal_status = HAL_TIM_IC_Init(&tach_timer_handle);
    if (hal_status != HAL_OK)
    {
        return hal_status;
    }

    tach_timer_config.ICPolarity = TIM_ICPOLARITY_RISING;
    tach_timer_config.ICSelection = TIM_ICSELECTION_DIRECTTI;
    tach_timer_config.ICPrescaler = TIM_ICPSC_DIV1;
    tach_timer_config.ICFilter = 0;

    hal_status = HAL_TIM_IC_ConfigChannel(&tach_timer_handle, &tach_timer_config, TACH_TMR_IC_CHANNEL);
    if (hal_status != HAL_OK)
    {
        return hal_status;
    }

    HAL_TIM_IC_Start_IT(&tach_timer_handle, TACH_TMR_IC_CHANNEL);
    if (hal_status != HAL_OK)
    {
        return hal_status;
    }

    return HAL_OK;
}


void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *tim_handle)
{
    // An array for storing the two most recent captured counter values.
    static uint16_t tach_timer_values[2] = {0, 0};
    // An array index to identify the most recently captured counter value.
    static int tach_timer_index = 0;

    if (tim_handle == &tach_timer_handle)
    {
        uint16_t this_tach_timer_value = HAL_TIM_ReadCapturedValue(tim_handle, TACH_TMR_IC_CHANNEL);
        tach_timer_values[tach_timer_index++] = this_tach_timer_value;
        tach_timer_index &= 0x01;
        uint16_t prev_tach_timer_value = tach_timer_values[tach_timer_index];

        unsigned int tach_period_ticks = this_tach_timer_value - prev_tach_timer_value;
    }
}

No necesita preocuparse por el traspaso del valor del contador al calcular tach_period_ticksde esta manera porque es matemática sin signo y el traspaso desaparece.

La velocidad del motor se puede calcular tach_period_ticksasí.

speed_rpm = (60 * TACH_TMR_TICK_RATE) / (tach_period_ticks * PULSES_PER_REVOLUTION);

TIM1 no parece estar haciendo nada. Su bucle while se ejecuta a una velocidad determinada por HAL_Delay, que (¿creo?) Está utilizando algún otro temporizador no definido explícitamente por usted (o eso o espera ocupado).

Si su intención es ejecutar a una velocidad determinada por TIM1, debe configurar una interrupción basada en la condición de coincidencia de este temporizador (o desbordamiento, o como lo llame ST).

En general, puedo creer que la idea de contar pulsos dado un período de tiempo fijo sería un indicador de la velocidad del motor, pero no sé lo suficiente sobre su hardware en particular para decir más.

¿Cómo usar los temporizadores en la placa STM32 y la biblioteca HAL para medir la velocidad del motor?

para ese tipo de cosas, primero piense en cómo lo mediría y luego cómo lo mediría con un enfoque/biblioteca particular.

en términos generales, necesitará un contador y una base de tiempo: para tener la cantidad de pulsos en un período de tiempo conocido.

dependiendo de la velocidad del motor, puede usar la base de tiempo para activar el contador, o viceversa. por ejemplo, puede precargar el contador con una compensación, iniciar la base de tiempo y luego interrumpir el desbordamiento del contador. O al revés.

Entonces, como máximo, se necesitan dos temporizadores. en algunos casos, un temporizador es suficiente.

Una vez que descubra el concepto, cómo implementarlo en su entorno de software es simple.