1

/*
PB5 PB4 PB3 PB2 PB1 PB0
13 12 11 10 9 8

PD7 PD6 PD5 PD4 PD3 PD2 PD1 PD0

7 6 5 4 3 2 1 0
*/

1.-

void setup() {
DDRB=DDRB | B00100000; // PB5(13) salida
}

void loop() {
PORTB=PORTB | B00100000;
delay(100);
PORTB=PORTB & B11011111;
delay(100);
}

2.-

void setup() {
DDRB=DDRB | B00100000;
}

void loop() {
PORTB=PORTB | B00100000;
delay(1000);
PORTB=PORTB & ~B00100000; // operador not bit a bit ~B00100000 = B11011111
delay(1000);
}

3.-

void setup() {
DDRB|=B00100000;
}

void loop() {
PORTB |= B00100000;
delay(1000);
PORTB &= ~B00100000;
delay(1000);
}
 2

4.-

void setup() {
DDRB |= B00100000;
}

void loop() {
PORTB ^= B00100000;
delay(1000);
}

5.-

void setup() {
DDRB |= B00100000; // PB5(13) salida
DDRD &= ~B11000000; // PD7(7) y PD6(6) entradas
}

void loop() {
if (!(PIND & B10000000)) // operador logico not, devuelve falso o verdadero
PORTB |= B00100000;
if (!(PIND & B01000000))
PORTB &= ~B00100000;
}

6.-

void setup() {
DDRB |= B00100000; // PB5(13) salida
DDRD &= ~B11000000; // PD7(7) y PD6(6) entradas
MCUCR &= ~B00010000; // Habilita pullups de entradas
PORTD |= B11000000; // Se escribe 1 en PD7(7) y PD6(6). Habilita pullups
}

void loop() {
if (!(PIND & B10000000)) // operador logico not, devuelve falso o verdadero
PORTB |= B00100000;
if (!(PIND & B01000000))
PORTB &= ~B00100000;
}
 3

7.-

void setup() {
bitSet(DDRB, DDB5);
}

void loop() {
bitSet(PORTB, PB5);
delay(100);
bitClear(PORTB, PB5);
delay(100);
}

8.-

void setup() {
bitSet(DDRB, PB5);
bitClear(DDRD, PD7);
bitClear(DDRD, PD6);
}

void loop() {
if (bitRead(PIND, PIND7) == LOW) //
bitSet(PORTB, PB5);
if (bitRead(PIND, PIND6) == LOW) //
bitClear(PORTB, PB5);
}

9.-

void setup() {
bitSet(DDRB, PB5);
bitClear(DDRD, PD7);
bitClear(DDRD, PD6);
}

void loop() {
if (bitRead(PIND, PIND7) == HIGH) // Si pulsador 7 esta a nivel uno
bitSet(PORTB, PB5);
if (bitRead(PIND, PIND6) == HIGH) // Si pulsador 6 esta a nivel uno
bitClear(PORTB, PB5);
}

10.-

void setup() {
bitSet(DDRB, PB5);
bitClear(DDRD, PD7);
 4

bitClear(DDRD, PD6);
bitClear(MCUCR, PUD); // Habilita pullups de entradas
bitSet(PORTD, PD7);
bitSet(PORTD, PD6);
}

11.-

void setup() {
bitWrite(DDRB, PB5,1);
bitWrite(DDRD, PD7,0);
bitWrite(DDRD, PD6,0);
bitWrite(MCUCR, PUD,false); // Habilita pullups de entradas
bitWrite(PORTD, PD7,1);
bitWrite(PORTD, PD6,true);
}

void loop() {
if (bitRead(PIND, PIND7) == LOW) //
bitWrite(PORTB, PB5,HIGH);
if (bitRead(PIND, PIND6) == LOW) //
bitWrite(PORTB, PB5,LOW);
}

12.-

void setup() {
bitWrite(DDRB, PB5,1);
bitWrite(DDRD, PD7,0);
bitWrite(DDRD, PD6,0);
bitWrite(MCUCR, PUD,false); // Habilita pullups de entradas
bitWrite(PORTD, PD7,1);
bitWrite(PORTD, PD6,true);
}

void loop() {
if ((PIND & bit(7)) == LOW) //
bitWrite(PORTB, PB5,HIGH);
if ((PIND & bit(6)) == LOW) //
bitWrite(PORTB, PB5,LOW);
}
 5

