UNIVERSIDAD NACIONAL DEL CALLAO

FACULTAD DE INGENIERÍA ELÉCTRICA Y ELECTRÓNICA

ESCUELA PROFESIONAL DE INGENIERÍA ELECTRÓNICA

LABORATORIO Nº2
TEMA:
INTERFASE DE INTERRUPTORES Y PULSADORES

ASIGNATURA:
MICROCONTROLADORES Y SISTEMAS EMBEBIDOS

PROFESOR:
ASTOCONDOR VILLAR, JACOB

INTEGRANTES:

• Alvarez Sandoval Piero Alessandro 1823220995

• Cjuno Rodríguez Sebastian Renzo 1823210906
• De la Cruz Salvador Kevin Gerzón 1823211016
• More Pumarrumi Jean Carlos 1823220773
• Vilca Perez Ivan Tomas 1823221273
 LABORATORIO 2
INTERFASE DE INTERRUPTORES Y PULSADORES

ENUNCIADO 1: Se conectan dos interruptores al PORTC<1:0> con pull -up internas y

según el valor leído realice una acción determinada conforme la siguiente tabla de
verdad:

OBJETIVOS
• Configurar las líneas de los puertos como entradas y salidas.
• Conocer la forma de interfaz ar correctamente interruptores y pulsadores.
• Utilizar las instrucciones:

FUNDAMENTO TEÓRICO Y ESQUEMA

Para la configuración de puertos como salidas debemos escribir en los bits del registro
DDRx 1 y 0 para entradas. En caso de ser salida un 1 en los bits de PORTx significa
pull -up interna habilitada. La lectura del dato de una entrada se lee en el registro PINx.

Los interruptores son elementos electromecánicos que generalmente se encuentran en

los contactos de los sensores digitales (capacitivos, inductivos, infrarrojos, etc.) ,
mientras que los pulsadores se emplean para el mando de motores ( encendido y
apagado ) .

Para conectar un pulsador o interruptor a un puerto de puede realizar a través de

resistencias pull -up o pull -down, conforme la siguiente figura. Recuerde que en el
microcontrolador AVR posee resis tencias pull -up internas que pueden ser habilitadas.

En caso de conectarse con resistencias pull -up el microcontrolador recibe 1L con el

pulsador abierto, lo contrario sucede con resistencia pull -down ( 0L con pulsador abierto
).
 MICROCONTROLADORES Y SISTEMAS EMBEBIDOS

a) Interface 5v b) interface de 12c a 24v

En caso de conectarse a voltajes de 12V o 24V se deberán poner resistencias que

limiten el voltaje a 5V y no dañen al pin (Fig. b).
Para el cálculo de las resistencias se emplea un divisor de voltaje, conforme el siguiente
ejemplo a 12V.

Donde V1=Vcc -Vpin ( Vpin=5V ) , entonces R3=7142 O por lo tanto su valor estándar
se de 6.8k Ω.
Con este valor, re calculando el voltaje Vpin será de 4.86V y la corriente (cuando se
accione el pulsador) en el pin será de 0.71mA.
Cuando se trabaja con interruptores y pulsadores aparece el fenómeno de los rebotes
que pueden dar en ocasiones señales falsas de accionamientos y que duran alrededor
de 5ms dependiendo del tamaño del pulsador. Para evitarlos se pueden emplear
métodos de eliminación de los rebotes por software o hardware. Nosotros emplearemos
el primero, introduciendo retardos de hasta 10ms.

El circuito de prueba, de acuerdo a las explicaciones dadas y con resistencias pull - up

internas activadas, se tiene el siguiente:

Fig. Circuito de prueba

Materiales
• Microcontrolador ATmega8 ( 1 )
• Protoboard ( 1)
• Dipswitch ( 1 dip de 4x2)
• Pulsadores ( 2)
• LEDs ( 8)
• Alambre No. 22AWG
• Fuente de voltaje estabilizada 5V/1A
• Grabador AVR tipo USB2.0 Desarrollo del programa

