Paso 5: Macros
Las macros son muy similares a las subrutinas que ya comentamos en el último paso que toman "argumentos". En otras palabras, las macros son esencialmente "funciones". De hecho, la principal diferencia entre lenguaje ensamblador y todas las lenguas de "alto nivel" que uso es que alguien ha recopilado un montón de funciones frecuentemente utilizadas en las macros. Aquí vamos a utilizar macros para lograr los mismos fines, con una diferencia importante, nuestras macros estará ahí en el código para poder ver y modificar como nos gusta.
Nuestra filosofía en estos tutoriales es deshacerse de todas las "cajas negras" y averiguar lo que está sucediendo detrás de las escenas. No queremos que nada sucede a menos que saberlo y le dijo que hacer eso. Por esta razón se llama "Línea de comandos de programación de lenguaje ensamblador". Estamos utilizando la línea de comandos en lugar de algunos Java basado IDE como el arduino uno (de hecho, yo uso la línea de comandos incluso con programación de arduino). Una ventana del ide de java es como una caja negra para mí. Nunca puedo estar absolutamente seguro de que no hay hipótesis que detrás de las escenas cuando mis instrucciones en el microcontrolador y no me gusta. También no me gusta cómo hinchado y cpu consume java se. De hecho, es también por qué estamos utilizando "avra" en lugar del ensamblador de ATmel IDE. Me doy cuenta que cuando eres un programador experto, o un completo principiante, usted ya sabe, o no importa, lo que está sucediendo detrás de las escenas, pero aquí sacrificamos la comodidad para evitar boxness de negro y la gordura.
Ahora ¿qué son las macros? También habrás dado cuenta al leer a través del programa que usamos la subrutina de "retraso" por todo el lugar. No solo de interior principal, sino desde dentro de otras subrutinas así. Esto conduce a los espaguetis y no nos gusta el spaghetti. (dibujar líneas entre cada bloque de la subrutina del código en su diagrama de uno bloque llama a otro y rápidamente vemos que la subrutina de "retraso" hace que el diagrama para parecerse a un plato de espaguetis)
Aquí es cómo generalmente se llama "retardo":
Verás que primero establecemos el variable (es decir, registro de trabajo) "de milisegundos" el valor 25 y luego llamamos a la subrutina "retrasar". La subrutina se demora 25 ms y luego regresar. Aparte de espaguetis, otro problema con esta manera de hacer las cosas es que si olvidamos establecer el valor de milisegundos antes que llamar a la subrutina que no tenemos idea cuál será la demora. Va a ser cualquier valor que ponemos en otro lugar de milisegundos. Se trata de una manera arriesgada de escribir código. Tan para resolver todo esto simplemente escribimos una "macro". Aquí ' tis:
Es una directiva del ensamblador que ponemos en la parte superior de nuestro programa que hace retrasar la misma cosas que teníamos en nuestra subrutina de retardo, se llama delay, pero tiene la diferencia importante que fijar las variable "milisegundos" dentro de ella! El símbolo (símbolo cero) significa lo que colocamos junto a retraso cuando lo llamamos. Aquí es cómo lo llamamos entonces. Si queríamos un retraso de 25 ms en algún lugar en nuestro programa simplemente escribimos
y el ensamblador reemplazará la en la macro con 25 y obtenemos nuestro retraso de ms de 25.
Por qué también puede escribir macros que tienen muchos más argumentos si quieres. En ese caso se usaría y y así sucesivamente. Luego al llamar a la función necesitará todos los argumentos correspondientes a éstos a las cosas en la macro.
¿Creo que ahora se puede ver cómo hacen el comando de "delay(20)" del lenguaje de Arduino derecha?
Ejercicio 2: agregar una macro en el programa y cambiar todas las subrutinas que llame a la macro en lugar de una subrutina de retardo. (¡ Nota! En uno de los incidentes tienes que buscar alrededor para averiguar lo que el retraso se supone que es! Deliberadamente dejé hacia fuera de las ldi milisegundos en este caso)
