Interconexión de circuitos electrónicos para Arduinos (3 / 6 paso)

Paso 3: Conversión de las formas de onda en código

Paso 3: convertir diagramas de sincronización de código
El entorno de desarrollo Arduino protege al usuario de muchos de los detalles del código desordenado. Esto es bueno cuando están empezando y quieren a parpadear un LED. Sin embargo, cuando queremos interactuar con otros circuitos electrónicos, debemos interactuar más directamente con el microprocesador.

Primero vamos a discutir cómo leer eficientemente en los 16 pines en el bus de datos. Desde que estoy usando la Arduino Mega porque tiene un montón de alfileres de IO, puedo usar Puerto A y Puerto C que mi bus de datos de 16 bits. Puerto A y Puerto C son pernos 22 – 37 en el Arduino Mega. El bus de datos es bidireccional, lo que significa que a veces los pasadores se utilizan como salidas y otras veces como entradas por lo que necesitamos configurar rápidamente los modos de pin y lectura/escritura a los pines se. La lenta forma de usar estos pines sería la siguiente:
pinMode(22,INPUT);
pinMode(23,INPUT);
pinMode(24,INPUT);
…
pinMode(37,INPUT);
torcedura1 = digitalRead(22);
BIT2 = digitalRead(23);
bit3 = digitalRead(24);
…
Bit16 = digitalRead(37);

En este caso perderíamos datos sería leer que los datos más lentos que la información se recibe. Tenemos que acelerar esta interfaz directamente con el microprocesador de Arduino.

El microprocesador de Arduino es como el motor dentro de la Porsche. Veces más un conductor de un coche realmente sólo necesita comprender cómo hacer que el coche pare y vaya y no es necesario comprender el funcionamiento interno del motor del coche. Un piloto de carreras, sin embargo, debe comprender los límites y las capacidades del motor para empujar para ganar la carrera. Además tenemos que entender los detalles de la ATMEL AVR que es motor de Arduino para interactuar con otros circuitos electrónicos.

Para entender el microcontrolador Arduino podemos leer la hoja de datos AVR. El Arduino Mega utiliza el ATMEGA1280 que pueden encontrarse aquí: www.atmel.com/dyn/resources/prod_documents/doc2549.pdf

Sí, se trata de 444 páginas de información detallada que puede ser intimidante a primera vista. Usted encontrará en las páginas 100 y 101 que se pueden establecer todas las clavijas en el puerto A y Puerto C con una sola escritura a la dirección PORTA y PORTC dirección. También podemos leer de estos puertos, pero lo hacemos no por lectura de la PORTA y PORTC direcciones pero de direcciones de la PINA y PINC. Asimismo podemos establecer todas las clavijas de los modos de pin en el puerto a la vez escribiendo a DDRA y DDRC direcciones, un '1' pone el pin a '0' a la entrada y salida.

Ahora podemos establecer los pines en entradas y leer mucho más rápidamente utilizando estos comandos:
DDRA = 0 X 00;
DDR = 0 X 00;
Byte1 = PINA;
Byte2 = PINC;

Y escribir a los pines del puerto:
DDRA = 0XFF;
DDR = 0XFF;
PORTA = Byte1;
PORTC = Byte2;

Ahora que eficientemente podemos leer y escribir a los pines del bus, que tenemos que mirar cómo eficiente leer y escribir los otros pines normales. En mi proyecto de ejemplo usé pasadores Arduino 2 – 12 para controlar las señales de control de bus no 11 entre el DEI1016 y el Arduino. Si queremos escribir código eficiente para estos pasadores también (y nosotros) tenemos que evitar las rutinas digitalWrite y digitalRead que son lentas porque hacen cosas como comprobación para ver que los pines son los modos correctos, etc.. Para escribir rápidamente una vez más podemos escribir directamente a los pines de hardware evitando la sobrecarga de Arduino. El avrio.h de archivo incluyen incluye las funciones avrio_WritePin y avrio_ReadPin que escribe y Lee rápido. Tomé una pista de la librería glcd y definir mi propia rutina fastWrite que es #defined a avrio_WritePin para hacer el código más legible. Si lo desea puede revisar cómo la librería glcd soluciona su escribe rápido, aunque tendrás que recorrer las pocas capas de direccionamiento indirecto.

¿Una última parte de la dificultad que tenemos en la traducción de los diagramas de momento en código, sólo cómo retrasamos el número especificado de nanosegundos? ¿Cuál es un nanosegundo? Pregunta: ¿Cuánto tiempo ¿tomar para que se deslice en una cáscara y caer? Respuesta: Un bananosecond. Perdón por el mal juego de palabras. El Arduino tiene un delay(milliseconds) y delayMicroseconds() pero no tiene una función delayNanoseconds(). Al trabajar en un lenguaje de alto nivel como C, tenemos menos conocimiento de cuánto tiempo llevará un microcontrolador ejecute nuestros comandos. Esto es muy complicado como los procesadores llegan a ser más complejos y tienen tuberías de instrucción con L1 y L2 memoria caché, etc.. En nuestro caso de Arduino no es demasiado difícil como podemos utilizar la capacidad del lenguaje C para incluir código de ensamblado en línea. Mediante Asamblea podemos contar las instrucciones y saber cuántos reloj ciclos (normalmente 1/16000000 de segundo) una operación de toma. Usa 'inline', las instrucciones no Haz implementadas como subrutinas y por lo tanto no tarda más tiempo en proceso con el que salta a la subrutina y empujando y apareciendo datos de la pila. La desventaja de ensamblado en línea es que el código de objeto compilado obtiene más largo, pero es aceptable ya que no estamos haciendo un montón de estas demoras de nanosegundo.

Otra vez robo la solución dentro de la biblioteca del glcd. Allí incluye el archivo delay.h que contiene la función _delay_cycles. Entonces definir esta función como el DelayNanoseconds más fácil de leer como sigue:

Rutina de ciclo de demora de Hans Heinrichs:
#define DelayNanoseconds(__ns) _delay_cycles ((doble) (F_CPU) * (__ns (doble)) / 1.0e9 + 0.5)

Te darás cuenta que hay doble matemáticas de punto flotante en aquí que generalmente se evita porque es muy lento y queremos demoras muy pequeñas. Esta rutina utiliza el flotante punto rutinas matemáticas para ajustar automáticamente la frecuencia de reloj del microcontrolador para insertar la cantidad correcta de montaje código en línea con el código de C y la mejor parte es que el flotante punto cálculos se llevan a cabo cuando se compila y no se ejecutan por el Arduino en tiempo de ejecución. Este método puede resultar en una solo-instrucción 'NOP' se inserta como un retraso ocupado.