Entradas Salidas Digitales

Entradas salidas digitales
con el AVR, los pines del microcontrolador AVR pueden tener múltiples funciones,
eso dependerá del microcontrolador AVR que se utilice, en esta ocación se verá el
uso de estos pines como entradas digitales o como salidas digitales, en los ejemplos
que se hagan en esta página y en los vídeos publicados en el canal de youtube
de MrElberni, se utilizarán diversos AVR, se recomienda siempre tener a mano la
hoja de datos del microcontrolador AVR que se utilice.
En esta ocasión se comentará el uso de los pines de los microcontroladores como
entradas salidas digitales con el AVR, los pines normalmente vienen agrupados en
grupos de 8 pines, a cada uno de estos grupos se les llama puertos, algunos puertos
pueden tener menos de 8 pines, por ejemplo para el ATmega88 se tiene que el
puerto B tiene 8 pines, mientras que el puerto C solo tiene 7 pines, la cantidad de
puertos puede variar de un modelo de microcontrolador AVR a otro.
Cada uno de los pines del avr a ser utilizados como entradas salidas digitales tienen
un nombre propio relacionado con el puerto al que pertenecen y al número de orden
del bit con el cual se programará, por ejemplo para el puerto D se tienen los pines
PD0, PD1, PD2, PD3, PD4, PD5, PD6, PD7.
Para la manipulación de los pines como entradas salidas digitales con el AVR,
el microcontrolador AVR cuenta con tres registros de 8 bits cada uno, estos registros
son el DDRx, PORTx, PINx, las x depende del puerto a utilizar, en adelante se
tomará como ejemplo el microcontrolador ATmega88, pero lo que aquí se comente
en cuanto al uso de los pines como entradas salidas digitales con el AVR es muy
similar para los demás microcontroladores AVR, la hoja de datos de este
microcontrolador se puede ver y descargar desde aquí, la programación de los pines
como entradas salidas digitales PIC se hará en C/C++ con el Atmel Studio.
El siguiente es un vídeo publicado en el canal de youtube de MrElberni, en el se
comenta sobre los registros a utilizar para programar los pines como entradas
salidas digitales con el AVR, en este caso se comenta para el Atmega88,
la información utilizada se obtiene de la hoja de datos del microcontrolador.
A continuación se ve la forma en que se configuran los bits de los registros DDRx,
PORTx, PINx, las x depende del puerto a utilizar, en el Atmel Studio para hacer
trabajar los pines como entradas salidas digitales con el AVR, los demás tipos de
registros con los que cuenta el microcontrolador AVR se configuran de la misma
forma, con la única diferencia que cambiarán los nombres tanto de los registros
como de sus correspondientes bits.
Entradas salidas digitales con el

AVR Registro DDRx
Mediante el registro DDRx se eligen si los pines a utilizar del microcontrolador
AVR serán salidas digitales o entradas digitales, la x representa el puerto al cual
pertenezcan los pines a utilizar como entradas o salidas digitales, por ejemplo si es
un pin del puerto B, entonces x será B, si es un pin de un puerto D de algún
http://microcontroladores-mrelberni.com/entradas-salidas-digitales-con-el-avr/
microcontrolador AVR, entonces x será D; para los microcontroladores AVR de 8
bits, el registro DDRx está conformado de 8 bits, cada uno de esos bits controlará
a un pin del puerto al que pertenezca el registro DDRx para que el pin se comporte
como una entrada digital o como una salida digital.
Para elegir que el pin se comporte como salida digital, se

pondrá su bit correspondiente en el registro DDRx del puerto
utilizado como 1.
.
Para elegir que el pin se comporte como entrada digital, se

