Medir la carga de la CPU de la rutina de interrupción

Solo una idea a medias, es posible que puedas usar temporizadores como este (pseudo código):

int main(void)
{

    /* ... init timers and uart here, enable your interrupts ... */

    start_timer0();
    while (!timer1Started()){}
    stop_timer1();

    uart_puts("Idle ticks: %d, ISR ticks: %d", timer0_value, timer1_value);

}

y en tu pantalla ISR ...

ISR_display()
{
    stop_timer0();
    start_timer1();

    /* ... your ISR routine ... */
}

He hecho algunos supuestos aquí. 1: que no está utilizando sus temporizadores para otra cosa, y que, 2: la sobrecarga de iniciar y detener un temporizador es mínima (por lo general, con una sola escritura de registro). EDITAR: y una tercera suposición, puede capturar todo esto antes de que ocurra un desbordamiento del temporizador, pero quizás también pueda tenerlo en cuenta.

Habrá una sobrecarga de cambio de contexto que no podrá capturar, y esto también agrega dos operaciones adicionales en su ISR (asegúrese de usar macros para su start_timer / stop_timer para eliminar la sobrecarga de llamadas de función). Si puede obtener el número total de ciclos utilizados para las macros de inicio y detención del temporizador, entonces puede restar esos ticks del valor de timer1_value para obtener un valor de ticks ISR un poco más preciso. Su cálculo final para el% de tiempo de CPU utilizado sería simplemente:

$$ Usage_ {cpu} = (\ frac {Ticks_ {isr}} {Ticks_ {isr} + Ticks_ {idle}}) * 100 $$

Establezca un pin de salida cuando ingrese el ISR y elimínelo antes de regresar. Filtra la salida con un filtro RC. El voltaje a través del capacitor debe darle el ciclo de trabajo ISR.
Por ejemplo, si su fuente de alimentación es de 3.3 V y usted mide 33 mV, entonces gasta el 1% del tiempo en el ISR.

La forma más fácil de hacerlo es ejecutar el código en el simulador y medir los ciclos tomados por la rutina de interrupción. El simulador Microchip MPLAB, por ejemplo, tiene una útil función de cronómetro que es muy útil para este propósito.

Si falla esto, puede ser útil levantar un pin al comienzo de la interrupción y bajarlo al final. La forma más fácil de ver eso es con un osciloscopio. Si está realizando proyectos de microcontroladores y electrónicos, debería obtener uno de todos modos.

Sin un alcance, podría simplemente pasar el filtro de paso bajo del pin y luego medirlo con un voltímetro. Ese voltaje dividido por el voltaje de potencia del procesador le dará la fracción del tiempo que el pin está alto. Por ejemplo, si el procesador está funcionando a 3.3 V y el voltaje del pin filtrado de paso bajo es de 800 mV, entonces el pin es alto 800 mV / 3.3 V = 24% del tiempo.

Ya que aparentemente estás usando un compilador, necesitas desviar esta respuesta un poco. Es probable que el compilador agregue algún código de entrada de interrupción antes de que se ejecute su código e interrumpa el código de salida después de que se ejecute su código. El verdadero tiempo de interrupción se extenderá unos pocos ciclos a cada lado del pulso. Por supuesto, si te preocupa el tiempo de interrupción, no deberías usar un compilador en primer lugar.