Foro - Perl en Español

Impacientes: saltar a la sección Programa

Resumen
Se propone resolver la cuestión de la realización de retardos en microcontroladores PIC por medio de un programa que genera el código necesario.

Introducción
En el mundo de la programación de microcontroladores, a veces ocurre que debemos crear un bucle de espera o retardo en el código, quizás porque necesitamos sincronizar el sistema con un sistema externo o con el mundo físico, o simplemente porque sabemos que no necesitamos que el sistema atienda ninguna actuación externa durante un tiempo, o porque el sistema externo necesita de una actuación precisa por parte del sistema microcontrolador.

En la mayor parte de las ocasiones, ese tipo de esperas se puede realizar con:

• los temporizadores internos
• esperando en un bucle, leyendo las entradas hasta que se produzca un evento (un temporizador externo o la acción de un actuador externo)
• poner el controlador en modo SLEEP. El microcontrolador se despertará cuando ocurra un evento o interrupción

Justificación
Pero no siempre es así. Hay ocasiones en las que necesitamos esperar un tiempo muy determinado o un número exacto de ciclos.

Los retardos se suelen crear como bucles sencillos:


Explicación
Pero no es tan sencillo, ya que:

• el periodo de un ciclo depende de la frecuencia de reloj del microcontrolador
• cada vuelta decrementado-goto consume un número de ciclos fijo, con lo que a veces no se obtiene un resultado exacto

Del ejemplo, vemos que el bucle se ejecuta 0x41 vueltas consumiendo, en cada una de ellas, 1 ciclo en la instrucción de decrementado, más 2 ciclos por la instrucción goto. En la última vuelta, cuando 'd1' pasa de '1' a '0', el decrementado hace "saltar" la instrucción goto, terminando el bucle. Eso suma 2 ciclos por esa última vuelta. Y hay que sumar los dos ciclos consumidos por las dos primeras instrucciones, donde se inicializa el contador 'd1'.

Echando cuentas: 2 + 0x41 * 3 + 2 = 199 ciclos.

Si quisiéramos tener exactamente 200 ciclos, estamos obligados a añadir un 'nop' al final (1 ciclo de instrucción más).

La cosa se complica si queremos tiempos de espera mayores. En esos casos, se hacen bucles anidados. Así, los ciclos consumidos por los bucles más profundos son multiplicados por los exteriores. Además, queremos que esos bucles internos consuman aún más ciclos que un ciclo normal, ya que queremos realizar una espera mucho más larga.

Una posibilidad es la de encadenar los goto de cada bucle anidado, haciendo que se sume 2 ciclos en cada salto. Ejemplo para tres bucles anidados:
En cada vuelta del bucle que decrementa 'd1', el goto salta al goto del nivel más superior, sumando 2 ciclos más. Así, con 3 bucles anidados tenemos que se consumen 7 ciclos por cada vuelta. Para el bucle de 'd2', son 5 ciclos por vuelta.

Además, cuando 'd1' agota su valor inicial, en la siguiente vuelta (impuesta por la siguiente vuelta de 'd2'), comenzará a decrementar desde '0', por lo que realizará 255 vueltas consumiendo 7 ciclos (más una vuelta final, de 2 ciclos).

El cálculo de los ciclos generados es el siguiente:

<ciclos generados por N niveles de anidamiento>
= <ciclos para la inicialización de N niveles>
+ <ciclos generados por las últimas vueltas de los bucles>
+ <ciclos generados por el bucle más interno>
* ∑(i=1,i=N){ 256^(i-1) * (di-1) }

= 2 * N + 2 * N + (2 * N + 1) * ∑(i=1,i=N){ 256^(i-1) * (di-1) }
= 2 * 2 * N + (2 * N + 1) * ∑(i=1,i=N){ 256^(i-1) * (di-1) }

Este cálculo no siempre es exacto con respecto a la espera que se desea: se obtienen números de ciclo que son múltiplos de los <ciclos generados por el bucle más interno>. Eso implica que a veces faltan (<ciclos generados por el bucle más interno> - 1) para llegar a la cifra correcta.

Esto se resuelve con el añadido de instrucciones adicionales, después de los bucles anidados. Poniendo una instrucción de goto, tenemos 2 ciclos más. Y poniendo una instrucción nop, 1 ciclo más.

El cálculo de los parámetros 'di' es el siguiente:

ciclos := <número_de_ciclos_que_deseamos_generar> - (2 * 2 * N)
loop := int(ciclos / (1 + 2 * N))
Para i=1 a N:
di := 1 + (int(loop/(256^(i-1))) % 256)
:Fin Para
ciclos_restantes_al_final := ciclos - loop * (1 + 2 * N)

Primero se va probando para N=1 (un solo bucle), y si la cantidad de ciclos generada no es suficiente, se repite el cálculo para N=2, y así sucesivamente.

Programa
Para facilitar la tarea del cálculo, se muestra el siguiente programa escrito en Perl, que genera un salida en texto con el código fuente en ensamblador que produce la espera deseada.

Como argumentos, se indicará la frecuencia de trabajo de la señal de reloj del microcontrolador, y la espera deseada, expresada tanto en forma de tiempo como en forma de ciclos de instrucción. Opcionalmente, se puede indicar argumento '-s' seguido de un nombre, y se generará el mismo código, pero ajustado para que sea incorporado al programa principal en forma de subrutina.

Ejemplos de llamada:

./delay_pic.pl -freq 4mhz -delay 1s
./delay_pic.pl -frec 32768hz -espera 200ms
./delay_pic.pl -f 20000000 -d 1000000
./delay_pic.pl 20mhz 500us
./delay_pic.pl -sub Wait_4µs 64Mhz 4us

El código se encuentra en Github: https://github.com/joaquinferrero/delay_pic

Ejemplo de salida:

La salida es -prácticamente- igual al generador de Golovchenko. Hay algunas diferencias: aparte del idioma, este programa genera siempre una solución basada en bucles, a diferencia del de Golovchenko, en que en ocasiones, genera ciclos por medio de más sentencias goto $+1 extras (ejecutarlo para 779 ciclos de espera, a 4 Mhz, por ejemplo).

La estructura interna es un poco peculiar, sí.

Se ve que va arrastrando la herencia de circuitos anteriores. Y el tema de la memoria paginada o por bancos.

Bueno, pero programando en C, la complejidad de los bancos desaparece.

A mí, el 16F877A me parece una auténtica virguería. ¡14 interrupciones distintas y cinco puertos de E/S!

Me han dicho que los AVR están mucho mejor, más cartesianos.