pondrá su bit correspondiente en el registro DDRx del puerto
utilizado como 0.
La siguiente es la imagen del registro DDRB del microcontrolador ATmega88
Por ejemplo si el bit7 o bit DDB7 se le pone a 1, el pin PB7 será una salida digital;
si el bit3 o bit DDB3 se pone a 0, el pin PB3 será una entrada digital, como se puede
observar los bits se cuentan de 0 a 7 de derecha a izquierda, esto será siempre así
para cualquier otro registro.
Este registro se puede programar para que todos los pines del puerto B sean salidas
digitales o todos los pines sean entradas digitales o una mezcla de ambos, en C/C++
la programación del registro DDRB se puede hacer en binario, en decimal o
hexadecimal, la forma de proceder dependerá del programa compilador que se esté
utilizando.
En el caso de utilizar el compilador ATMEL STUDIO, la forma de configurar todos
los pines del puerto B, para usarlos como entradas salidas digitales PIC se hace
como se muestra a continuación:
1 /////////////////////////////////////////////
2
3
/// Entradas salidas digitales con el AVR ///
4 /////////////////////////////////////////////
5
6 //todos los pines de puerto b como entradas digitales
7 DDRB=0b00000000;//en binario
8
9 DDRB=0; //en decimal
10 DDRB=0x00; //en hexadecimal
11
12 //todos los pines del puerto b como salidas digitales
13
14
DDRB=0b11111111;//en binario
15 DDRB=255; //en decimal
16 DDRB=0xff; //en hexadecimal
17
18 //algunos pines como entradas y otros como salidas digitales
19
20 //PB7, PB5, PB3 y PB1 como entradas digitales
//PB6, PB4, PB2 y PB0 como salidas digitales
DDRB=0b01010101;//en binario
DDRB=85; //en decimal
DDRB=0x55; //en hexadecimal
La forma binaria tiene la ventaja de que deja ver con que valores 0 o 1 se están
programando los bits del registro utilizado, el valor asignado al registro está
comprendido entre 0 y 255 porque el registro es de 8 bits.
“Se ha comentado la forma de proceder para el caso del registro

DDRB, pero en el ATMEL STUDIO se procede de la misma forma
para cualquier otro registro del microcontrolador AVR que se quiera
utilizar, que como se verá son muchos registros.”
Muchas veces será necesario programar los bits de los registros bit por bit, no
todos de una vez como se ha visto, esto en el lenguaje C/C++ se hace mediante
operaciones con bits, y como se programará en C/C++ con el ATMEL STUDIO, las
operaciones de bits se puede utilizar, es muy importante dominar las operaciones de
bits ya que facilita bastante la programación de los microcontroladores; lo que se
comente en adelante para la manipulación de los bits registro DDRB será aplicable
a cualquier otro registro del microcontrolador AVR.
Por ejemplo si se quiere utilizar solo el pin PB0 como salida digital, entonces
el bit0 del registro DDRB se tiene que poner a 1, para lograr esto se procede así:
DDRB |= (1<<0);//aquí se esta diciendo que el bit0 del registro DDRB se ponga
a1
donde | es el operador de bits OR, y (1<<0) es un número binario de 8 bits donde
el bit0 se ha puesto a 1, lo anterior es lo mismo que hacer lo siguiente
DDRB=DDRB|(0b00000001);
Se realiza la operación OR entre el número binario y registro DDRB, con lo que se
logra que el bit0 del registro DDRB se ponga a 1 si antes estaba a 0 y si ya estaba
a 1 se mantendrá a 1, los demás bits del registro DDRB mantendrán sus valores en
la operación OR, ya que los otros bits del número binario están a 0, por último el
resultado de la operación se le asigna al registro DDRB, mediante esta operación se
logra que el bit0 del registro DDRB se ponga a 1 y así establecer que el pin PB0 será
utilizado como una salida digital.
Por ejemplo si se necesita que el pin PB5 sea una salida digital, se puede proceder
así
DDRB |=(1<<5);//viene del lenguaje C
En el ATMEL STUDIO también se puede hacer así:
DDRB |=(1<<DDB5);//DDB5 es el nombre del bit5 del registro DDRB

