Control de tiempos de ejecución.

Hola a todos!! ¿Alguna vez os habéis preguntado cuanto tarda vuestro microcontrolador en ejecutar cierto programa?, quizás por curiosidad, o porque en vuestro proyecto los tiempo de ejecución son críticos, por ejemplo en un sistema de control embebido, os puede ser necesario conocerlos con exactitud. Para ello, MPLAB IDE no ofrece una herramienta de simulación muy completa con la que podemos tanto simular un código y medir lo tiempos de ejecución, como programar un microcontrolador y depurarlo, viendo también los tiempos de ejecución. La herramienta en cuestión se llama MPLAB SIM, y la podéis encontrar en DEBUGGER > SELECT TOOL > MPLAB SIM.

Para probar esta herramienta, vamos a crear un código muy sencillo, y vamos a experimentar con el.

   1: void main(){

   2:     

   3:     char x, y;

   4:     

   5:     int result;

   6:     

   7:  

   8:     while(1){

   9:         x = 100;

  10:         y = 200;

  11:  

  12:         result = x * y;

  13:         

  14:         x=x+4;

  15:         }

  16:     }

Hemos creado 2 variables tipo char de 8 bits, y una variable tipo entero de 16 bits. El código como veis es muy sencillo, y lo único que hacemos es realizar una multiplicación , y almacenar el resultado en una variable, luego incrementamos una de las variables en 4 y volvemos a realizar la operación.
Una vez compilado nuestro código, seleccionamos la herramienta MPLAB SIM, y nos aparecerá una nueva barra de herramientas con las opciones del simulador.

Desde aquí podemos arrancar el programa, pausar el programa, hacer una ejecución continua y que nos muestre en todo momento la instrucción que está realizando, las tres siguientes son para que el simulador nos muestre lo que hay dentro de una función, salga de ella, o decirle que no entre en las funciones, el siguiente botón es para realizar un reset del sistema, y el siguiente para crear un Breakpoint, también lo podemos crear dando doble click en la línea que queramos.

Vamos a crear un Breakpoint en cada una de las líneas del programa que están dentro del while(1), de forma que quede así:

Una vez compilado, debemos sacar la ventana que va a medir los tiempos, esta la encontramos en Debugger > StopWatch, y nos aparecerá una ventana como la siguiente:

La velocidad del procesador la podemos modificar desde Debugger > Settings. Si ahora le damos a play, veremos que una flecha aparecerá en la linea x = 100;, en ese momento si miramos la ventana de Stopwatch, nos aparecerán unos valores que nos indican, hasta ese punto, el tiempo que ha pasado, y las instrucciones que se han ejecutado. Esas instrucciones son las de inicialización del micro, y las de creación de las variables. Como estas no nos interesan por ahora, pulsamos sobre Zero para resetear los contadores de Stopwatch, aun así podemos seguir viendo el total simulado.

Una vez reseteados mediante el botón Zero, le damos de nuevo a play, y la flecha se nos situará en la siguiente línea. En ese momento, en la ventana de Stopwatch, vemos las instrucciones que le ha llevado al micro asignar el valor 100 a la variable x.

Que como vemos han sido 2 ciclos de reloj, y ha tardado 0.4 microsegundos. Con estos datos podemos saber a que velocidad ejecuta 1 instrucción el micro, simplemente hacemos 2/0.4us = 5MHz, que corresponde con Fclk/4.

A cotinuación podemos ver lo que le cuesta al microcontrolador realizar una multiplicación de 2 bytes, para lo cual le damos a play hasta que la flecha se sitúe en la línea de la multiplicación, ponemos a cero los contadores, y le damos al play.

Vemos que la multiplicación le ha costado 14 instrucciones hacer la multiplicación, y en tiempo eso son 2,8 microsegundos. Es interesante ver como microcontroladores DSPIC, estas operaciones son capaces de hacerlas en tan solo un ciclo de instrucción. Otro día os seguiré mostrando los secretos del MPLAB SIM, e intentaré mostraros ejemplos con DSPic y PIC32.