Contar de lento a rápido en un microcontrolador. (Rampa)

-2

Quiero hacer un incremento (++) a una variable inicialmente lentamente y luego acelerar de forma lineal. Por ejemplo, al utilizar una interrupción de temporizador (cada 1 segundo) para aumentar la variable x en 1.so, la primera variable se incrementa en 1 en 1 segundo. Luego debe incrementarse en 1 en 0.9 segundos, luego debe incrementarse en 1 en 0.8 segundos y así sucesivamente de manera lineal. ¿quién lo hace?

El hecho es que Tengo una función de bucle de caja de conmutador para el motor bldc.

    switch(step)
        {
            case 0:
            {
                commutation 1
            }
            break;
            case 1:
            {
                commutation 2
            }
            break;
            case 2:
                {
                commutation 3
                }
            break;
            case 3:
                {
                commutation 4
                }
            break;
            case 4:
                {
                commutation 5
                }
            break;
            case 5:
            {
                commutation 6
            }
            break;
        }
}

Quiero que ejecute los pasos de conmutación uno por uno dentro de una interrupción de temporizador.

void Handle_T13()// every 10000ms
{
    step++;
    if(step==6)
     {step=0;}      
}

Funciona bien. Pero ahora quiero aumentar la velocidad gradualmente. Así que necesito aumentar el incremento de pasos gradualmente. !!!

    
pregunta litun bls

1 respuesta

0

En tu ejemplo, parece que solo necesitas una resolución de 10 ms. En ese caso, solo cuenta los tics de 10 ms hasta la próxima vez para incrementar la variable. Ese conteo disminuye en 1 por cada incremento.

Otra forma es darse cuenta de que lo que realmente estás pidiendo es una variable que es una función cuadrática del tiempo. Incrementa mucho más a menudo de lo que necesitas, como cada 1 ms tal vez. El incremento se incrementa un poco cada vez. Dicho de otra manera, esto mantiene constante la segunda derivada, por lo que la primera derivada es lineal y el valor en sí es cuadrático. Por supuesto, esto requiere portar bits de fracción extra que finalmente no usas al agarrar el entero final.

    
respondido por el Olin Lathrop

Lea otras preguntas en las etiquetas