PROCEDIMIENTOS:

1. De acuerdo al circuito de la figura Circuito de prueba y a los requerimientos del

enunciado, desarrollar el programa ( Juegos_Luces.ASM )
2. Realizar el diagrama de flujo
 3. Comente cada sentencia

/*
* main.c
*
*
* Author: DE LA CRUZ SALVADOR KEVIN GERZON
*/

#define F_CPU 16000000UL

#include <avr/io.h>
#include <util/delay.h>
//#define pulsador0 (PINC & (1<<PORTC0))
//#define pulsador1 (PINC & (1<<PORTC1))
int main(void)
{
DDRD= 0xFF; //definicion todos los pines del puerto D como
salida
DDRC &= ~((1<<DDC0)|(1<<DDC1)); //definicion de puerto PC1 y PC0 como entrada
PORTC = (1<<0)|(1<<1); //Habilita la resistencia PULL-UP solo para el
pin PC0 y PC1.
while (1)
{
if ((PINC & (1<<PORTC1))==0){ // Se pone en BAJO (0) el pin PC1
if ((PINC & (1<<PORTC0))==0){ // Se pone en BAJO (0) en pin PC0

// LEDS APAGADOS

PORTD=0b00000000; // Todos los pines del "puerto D"

estan desabilitados
}

else{ // Se pone en ALTO (1) en pin PC0

// LUCES AUTO FANTASTICO

PORTD=0b10000001; // Se activa los pines del pin PD0 y PD7

_delay_ms(10);
PORTD=0b11000011; // Se activa los pines del pin PD0 PD1 y
PD7 PD6
_delay_ms(10);
PORTD=0b11100111;
_delay_ms(10);
PORTD=0b11111111;
_delay_ms(10);
PORTD=0b11100111;
_delay_ms(10);
PORTD=0b11000011;
_delay_ms(10);
PORTD=0b10000001;
_delay_ms(10);
PORTD=0b00000000;
_delay_ms(10);

}
}
else { // Se pone en ALTO (1) el pin PC1

if ((PINC & (1<<PORTC0))==0){ // Se pone en BAJO (0) el pin PC0

 //LEDS INTERMITENTES

PORTD=0b10101010;
_delay_ms(9);
PORTD=0b01010101;
_delay_ms(9);
}

else{ // Se pone en ALTO (1) el pin PC0

//JUEGO DE LEDS

PORTD=0b11110000; // Activamos los pines: PD7 PD6 PD5

PD4 (alto) y PD3 PD2 PD1 PD0 (bajo)
_delay_ms(9);
PORTD=0b00001111;
_delay_ms(9);

}
}
}
}

4. Realizar pruebas en el laboratorio

PC1=0 PC0=0 → LEDs APAGADOS

PC1=0 PC0=1 → AUTO FANTASTICO

PC1=1 PC0=0 → LEDs INTERMITENTES

PC1=1 PC0=1 → JUEGO DE LEDs

 Tarea adicionales
1. En el PORTB<3:0> se conectan 4 interruptores y al PORTB<7:4> 4 LEDs en
cátodo común. Realizar un programa que visualice a través de los LEDs el estado
de los interruptores. Empleando las resistencias pull -up internas tenemos:
interruptor abierto --> LED apagado e interruptor cerrado --> LED prendido.

Diagrama de flujo:

Código:

#define F_CPU 64MHz //declaramos la velocidad del procesador

#include <avr/io.h> //declaramos libreria del atmega

int main(void)//funcion principal