DDRB=DDRB|(0b00100000);//forma completa de la anterior
Si se quiere por ejemplo que los pines PB1, PB4 y PB7 sean salidas digitales, esto
en una sola linea utilizando el operador de bits OR | sería así:
DDRB |=((1<<1) | (1<<4) | (1<<7));
También puede ser así:
DDRB |= ((1<<DDB1)|(1<<DDB4)|(1<<DDB7));//con los nombres de los bits
Por ejemplo si se quiere utilizar solo el pin PB0 como entrada digital,
entonces el bit0 del registro DDRB se tiene que poner a 0, para lograr esto se
procede así:
DDRB &=~ (1<<0);//aquí se esta diciendo que el bit0 del registro DDRB se ponga
a0
donde & es el operador de bits AND, ~ es la negación y (1<<0) es un número
binario de 8 bits donde el bit0 se ha puesto a 1, lo anterior es lo mismo que hacer lo
siguiente
DDRB=DDRB&~(0b00000001);
Se niega el número binario con lo que el bit0 se pone a 0 y todos sus demás bits se
ponen a 1, luego se realiza la operación AND con el registro DDRB, con lo que se
logra que el bit0 del registro DDRB mediante la operación AND se ponga a 0, los
demás bits del registro DDRB mantendrán sus valores en la operación AND, ya que
los otros bits del número binario se pusieron a 1 en la negación, por último
el resultado de la operación se le asigna al registro DDRB, mediante esta
operación se logra que el bit0 del registro DDRB se ponga a 0 y así establecer que
el pin PB0 será utilizado como una salida digital.
Por ejemplo si se necesita que el pin PB5 sea una entrada digital, se puede proceder
así
DDRB &= ~(1<<5);//viene del lenguaje C
En el ATMEL STUDIO también se puede hacer así:
DDRB &=~(1<<DDB5);//DDB5 es el nombre del bit5 del registro DDRB

DDRB=DDRB&~(0b00100000);//forma completa de la anterior
Si se quiere por ejemplo que los pines PB1, PB4 y PB7 sean entradas digitales, esto
en una sola linea utilizando el operador de bits OR | sería así:
DDRB &=~ ((1<<1) | (1<<4) | (1<<7));
También puede ser así:
DDRB &=~((1<<DDB1)|(1<<DDB4)|(1<<DDB7));//se usa los nombres de los bits
Entradas salidas digitales con el AVR
Registro PORTx
Cuando algún pin o los pines de AVR se han configurado como salidas
digitales, mediante el registro PORTx se indica si la salida será un alto o un bajo
que es lo mismo que un 1 o un 0.
Por ejemplo con la siguiente linea de código se pondría todos los pines del puerto B
como altos si previamente mediante DDRB se han configurado como salidas
digitales:
PORTB=0b11111111; //en binario, también se puede hacer en decimal o
hexadecimal.
mediante la siguiente linea
PORB=0b01010101; //por los pines impares se obtendrán ceros, mientras que
por los pares unos.
si se quiere que solo por el pin PB3 salga un 1 será así
PORTB |= (1<<3);//el pin PB3 se pone a 1
en atmel studio también puede ser así
PORTB |= (1<<PB3);//se usa el nombre del bit3 del registro PORTB
si se quiere que solo por el pin PB3 salga un 0 será así
PORTB &=~ (1<<3);//el pin PB3 se pone a 0
en atmel studio también puede ser así
PORTB &=~ (1<<PB3);//se usa el nombre del bit3 del registro PORTB
si se quiere que por los pines PB5 y PB2 salgan unos sería así:
PORTB |= ((1<<2)|(1<<5));//los pines PB2 y PB5 se ponen a 1
También se puede hacer así