PROGRAMACIN MEDIANTE REGISTROS

Pin PORTB1 y PORTB0 configurados como salidas. Se setean DDB0 y DDB1.

DDRB = B00000011; // !NO USAR!
DDRB = DDRB | B00000011;
DDRB |= B00000011;
Como DDB0 = 0, DDB1 = 1, DDB2 = 2, etc.
DDRB = DDRB | ((1<<DDB0) | (1<<DDB1));

DDRB |= (1<<DDB0) | (1<<DDB1);

SET
PORTB1 y PORTB0 se setean.
PORTB = B00000011; // !NO USAR!
PORTB = PORTB | B00000011;
PORTB |= B00000011;
Como PORTB0 = 0, PORTB1 = 1, PORTB2 = 2, etc.
PORTB = PORTB | ((1<<PORTB0) | (1<<PORTB1));

PORTB |= (1<<PORTB0) | (1<<PORTB1);

SET
PORTB1 y PORTB0 se limpian
PORTB = B00000000; // !NO USAR!
PORTB = PORTB & ~B00000011;
PORTB &= ~B00000011;
Como PORTB0 = 0, PORTB1 = 1, PORTB2 = 2, etc.
PORTB = PORTB & ~ ((1<<PORTB0) | (1<<PORTB1));

PORTB &= ~ ((1<<PORTB0) | (1<<PORTB1));

CLEAR
PORTB1 y PORTB0 se conmutan
PORTB = PORTB ^ B00000011;
PORTB ^= B00000011;
Como PORTB0 = 0, PORTB1 = 1, PORTB2 = 2, etc.
PORTB = PORTB ^ ((1<<PORTB0) | (1<<PORTB1));

PORTB ^= (1<<PORTB0) | (1<<PORTB1);

TOGGLE

Verdad si PINB0 est en alto:

if (PINB & (1<<PINB0))

{

}
 6

Verdad si PINB0 est en bajo:

if ((PINB & (1<<PINB0)))

{

Ejemplo de interrupcin externa por el pin INT0, usando registros:

void setup()
{
// MCUCR &= ~(1<<PUD); // Se habilita PULLUP Global
DDRD &= ~ (1<<DDD2); // PORTD2 entrada: DDD2=0
// PORTD |= (1<<PORTD2); // Se habilita PULLUP de PORTD2. (Se escribe 1 en PORTD2)
DDRB |= (1<<DDB0) | (1<<DDB1); // PORTB0 y PORTB1 salidas: DDB0=1 y DDB1=1
SREG |= (1<<7); // Habilitador Global de Int. (I=1). Tb. sei();
EIMSK |= (1<<INT0); // Habilitador de Int. externa 0: INT0=1
// EICRA |= (1<<ISC01) | (1<<ISC00); // Evento en flaco de subida: RISING
EICRA |= 1<<ISC01; // Evento en flaco de bajada: FALLING
EICRA &= ~ (1<<ISC00); // Evento en flaco de bajada: FALLING
}

void loop(void)
{
PORTB ^= (1<<PORTB0);
delay(1000);
}

ISR(INT0_vect)
{
PORTB ^= (1<<PORTB1);
}
 7

Sin las lneas comentadas:

void setup()
{
DDRD &= ~ (1<<DDD2); // PORTD2 entrada: DDD2=0
DDRB |= (1<<DDB0) | (1<<DDB1); // PORTB0 y PORTB1 salidas: DDB0=1 y DDB1=1
SREG |= (1<<7); // Habilitador Global de Int. (I=1). Tb. sei();
EIMSK |= (1<<INT0); // Habilitador de Int. externa 0: INT0=1
EICRA |= 1<<ISC01; // Evento en flaco de bajada: FALLING
EICRA &= ~ (1<<ISC00); // Evento en flaco de bajada: FALLING
}

void loop(void)
{
PORTB ^= (1<<PORTB0);
delay(1000);
}

ISR(INT0_vect)
{
PORTB ^= (1<<PORTB1);
}
 8

int sw = 2; // interrupcin externa 0

int led_loop = 8;
int led_isr = 9;

void setup()
{
pinMode(sw2,INPUT);
pinMode(led_loop,OUTPUT);
pinMode(led_isr,OUTPUT);
attachInterrupt(0,isr,RISING); // (Nro. de interrupcin, funcin isr, modo)
}

void loop(void)
{
digitalWrite(led_loop,!digitalRead(led_loop));
delay(1000);
}

void isr()
{
digitalWrite(led_isr,!digitalRead(led_isr));
}
 9

Hacemos una comparacin entre los bytes de memoria de programa usados con ambos mtodos:

1596 = ( 2,08) 766

El mismo programa, pero la conmutacin se realiza escribiendo en PINB:

El registro PINB sirve para leer el estado de un pin (ya sea que est
configurado como entrada o como salida). Cuando se escribe un 1 se conmuta
el pin correspondiente.

void setup()
{
DDRD &= ~ (1<<DDD2); // PORTD2 entrada: DDD2=0
DDRB |= (1<<DDB0) | (1<<DDB1); // PORTB0 y PORTB1 salidas: DDB0=1 y DDB1=1
SREG |= (1<<7); // Habilitador Global de Int. (I=1). Tb. sei();
EIMSK |= (1<<INT0); // Habilitador de Int. externa 0: INT0=1
EICRA |= 1<<ISC01;
EICRA &= ~ (1<<ISC00);
}

void loop(void)
{
PINB |= (1<<PINB0); // Conmuta PORTB0!
delay(1000);
}

ISR(INT0_vect)
{
PINB |= (1<<PINB1); // Conmuta PORTB1!
}

Conmutador con librera BOUNCE y registros:

 10

#include <Bounce.h>
#define led 8 // PORTB0
#define pulsador 2 // PORTD2
Bounce rebote_pulsador = Bounce(pulsador,20); // // tiempo de 20 ms

void setup()
{
DDRB |= (1<<DDB0); // PORTB0 salida: DDB0=1
DDRD &= ~ (1<<DDD2); // PORTD2 entrada: DDD2=0
MCUCR &= ~(1<<PUD); // Se habilita PULLUP Global
PORTD |= (1<<PORTD2); // Se habilita PULLUP de PORTD2. (Se escribe 1 en PORTD2)
PORTB &= ~(1<<PORTB0); // Valor inicial de PORTB0=1
}

void loop()
{
if (rebote_pulsador.update() )
{
if (rebote_pulsador.read() == LOW)
{
PORTB ^= (1<<PORTB0);
}
}
}

Conmutador con librera BOUNCE y consulta de estado de la entrada con registro

PINX:

#include <Bounce.h>
#define led 8 // PORTB0
#define pulsador 2 // PORTD2
Bounce rebote_pulsador = Bounce(pulsador,20); // // tiempo de 20 ms

void setup()
{
DDRB |= (1<<DDB0); // PORTB0 salida: DDB0=1
DDRD &= ~ (1<<DDD2); // PORTD2 entrada: DDD2=0
MCUCR &= ~(1<<PUD); // Se habilita PULLUP Global
PORTD |= (1<<PORTD2); // Se habilita PULLUP de PORTD2. (Se escribe 1 en PORTD2)
PORTB &= ~(1<<PORTB0); // Valor inicial de PORTB0=1
}

void loop()
{
if (rebote_pulsador.update() )
{
if (rebote_pulsador.read() == LOW)
{
PINB |= (1<<PINB0); // Tambin: PORTB ^= (1<<PORTB0);
}
}
}
 11

Una variante del ejercicio anterior:

#include <Bounce.h>
#define led 8 // PORTB0
#define pulsador 2 // PORTD2
Bounce rebote_pulsador = Bounce(pulsador,20); // // tiempo de 20 ms

void setup()
{
{
DDRB |= (1<<DDB0); // PORTB0 salida: DDB0=1
DDRD &= ~ (1<<DDD2); // PORTD2 entrada: DDD2=0
MCUCR &= ~(1<<PUD); // Se habilita PULLUP Global
PORTD |= (1<<PORTD2); // Se habilita PULLUP de PORTD2. (Se escribe 1 en PORTD2)
PORTB &= ~(1<<PORTB0); // Valor inicial de PORTB0=1
}}

void loop()
{
if (rebote_pulsador.update())
{
if (rebote_pulsador.read() == LOW)
{
if (PINB & (1<<PINB0)) // Si PORTB0=1
PORTB &= ~(1<<PORTB0); // PORTB0=0
if (!(PINB & (1<<PINB0)))// Si PORTB0=0
PORTB |= (1<<PORTB0); // PORTB0=1
}
}
}