{
DDRB=0xF0; //Definimos de PB0 a PB3 como ENTRADAS y de PB4 a PB7 como SALIDAS
PORTB=0x0F; //Activamos los PUL-UP de las entradas de PB0 a PB3

while (1)
{
switch(PINB & 0x0F) //habilitamos 16 casos
{
case 0x00: //caso 1
PORTB=0xF0;//LEDS ENCENDIDOS//
break;
case 0x01: //caso 2
PORTB=0xE0;//encendemos led//
break;
 case 0x02: //caso 3
PORTB=0xD0;//encendemos led//
break;
case 0x03: //caso 4
PORTB=0xC0;//encendemos led//
break;
case 0x04: //caso 5
PORTB=0xB0;//encendemos led//
break;
case 0x05: //caso 6
PORTB=0xA0;//encendemos led//
break;
case 0x06: //caso 7
PORTB=0x90;//encendemos led//
break;
case 0x07: //caso 8
PORTB=0x80;//encendemos led//
break;
case 0x08: //caso 9
PORTB=0x70;//encendemos led//
break;
case 0x09: //caso 10
PORTB=0x60;//encendemos led//
break;
case 0x0A: //caso 11
PORTB=0x50;//encendemos led//
break;
case 0x0B: //caso 12
PORTB=0x40;//encendemos led//
break;
case 0x0C: //caso 13
PORTB=0x30;//encendemos led//
break;
case 0x0D: //caso 14
PORTB=0x20;//encendemos led//
break;
case 0x0E: //caso 15
PORTB=0x10;//encendemos led//
break;
case 0x0F: //caso 16
PORTB=0x00;//LEDS APAGADOS//
break;

}
}
}
Esquema:

U1
30 12 8 OFF ON 1
PD0/RXD/PCINT16 PB0/ICP1/CLKO/PCINT0
31 13 7 2
PD1/TXD/PCINT17 PB1/OC1A/PCINT1
32 14 6 3
PD2/INT0/PCINT18 PB2/SS/OC1B/PCINT2
1 15 5 4
PD3/INT1/OC2B/PCINT19 PB3/MOSI/OC2A/PCINT3
2 16
PD4/T0/XCK/PCINT20 PB4/MISO/PCINT4
9 17
PD5/T1/OC0B/PCINT21 PB5/SCK/PCINT5
10 7
PD6/AIN0/OC0A/PCINT22 PB6/TOSC1/XTAL1/PCINT6
11 8
PD7/AIN1/PCINT23 PB7/TOSC2/XTAL2/PCINT7
20 23
AREF PC0/ADC0/PCINT8
18
AVCC PC1/ADC1/PCINT9
24 D1 D2 D4 D3
25 LED-GREEN LED-GREEN LED-GREEN LED-GREEN
PC2/ADC2/PCINT10
19 26
ADC6 PC3/ADC3/PCINT11
22 27
ADC7 PC4/ADC4/SDA/PCINT12
28
PC5/ADC5/SCL/PCINT13
29
R1
PC6/RESET/PCINT14
10k
ATMEGA328P
 2. Realizar un programa que encienda y pague un LED desde dos puntos
(interruptores).
Diagrama de flujo:

Código:
int main(void)// funcion principal
{
DDRD =0x00; //Declaramos el puerto D como entrada
PORTD =0xFF; //Activamos las resistencias de PULL UP del puerto D
DDRB =0X01; //Declaramos el PORTB0 como salida

while (1)
{
switch(PIND & 0x03) //iniciamos 4 casos
{
case 0x00: //caso 1
PORTB = 0x00;
break;
case 0x01: //caso 2
PORTB = 0x01;
break;
case 0x02: //caso 3
PORTB = 0x01;
break;
 case 0x03: //caso 4
PORTB = 0x00;
break;
}
}
}

Esquema:

U1
4 OFF ON 1 30 12
PD0/RXD/PCINT16 PB0/ICP1/CLKO/PCINT0
3 2 31 13
PD1/TXD/PCINT17 PB1/OC1A/PCINT1
32 14
PD2/INT0/PCINT18 PB2/SS/OC1B/PCINT2
1
PD3/INT1/OC2B/PCINT19 PB3/MOSI/OC2A/PCINT3
15 D1
2 16 LED-RED
PD4/T0/XCK/PCINT20 PB4/MISO/PCINT4
9 17
PD5/T1/OC0B/PCINT21 PB5/SCK/PCINT5
10 7
PD6/AIN0/OC0A/PCINT22 PB6/TOSC1/XTAL1/PCINT6
11 8
PD7/AIN1/PCINT23 PB7/TOSC2/XTAL2/PCINT7
R1
20 23 220
AREF PC0/ADC0/PCINT8
18 24
AVCC PC1/ADC1/PCINT9
25
PC2/ADC2/PCINT10
19 26
ADC6 PC3/ADC3/PCINT11
22 27
ADC7 PC4/ADC4/SDA/PCINT12
28
PC5/ADC5/SCL/PCINT13
29
R2
PC6/RESET/PCINT14
10k
ATMEGA328P

3. Realizar un programa que con un interruptor abierto realice un juego de luces y

con el interruptor cerrado pite una sirena de manera intermitente.

DIAGRAMA DE FLUJO:
CÓDIGO:
#include <avr/io.h> //Incluimos la libreria de entradas y salidas
#define F_CPU 8000000UL //Definimos el clock del microcontrolador
#include <util/delay.h> //incluimos la libreria delay

int main(void)
{
DDRB = 0xFF; //habilitamos puerto B como salida
DDRC = 0X01; //habilitamos PORTC0 como salida
DDRD = 0X00; //habilitamos puerto D como entrada

while(1)
{
switch(PIND & 0x01) //habilitamos 2 casos para el PIND
{
case 0x00: //Caso 1

for(int i=1; i<=128; i=i*2)//iniciamos juego de luces conteo

creciente//
{
PORTB = i;
_delay_ms(150); //retraso de 150ms
}
for( int i=128; i>=1; i=i/2)//iniciamos juego de luces conteo
decreciente//
{
PORTB = i;
_delay_ms(150);_//retraso de 150ms
}
break;

case 0x01: //Caso 2

PORTB=0x00; //habilitamos el puerto B en apagado

PORTC=0x1; //encendemos la alarma

_delay_ms(800); //retraso de 800ms
PORTC=0X0; //apagamos la alarma
_delay_ms(800); //retraso de 800ms

break;
}

}
}
 4. Realizar un contador binario, el mismo que se incrementar á cada vez que se
pulse la tecla conectado a PC0. En el circuito de la figura se cambian los
interruptores por un pulsador

DIAGRAMA DE FLUJO:
CÓDIGO:
#include <avr/io.h> //declaramos libreria del atmega
#define F_CPU 16000000UL //declaramos velocidad del procesador//
#include <util/delay.h> //declaramos libreria del retraso
int main(void)
{
DDRB=0xFF; //Definimos salida
DDRC=0x00; //Definimos entrada
PORTB=0x00;//Apagado
PORTC=0x01;//Encendido
DDRD=0x01; //Definimos salida
PORTD=0x00;//Apagado
while(1)
{
for(int i=1;i<=255;i++) //Iniciamos el conteo
{
while (PINC & 0x01);//El while servira para habilitar el
button del contador
PORTB=i; // se activara los led contando de forma binaria
while (!(PINC & 0x01)); //Hasta que reciba una señal sale
del ciclo while
}
}
 5. Hacer los cambios en el programa anterior de tal forma que cuando la cuenta
llegue a 125, suene intermitente una sirena 5 veces.

CODIGO:
#define F_CPU 8000000UL
#include <avr/io.h>
#include <util/delay.h>

int main(void)
{
DDRD=0xFF; //SALIDAS
DDRC &=~ (1<<DDC0); //ENTRADA
PORTC=0x01; //PULL-UP
PORTD=0x00; //INCIALMENTE APAGADOS
while (1)
{
for(int i=1;i<=255;i++) //CONTEO
{
while (PINC & (1<<PINC0)); //HABILITAMOS EL PULSADOR
PORTD=i; //PUERTO D CONTARÁ DE FORMA BINARIA EN LOS
LEDS
if (i==125) //CONTEO 125
{
for (int j=1;j<=5;j++) //NRO DE VECES QUE SONARÁ LA SIRENA
{
PORTB=0x01; //SUENA LA SIRENA
_delay_ms(250); //SUENA POR 250ms

PORTB=0x00; //APAGA LA SIRENA

_delay_ms(250); //APAGA POR 250ms
}
}
while (!(PINC & (1<<PINC0))); //HASTA QUE RECIBA UNA SEÑAL DIFERENTE

}
}
}

CIRCUITO
DIAGRAMA DE FLUJO

PROBLEM
A5

CONFIGURAMOS
PUERTOS
DDRD=0xFF;
DDRC &=~ (1<<DDC0);
PORTC=0x01;
PORTD=0x00;

for(i=1; i<=255;
i++)

while(PINC & (1<<PINC0))

PORTD=i

NO SI
i==125 for(j=1; j<=5; j++)

PORTB=0x01;
_delay_ms(250);
PORTB=0x00;
_delay_ms(250)
 6. Un LED se prende con un pulso de una tecla, con el siguiente pulso se apaga.

CODIGO:
#define F_CPU 16000000UL
#include <avr/io.h>

int main(void)
{
DDRD &=~ (1<<DDD0); //ENTRADA
DDRB |= (1<<DDB0); //SALIDA
PORTD |= (1<<DDD0); //PULL-UP
while (1)
{
while (PIND & (1<<PIND0));
PORTB^= (1<<PORTB0);
while (!(PIND & (1<<PIND0)));
}
}

CIRCUITO

DIAGRAMA DE FLUJO

PROBLEM
A6

CONFIGURAMOS
PUERTOS
DDRD &=~ (1<<DDD0);
DDRB |= (1<<DDB0);
PORTD |= (1<<DDD0);

while (PIND & (1<<PIND0))

PORTB^= (1<<PORTB0)
 7. Realizar un programa que realice el encendido y monitoreo de un motor a través
de contactores. Existen 3 pulsadores: uno de parada ( BP ) , uno de marcha (
BM) y uno para funcionamiento intermitente ( BI ) , y un sensor de supervisión (
S ) . En caso de presionar BM el motor funciona de manera permanente y si se
cierra BP o S el motor se apaga. Con BI el motor funciona solo si este está
presionado.

SIMULACION :
/*
* problem7.c
*/
#define F_CPU 8000000UL
#include <avr/io.h>
#include <util/delay.h>
#define pulsador1BP (PIND & (1<<PORTD0))
#define pulsador2BM (PIND & (1<<PORTD1))
#define pulsador3BI (PIND & (1<<PORTD2))
int main(void)
{
DDRD &= ~((1<<DDD0)|(1<<DDD1)|(1<<DDD2)); // puertos de entrada
DDRB |= ((1<<DDB0)|(1<<DDB1)|(1<<DDB2)); // puertos de salida
while (1)
{
if (pulsador2BM==0){ // se a pulsado para ejercutar el codigo
while(pulsador3BI!=0 && pulsador1BP!=0 ){//motor en marcha
_delay_ms(100);
PORTB &= ~(1<<PORTB0); // para sentido antihorario
PORTB |= (1<<PORTB1);
PORTB |= (1<<PORTB2);
}
}
else {
PORTB &= ~(1<<PORTB2);
}
if (pulsador3BI==0){ // se a pulsado para ejercutar el codigo
while(pulsador2BM!=0 && pulsador1BP!=0){ // intermitente
_delay_ms(100);
PORTB &= ~(1<<PORTB0); //sentido antihorario
PORTB |= (1<<PORTB1);
PORTB |= (1<<PORTB2);
_delay_ms(1000);
PORTB &= ~(1<<PORTB2); // apagado del motor
_delay_ms(1000);
}
}
else {
PORTB &= ~(1<<PORTB2);
}
}
}

Link de drive:
https://drive.google.com/drive/folders/1GOSWgW2MWN43HZiuSnOV3Ldx_0MWVn6l?
usp=sharing