PORTB |= ((1<<PB2)|(1<<PB5)); con los nombres de los bits
Cuando algún pin o los pines de AVR se han configurado como entradas
digitales, mediante el registro PORTx se activa o desactiva unas resistencias Pull
Up internas al microcontrolador AVR, cuando el bit del registro PORTx
correspondiente a algún pin que es utilizado como entrada digital, se pone a 1 se
activará la resistencia pull up correspondiente al pin, cuando se configura como 0 la
resistencia pull up de ese pin estará desactivada.
Por ejemplo con la siguiente linea de código se activarán todas las resistencias pull
up del puerto B, si previamente mediante DDRB se le ha configurado todo el puerto
B como entradas digitales:
PORTB=0b11111111; //en binario, también se puede hacer en decimal o
hexadecimal.
mediante la siguiente linea
PORTB=0b01010101;
los pines impares tendrán desactivadas sus resistencias pull up, mientras que por
los pares las tendrán activadas.
si se quiere que solo la resistencia pull up del pin PB3 esté activa será así
PORTB |= (1<<3); //activa la resistencia pull up del pin PB3

En atmel studio también puede ser así PORTB |= (1<<PB3).
si se quiere que las resistencias pull up de los pines PB5 y PB2 estén activadas sería
así:
PORTB |= ((1<<2)|(1<<5));
También puede ser así
PORTB |= ((1<<PB2)|(1<<PB5));//usa los nombres de los bits
Entradas salidas digitales con el AVR

Registro PINx
Cuando los pines han sido configurados para trabajar como entradas salidas digitales
con el AVR, mediante este registro se puede obtener el estado o los valores de los
pines del puerto correspondiente, independientemente si están configurados como
entradas digitales o como salidas digitales, hay una forma de hacer esto que se verá
mas adelante, de momento por ejemplo si se quiere saber los valores de los pines
del puerto D y esto hay que guardarlo en alguna variable sería algo así.
int8_t dato;
dato=PIND;
Entradas salidas digitales con

el AVR Ejemplos
Para empezar se ha pensado conveniente realizar los ejemplos en vídeo, en ellos se
verá la programación de los registros DDRx, PORTx y PINx, para la utilización de los
pines como entradas salidas digitales con el AVR, se verá como crear los proyectos
en el ATMEL STUDIO, desarrollar el programa y como programar el microcontrolador
AVR con el programador AVRISP mkii.
Se anima a que visualicen los siguientes vídeos ya que serán básicos para los
próximos temas que se traten sobre los microcontroladores AVR.
Ejemplo 1
En el siguiente vídeo publicado en el canal de youtube de MrElberni, se hace un
primer ejemplo de programación del AVR en el atmel studio, para utilizar uno de los
pines del microcontrolador AVR, en este caso el ATmega88, como una salida digital,
en el cual se conectará un led que se hará parpadear, se ve la forma de crear un
proyecto en el ATMEL STUDIO, realizar el programa compilarlo y la forma de utilizar
el programador AVRISP mkii para cargar el programa realizado en el ATmega88.
El siguiente es el código utilizado en este primer ejemplo:
///////////////////////////////////////////////////////
///////*****************************************///////
/////////***microcontroladores-mrelberni.com***////////
1
2
///////*****************************************///////
3 //* Entradas salidas digitales con el AVR ejemplo 1 *//
4 ///////*****************************************///////
5
6 #define F_CPU 1000000ul //frecuencia de trabajo del ATmega88 1Mhz, se define para que
7
8 //el programa pueda hacer los cálculos de los tiempos
9 #include <avr/io.h> //archivo de cabecera para los nombres de los bits, los pines, los
10 registros, etc
11
12
#include <util/delay.h> //archivo de cabecera para los tiempos
13
14 int main(void)
15 {
16
DDRB|=(1<<DDB0);//el pin PB0 como salida digital
17
18 PORTB&=~(1<<PB0);//el pin PB0 se inicia en bajo, led apagado
19
20 while(1)//ciclo del programa
21 {
22
23 PORTB^=(1<<PB0);//PB0 cambia de estado, el led parpadea
_delay_ms(200);//tiempo de espera antes que el ciclo se repita
}
}
Ejemplo 2
La intención del siguiente vídeo es ver como se pueden programar algunos bits a la
vez de un mismo puerto, no todos los bits del puerto, para ello se simulará un
semáforo con leds los que estarán conectados a tres pines diferentes del puerto C
del ATmega88, estos pines se configuran como salidas digitales; en si lo que se
quiere es que se vea como programar grupos de bits de algún registro cualquiera
como salidas digitales.
El siguiente es el código utilizado en este segundo ejemplo:
///////////////////////////////////////////////////////
///////*****************************************///////
///////*****************************************///////
2
3 ///////*****************************************///////
4
7
9 registros, etc
10 #include <util/delay.h> //archivo de cabecera para los tiempos
11
12
13
int main(void)
14 {
15 uint16_t tiempo=2000;//variable de 16 bits para el control de tiempos
16 DDRC|=((1<<DDC0)|(1<<3)|(1<<5));//PC0, PC3 y PC5 como salidas digitales
17
18 PORTC&=~((1<<DDC0)|(1<<3)|(1<<5));//En un inicio las salidas a 0
19
21 {
22
23 PORTC|=(1<<PC0);//enciende el led verde
24 _delay_ms(tiempo);//pausa de 2 segundos
25 PORTC|=(1<<3);//enciende el led amarillo
26
27
_delay_ms(tiempo);//pausa de 2 segundo
28 PORTC&=~((1<<0)|(1<<3));//apaga led verde y amarillo
29 PORTC|=(1<<5);//enciende led rojo
30 _delay_ms(tiempo);//pausa de 2 segundos
31
32 PORTC|(1<<3);//enciende led amarillo
_delay_ms(tiempo);//pausa de 2 segundos
PORTC&=~((1<<5)|(1<<3));//apaga led rojo y amarillo
}
}
Ejemplo 3
En el siguiente vídeo se comenta sobre el uso del pin RESET del AVR, así como
también se puede ver como programar todos los bits de un registro, en este caso se
programan todos los bits de los registros DDRB y del registro PORTB del puerto B,
para poder utilizar todos sus pines como salidas digitales.
El siguiente es el código utilizado en este tercer ejemplo:
///////////////////////////////////////////////////////
///////*****************************************///////
1
2
///////*****************************************///////
4 ///////*****************************************///////
5
7
10 registros, etc
11
12
#include <util/delay.h> //archivo de cabecera para los tiempos
13
14 int main(void)
15 {
16
DDRB=255;//todos los pines del puerto b como salidas digitales
17
18 PORTB=0b10101010;//las salidas pares a 1 y las impares a 0
19
21 {
22
23 PORTB=~PORTB//cambia los estados de los pines del puerto B
_delay_ms(200);//pausa de 200ms
}
}
Ejemplo 4
En el siguiente vídeo se muestra un circuito en que se han programado 2 pines del
AVR como entradas digitales, mediante los cuales se controlará el estado de otro
pin que se ha programado como salida digital, sobre el código del programa se
comenta en el siguiente vídeo.
En el siguiente vídeo se comenta la forma de programar los pines del AVR como
entradas digitales y sobre el uso de las resistencias pull up internas al AVR cuando
los pines se utilizan como entradas digitales.
El siguiente es el código utilizado en este cuarto ejemplo:
///////////////////////////////////////////////////////
///////*****************************************///////
///////*****************************************///////
1
2
//* Entradas salidas digitales con el AVR ejemplo 4 *//
3 ///////*****************************************///////
4
7
9 registros, etc
11
12
13 int main(void)
14 {
15 DDRB|=(1<<DDB1);//pin PB1 como salida digital para el led
16
17
PORTB&=~(1<<PB1);//el estado incial del pin PB1 es bajo
18
19 DDRD&=~((1<<5)|(1<<DDD7));//Pines PD5 y PD7 como entradas digitales
20 PORTD|=((1<<5)|(1<<PD7));//resistencias pull up internas de los pines PD5 y PD7
21 activadas
22
23
25 {
26 if((PIND&(1<<PD7))==0)//si se presiona en PD7
27
28 PORTB&=~(1<<PB1);//el led se apaga
29
if((PIND&(1<<PD5))==0)//si se presiona en PD5
PORTB|=(1<<1);//el led se enciende
}
}
Ejemplo 5
En el siguiente vídeo se hace la programación de los pines del puerto D del
microcontrolador AVR atmega88 como salidas digitales, para realizar diferentes
juegos de luces utilizando leds.
El siguiente es uno de los códigos utilizados en este quinto ejemplo:
///////////////////////////////////////////////////////
///////*****************************************///////
///////*****************************************///////
2
///////*****************************************///////
3
4
8
9 registros, etc
11
12 int main(void)
13
14
{
15 uint8_t tiempo=200;//variable de 8 bits sin signo para controlar los tiempos
16 DDRD=0xff;//todos los pines del puerto D como salidas digitales
17 PORTD=0;//los estados de los pines del puerto D a 0, leds apagados
18
19
21 {
22 PORTD=0b10000001;
23
24 _delay_ms(tiempo);
25 PORTD=0b01000010;
27
28
PORTD=0b00100100;
30 PORTD=0b00011000;
32
33 PORTD=0b00100100;
PORTD=0b01000010;
_delay_ms(tiempo);
}
}
Ejemplo 6
En el siguiente vídeo se hace la programación de los pines del puerto D del
microcontrolador AVR atmega88 como salidas digitales, en este caso se realiza un
juego de luces utilizando la instrucción for del lenguaje C.
El siguiente es el código utilizado en este sexto ejemplo:
///////////////////////////////////////////////////////
///////*****************************************///////
///////*****************************************///////
1
//* Entradas salidas digitales con el AVR ejemplo 6 *//
2
3 ///////*****************************************///////
4
7
9 registros, etc
11
12
13
int main(void)
14 {
15 uint8_t tiempo=100;//variable de 8 bits sin signo para controlar los tiempos
17
18 PORTD|=(1<<PD0);//Puerto D PORTD=00000001
19
21 {
22
23 for(int i=0;i<7;i++){
25 PORTD=PORTD<<1;//corrimiento de bits a la izquierda
26
27
}//fin for
28 //PORTD=10000000
29 for(int i=0;i<7;i++){
31
32 PORTD=PORTD>>1;//corrimiento de bits a la iderecha
}//fin for
//PORTD=00000001
}
}
Ejemplo 7
Se realiza un contador binario de 8 bits por medio de una variable interna al
microcontrolador AVR, los valores de la variable se pueden ver por medio de unos
leds conectados al puerto D del ATmega88, cuyos pines son programados como
salidas digitales.
El siguiente es el código utilizado en este séptimo ejemplo:
///////////////////////////////////////////////////////
///////*****************************************///////
///////*****************************************///////
2 ///////*****************************************///////
3
4
5
#define F_CPU 1000000ul //frecuencia de trabajo del ATmega88 1Mhz, se define para que
8 registros, etc
9
11
12 int main(void)
13 {
14
15
uint8_t contador=0;//se crea la variable contador de 8 bits sin signo
16 uint16_t tiempo=500;//para controlar los tiempos del aumento del contador
18
PORTD=0;//Puerto D a 0, aquí se conectan los led para ver los valores de la
19
20 //variable contador en binario
21
23 {
24
25 PORTD=contador;//al puerto D se le asignan los valores de la variable
26 contador
27 _delay_ms(tiempo);//pausa de medio segundo
contador++;//en cada ciclo del programa la variable contador aumenta
una unidad
}
}
Ejemplo 8
En este caso por medio de un pulsador conectado al pin PB0 utilizado como una
entrada digital del ATmega88 se incrementará los valores del puerto D, estos valores
serán vistos en forma binaria en unos leds conectados al puerto D, por lo que todos
sus pines son utilizados como salidas digitales.
El siguiente es el código utilizado en este octavo ejemplo:
///////////////////////////////////////////////////////
///////*****************************************///////
1 ///////*****************************************///////
3 ///////*****************************************///////
4
5
9
10
registros, etc
12
13 int main(void)
14 {
15
17 PORTD=0;//Puerto D a 0, aquí se conectan los led para ver los valores de la
18 //variable contador en binario
19
20 DDRB&=~(1<DDB0);//pin PB0 como entrada digital, para el pulsador
21 PORTB|=(1<<0);//resistencia pull up interna del pin PB0 activad
22
24
25
{
26 if((PINB&(1<<PB0))==0){//si el pulsador en PB0 se pulsa
27 PORTD++;//la salida en el puerto D aumenta una unidad
28 _delay_ms(200);//pausa de 200ms
}
}
}
Ejemplo 9
En este caso se ve la utilización de un display de 7 segmentos para ver valores
numéricos del 0 al 9 en forma decimal a partir de los valores binarios que se obtienen
con microcontrolador AVR atmega88 en su puerto C, es necesario tener un
conocimiento previo sobre el display y sobre el decodificador de 7 segmentos, sobre
estos temas se han publicado un par de vídeos en el canal de youtube de MrElberni,
puedes seguir los siguientes enlacesEntradas salidas digitales Proyecto 9: Display
de 7 segmentos.
 Display o visualizador de 7 segmentos.

 Decodificador de 7 segmentos.
El siguiente es el código utilizado en este noveno ejemplo:
1 ///////////////////////////////////////////////////////
2 ///////*****************************************///////
3 /////////***microcontroladores-mrelberni.com***////////
4 ///////*****************************************///////
6 ///////*****************************************///////
7
10 #include <avr/io.h> //archivo de cabecera para los nombres de los bits, los pines, los registros, etc
12
13 int main(void)
14 {
15 DDRC|=(15<<0);//pines PC0, PC1, PC2, y PC3 como salidas digitales
16 PORTC=9;//valor inicial obtenido en el puerto C
17
19 {
20 _delay_ms(1000);//pausa de 1 segundo para ver el número en el display
21 if(PORTC==0){//si el puerto c se hace 0
22 PORTC=9;//al puerto c se le asigna 9
23 _delay_ms(1000);//pausa de 1 segundo
24 }
25 PORTC--;//el valor visto en el display a traves del puerto C
26 } //disminuye en una unidad en cada ciclo del programa
27 }
Si he logrado ayudarte en cuanto a la utilización de los pines como entradas salidas
digitales con el AVR, comparte este enlace para poder ayudar a muchas personas
mas. Muchas Gracias.

Entradas Salidas Digitales

Cargado por

Información del documento

Título original

Derechos de autor

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Entradas Salidas Digitales

Título original:

Cargado por

Copyright:

Entradas salidas digitales

Entradas salidas digitales con el

Para elegir que el pin se comporte como salida digital, se

Para elegir que el pin se comporte como entrada digital, se

“Se ha comentado la forma de proceder para el caso del registro

DDRB |=(1<<DDB5);//DDB5 es el nombre del bit5 del registro DDRB

DDRB &=~(1<<DDB5);//DDB5 es el nombre del bit5 del registro DDRB

También se puede hacer así

PORTB |= (1<<3); //activa la resistencia pull up del pin PB3

Entradas salidas digitales con el AVR

Entradas salidas digitales con

 Display o visualizador de 7 segmentos.

El siguiente es el código utilizado en este noveno ejemplo:

También podría gustarte