Source: https://arduwiki.perut.org/index.php/Programacion_avanzada
Timestamp: 2020-02-18 07:54:50+00:00

Document:
Programacion avanzada - ArduWiki
La mayoría de los puertos de los uC son multipropósito, es decir, en función de su configuración se comportan de una forma u otra. El ATmega 328p como cualquier otro uC tiene registros para cada puerto donde define si sera usado como entrada o salida. ATmega 328p tiene 3 bancos o grupos de puertos: B (D8~D13), C (A0~A5) y D (D0~D7), es decir a B y C le faltan puertos debido a que no se dispone de pines suficientes al ser ATmega 328p un DIP-28 (en comparación del tradicional DIP-40 de la mayoría de uC).
B - - D13 D12 D11 D10 D9 D8
C - - A5 A4 A3 A2 A1 A0
ATmega 328p tiene 3 registro de 8 bits con los que administra estos 3 bancos:
DDRx, determina si el banco x sera entrada (0) o salida (1).
PORTx, determina si el banco x estara en nivel HIGH o LOW. También define Pull-up si es fuera una entrada.
PINx, permite leer estado del banco x (solo lectura).
2 Digitales
2.1 Masivo
2.2 Puntual
3 Analogicos
3.1 ADC
Antes de meterme de lleno a explicarte los registros, quiero que primero veamos para que podría servir este esfuerzo.
Cada instrucción máquina necesita un ciclo de reloj a 16 MHz. Las funciones digitalRead() y digitalWrite() se componen cada una de ellas de varias instrucciones máquina, lo que puede influir negativamente en aplicaciones muy dependientes del tiempo. El Registro PORTx puede hacer el mismo trabajo en muchos menos ciclos de reloj.
Si necesitas cambiar de estado muchos pines en lugar de hacer un loop for que tomara mucho tiempo puedes echar mano directamente al registro y establecer varios pines de una sola vez.
Si estas al limite de memoria flash, puedes usar este truco para hacer que tu código use menos bytes de programación.
Es mucho mas fácil que cometas errores de difícil depuración. Por ejemplo con DDRD = 1, pone todos los pines del banco B (D0~D7) como salida, incluso el pin D0 (Rx) lo que causar que el puerto serial deje de funcionar.
Nota: En librerías es muy recomendable usar la manipulación directa de registros, así se hacen mucho mas rápidas.
Bien ahora que ya sabes para que nos meteremos en como manejar estos registros. En principio tenemos dos métodos: masivo es decir todos los puertos de un banco a la vez o puntual es decir un puerto de un banco en particular.
Ya sabemos que ATmega 326P maneja 3 bancos (B, C y D) y que cada uno agrupa a un numero de puertos. Por otro lado tenemos 3 registros (DDRx, PORTx y PINx) que podemos manejar.
DDRB = 255;         //D8~D13 como salidas.
DDRD = B11111111;   //D0~D7 como salidas.
DDRD = B00000000;   //D0~D7 como entradas.
DDRB = B00000111;   //D8~D10 como salida D11~D13 como entradas.
PORTD = B11111111;  //D0~D7 en HIGH.
PORTD = 0;          //D0~D7 en LOW.
PORTB = B00000101;  //D8+D10 en HIGH, D8, D11~D13 en LOW.
byte variable = PIND; //Guarda en una variable los estados de D0~D7 como un byte.
Se debe tener cuidado cuando se usa el PORTD y el puerto serie D0 (Rx) y D1 (Tx) son los usados por la UART y si se pone estos puertos como entradas o salidas, la UART será incapaz de leer o escribir datos en estos puertos. Este es un ejemplo de cuidado que se debe tener al usar esta programación en lugar de la capa de programación que nos ofrece Arduino.
Mediante los registros también podemos controlar las resistencias internas de pull-up que se usan básicamente para no dejar los pines al aire ya que esto genera ruido eléctrico. Se puede resolver este problema de dos maneras: poner una resistencia externa de 10K a Vcc (+5V) o usar los Pull-up internos del uC que producen el mismo efecto y hacen mas simple el circuitos.
Para habilitar las resistencias pull-up tenemos primero que configurar como entrada (0) el puerto mediante registro DDRx y luego escribir un 1 en el registro PORTx.
DDRD = 0;            //Configura todos los puertos del banco PORTD (D0~D7) como entradas.
PORTD = B00001111;   //Habilitar las Pull-ups de los puertos D0~D3.
Es casi tan fácil como usar las funciones digitalRead() y digitalWrite() de Arduino, pero con acceso directo al puerto se puede ahorrar espacio en la memoria flash porque cada operación de leer el estado de un solo puerto ocupa 40 bytes de instrucciones y también puede ganar mucha velocidad, porque las funciones Arduino puede tomar más de 40 ciclos de reloj para leer o escribir un solo bit en un puerto.
No es normal que se necesite definir, leer o escribir en un banco completo siempre, por ejemplo, si queremos encender un LED tendremos que actual sobre un solo puerto y no sobre todo el banco. Para eso podemos usar la macro Pxn donde x sera el puerto B, C o D y n sera el bit que estará entre 0~7 para definir el pin en particular. Ver exponencial de tabla arriba.
DDRD = 0<<PD2;  //Configura el bit 2 (pin D2) como enteada.
DDRB = 1<<PB2;  //Configura el bit 2 (pin D10) como salida.
DDRB = bit(5);  //Configura el bit 5 (pin D13) como salida.
PORTD = 1<<PD5; //Pone bit 5 (pin D5) en HIGH.
PORTB = 0<<PD2; //Pone bit 2 (pin D10) en LOW.
PORTB = PORTB | bit(2); //Pone bit 2 (pin D10) en HIGH.
PORTD = PORTD ^ 32; //Conmuta bit 5 (D5).
PORTB = 1<<PB5; //Le pone al bit 5 (pin D13) el PULL_UP.
byte variable = (PIND & (1<<PD1)); //Lee bit 1 (pin D1) y almacena su valor en la variable.
También podemos usar la macro Pxn varias veces en una misma instrucción, por ejemplo, en este código, se ejecutará algo de código sólo si los puertos D10 y D11 están en HIGH al mismo tiempo.
DDRB = B00001100; // Los pines D10 y D11 son salidas y el resto (D8+D9+D12+D13) entradas.
if (PINB & ((1<<PB2) | (1<<PB3))) {
//Algún código que se ejecutará solo si los dos pines de salida (D10+D11) se encuentran en HIGH.
La manipulación directa de los puertos puede ser acompañada de las máscaras de bits, los operadores lógicos (not, and, or y xor) y operaciones de desplazamiento a la derecha e izquierda.
El siguiente ejemplo lee alternativamente 100 veces el pin D9 con digitalRead() y mediante el registro PINB y calcula el tiempo en microsegundos de ambas operaciones. Te sorprenden los resultados ?
unsigned long t,t1;
for (byte n=0; n<100; n++){
y = digitalRead(9);
y = PINB & (1 << PB1);
t1 = micros() - t;
Serial.print("DigitalRead() = ");
Serial.print("PINx = ");
La forma de manejar con registros las entradas analógicas correspondientes al puerto C con POR y PIN es para usar esos pines como I/O digitales, puesto que los pines de los uC son multipropósito como se ha dicho anteriormente.
En las entradas analógicas entran en juego los conversores Analógico Digital (ADC) y en las salidas analógicas entra el PWM que usa uno de los temporizadores del uC para hacer la forma de onda PWM.
Un uC solo entiende señales digitales (0+1), por lo que para leer señales analógicas necesitamos un conversos análogo a digital (ADC). El ATmega 329P tiene incluido un conversor analógico a digital (ADC) de 6 canales (por multiplexion) y 10 bits (1024 pasos), por lo que devuelva enteros entre 0~1023.
Esto significa que a pesar de que ATmega 328P tiene disponibles 6 pines analogicos (A0~A5) solo puede leer un pin analogico a la vez (por la multilexion), de modo de si requiere lecturas de alta velocidad se podría necesitar el uso de ADC externos. El datasheet de ATmega advierte de hacer lecturas rápidas entre pines analógicos (mas de 200 KHz) puede causar ruido eléctrico, por lo que se recomienda incluir retardos de 1 milisegundo entre lecturas.
También es posible alterar la tensión máxima (siempre por debajo de Vcc) que usa el ADC. Es Aref, que es la tensión contra la que todas las entradas analógicas hacen las conversiones. Reducir Aref tiene sentido para mejorar la resolución del ADC. Con Aref = 5V la resolución es de 4,88 mV (5/1023) por paso. Si tienes un sensor de 3V3 mejor pon Vref = 3V3 y obtendrás una resolución de 3.22 mV (3.3/1023) por paso.
El ADC interno también se puede usar en un modo de 8 bits (), donde sólo se usan los 8 bits más significativos de la resolución de 10 bits completa, esto podría ser útil cuando se trabaja en ambientes ruidosos y se ahorra tiempo de uC. El ADC también puede configurarse para que lleve a cabo una conversión y detenerse o puede ser configurado para funcionar en un modo de funcionamiento libre, la primera opción es la mejor opción cuando queremos leer diferentes pines, y el segundo es mejor cuando sólo tenemos que leer un pin y esto puede ahorrar algo de tiempo entre las conversiones.
Las salidas Pulse Width Modulation (PWM) permiten simular salidas analógicas con ciertos pines digitales (D3, D5, D6, D9, D10, D11 para Arduino UNO). PWM es una técnica para modificar el ancho de pulsos (duty cycle) de una señal. Lo que modificamos no es la frecuencia que siempre sera 490 Hz (D3, D9, D10 y D11) o 980 Hz (D5 y D6), sino que cambiaremos la proporción de la parte positiva y negativa de cada periodo. Sus usos son:
Generar tensiones analógicas entre 0~100% de Vcc
Varias intensidad de un LED
En la familia de uC AVR, el PWM se controla por hardware y ATmega 328p cuenta con 3 timers. Timer 0 (D5 + D6) y timer 2 (D3 + D11) dan una resolución de 8 bit (256 pasos) mientras que el timer 1 (D9 + D10) ofrece una resolución de 16 bits (65536 pasos). Todo lo que necesita hacer es inicializar e iniciar el temporizador y establecer el ciclo de trabajo. Estos temporizadores generan interrupciones cuando alcanzan el overflow o cuando alcanzan el registro de comparación. Los registros de control del timer/counter n (donde n 0~2) son TCCRnA y TCCRnB y tienen los principales controles de los temporizadores.
digitalRead() sin PWM 58
digitalRead() con PWM 72
digitalWrite() sin PWM 63
digitalWrite() con PWM 77
analogRead() 1775
analogWrite() 129
PINx; Leer 8 pines 1
n = PINx; Leer y almacenar en variable RAM 8 pines 3
PORTx = B000010000; Escribir 8 pines 1
PORTx = n; Escribir 8 pines desde variable en RAM 3
Se requiere definir el pin como salida.
D0 PIND = bit(0); 1
D1 PIND = bit(1); 2
D2 PIND = bit(2); 4
D3 PIND = bit(3); 8
D4 PIND = bit(4); 16
D5 PIND = bit(5); 32
D6 PIND = bit(6); 64
D7 PIND = bit(7); 128
D8 PINB = bit(0); 1
D9 PINB = bit(1); 2
D10 PINB = bit(2); 4
D11 PINB = bit(3); 8
D12 PINB = bit(4); 16
D13 PINB = bit(5); 32
A0 PINC = bit(0); 1
A1 PINC = bit(1); 2
A2 PINC = bit(2); 4
A3 PINC = bit(3); 8
A4 PINC = bit(4); 16
A5 PINC = bit(5); 32
DDRB = bit(5);  //Define el bit 5 (pin digital 13) como salida.
PORTB = PORTB ^ bit(5);  //Invertido estado del bit 5 (pin digital 13), no altera el resto.
DDRB = B11111111;  //Lo mismo que DDRB = 255;
PORTB = 255;  //Prende todos los LED D8~D13
PORTB = 0;    //Apaga todos los LED D8~D13
Parpadea el LED a bordo.
DDRB = DDRB | 32;    //Configura el pin digital 13 como OUTPUT, no altera el resto. 32=B00100000;
PORTB = PORTB ^ 32;  //Invertido estado del bit 5 (pin digital 13), no altera el resto.
También se puede usar: PORTB = PORTB ^ bit(5):
Se pueden crear definiciones especiales como estas:
#define CLR(puerto,bit) (puerto&=(~(1<<bit)))     //CLR(PORTB, 0);
#define SET(puerto,bit) (puerto|=(1<<bit))        //SET(PORTB, 0);
#define _BV(bit) (1<<(bit))                       //PORTB |= _BV(0); o PORTB &= ~(_BV(0));
#define SBI(puerto,bit) (puerto)|=(1<<(bit))      //SBI(PINB, 0);
#define RVT(puerto,bit) (puerto=puerto^bit(bit))  //RVT(PORTD, 5);
PORT manipulation - Arduino
Entradas analogicas - Luis Llamas
El registro PORT - José Villalaz
Obtenido de «https://arduwiki.perut.org/index.php?title=Programacion_avanzada&oldid=4968»
Esta página fue modificada por última vez el 26 sep 2019 a las 11:09.

References: resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución