Reporte de Práctica 7

“Interrupciones ”
Microcomputadoras Automotrices I
7SV1

UPIITA-IPN

Alvarez Cruz Gerardo Javier

Castillo Rosales Erick Jared
Morales Hidalgo Nataly Michelle
27 de mayo de 2021

1
Índice
1. Introducción 3

2. Parte 1: Explicación del código 6

3. Parte 2: Código completo 11

4. Parte 3: Práctica en fisico 15

2
1. Introducción
En esta práctica se desarrollará un programa partiendo de la configuración
de entradas y salidas en cada uno de los puertos con los que cuenta en
microcontrolador.
Para esto es necesario crear algun tipo de interrupcion externa en algunos
de los PCINT o INT con los que cuenta el microcontrolador.
La interrupcion sera atendida solo cuando el dispositivo lo requiera, de
otra manera el codigo seguira ejecutandose y en este caso el conteo no se
interrumpe.
Esta interrupción es visible mediante una LCD.
Partes de la práctica: A continuación, se detalla el material utilizado,
ası́ como las partes que conforma la práctica realizada. Se describirá el código
empleado para el correcto funcionamiento del circuito fı́sico.

1. Placa Arduino (uno o mega)

2. 1 ATmega 328P

3. 1 LCD

4. 2 Push button

5. 2 resistencias de 560Ω

6. Cables para tablilla de pruebas (protoboard)

7. 2 Protoboard

3
 Figura 1: Esquema de conexion

A continuación está la figura 6 del atmega328p y la figura 3 del LCD.

4
Figura 2: ATMEGA328P

Figura 3: C
onexión LCD

5
 PIN Simbolo Nombre y Función
1 VSS GND (TIERRA 0 VOLTS)
2 VDD ALIMENTACIÓN 5 VOLTS
3 VO AJUSTE DE CONTRASTE
4 RS SELECCIÓN DATO/CONTROL
5 RW LECTURA O ESCRITURA EN LCD
6 E HABILITACIÓN
7-13 D0-D7 BIT DEL MENOS AL MAS SIGNIFICATIVO
14 LED + ÁNODO DE LED
15 LED - CATODO DE LED

2. Parte 1: Explicación del código

Explicación de cada lı́nea de los codigos desarrollados.
A continuación se muestra la explicación con el código que es para el
ATmega328P
1 #define F_CPU 8000000UL // se define la velocidad a la
que trabaja el programa
2 #include <avr/io.h> //biblioteca del AVR de entradas y
salidas
3 #include <util/delay.h>//biblioteca para el tiempo
4 #define LCD_Dport PORTD //Puerto D se define como
puerto LCD
5 #define LCD_Dpin DDRD //Puerto D como salidas
6 #define LCD_Cport PORTC //Puerto C se define como
puerto LCD
7 #define LCD_Cpin DDRC //Puerto C como salidas
8 #define LCD_INST 0
9 #define LCD_DATA 1
10 #define RSPIN PB0 //pin RS
11 #define ENPIN PB1 //Pin E
12 #define LINEA1 0x80 //primer linea de la LCD
13 #define LINEA2 0xC0 //segunda linea de la LCD
14 #define CLEAR 0x01 //limpia la LCD
15

6
16
17 void lcd_start(); //la pantalla se prende, lista para
usarse
18 void lcd_write(uint8_t type, uint8_t inst_data); //
para definir el renglon y la columna donde se
tienen que posicionar las letras
19 void lcd_init(); //configura las salidas en los
puertos
20 void lcd_print(char s); //imprime un Char
21 void lcd_print1(char *s); //imprime cadena de
caracteres
22
23 void lcd_start()
24 { // a q u se empieza a escribir el nibble, primero
la parte alta y luego la baja
25 PORTB &=˜ (1<<PORTB0);
26 _delay_ms(10);
27 PORTB |= (1<<PORTB0);
28 }
29
30 void lcd_write(uint8_t type, uint8_t inst_data) //se
envia el dato del caracter para el LCD
31 {
32 if(type)
33 PORTB |= (1<<PORTB1);
34 else
35 PORTB &=˜ (1<<PORTB1);
36 PORTD = (PIND & 0x0F) | (inst_data & 0xF0); //parte
alta
37 lcd_start();
38 PORTD = (PIND & 0x0F) | ((inst_data<<4) & 0xF0); //
parte baja
39 lcd_start();
40 _delay_ms(20);
41 }
42
43 void lcd_init()
44 //se inicializan funciones en la LCD

7
45 {
46 LCD_Dpin = 0x0F | 0x030; //Control pines LCD (0-4
como salidas)
47 LCD_Dpin = 0x0F | 0x020;
48 DDRD |= 0xF0;
49 DDRB |= (1<<DDB0) | (1<<DDB1);
50 PORTB &=˜ ((1<<PORTB0) | (1<<PORTB0));
51
52 lcd_start();
53 _delay_us(100);
54
55 lcd_write(LCD_INST, 0x2C);
56 lcd_write(LCD_INST, 0x08);
57 lcd_write(LCD_INST, 0x0C);
58 lcd_write(LCD_INST, 0x06);
59 lcd_write(LCD_INST, 0x01);
60 }
61
62 void lcd_print(char s) //se imprimen los caracteres en
el LCD
63 {
64 lcd_write(LCD_DATA, s);
65 }
66 void lcd_print1(char *s)
67 {
68 while(*s)
69 {
70 lcd_write(LCD_DATA, *s);
71 s++
72 }
73 }
74 char valor[]={"0123456789F9876543210"}; //variable de
tipo char para almacenar el conteo de
interrupciones
75 char norm[]={"0123456789"};//variable tipo char para
almacenar el conteo del programa
76 int i,j,k;
77 int main(void)

8
 78 {
79 lcd_init(); //llamado de funcion
80 lcd_write(LCD_INST,LINEA1); //se posiciona en la
linea 1
81 lcd_print1("Conteo:"); //Imprime el mensaje
82 LCD_Dpin = 0x0F; //pantalla limpia
83 LCD_Cpin = 0x00; //pines de escritura
84 LCD_Dport = 0x0F; //configuracion del Puerto D en 0
85 LCD_Cpin = 0b0001111; //pines menos significativos
86 LCD_Dpin = 0xF0; //pines mas significativos
87 DDRD &= ˜(1 << DDD2); //PD2 como entrada
88 EICRA |= (1 << ISC01) | (1 << ISC00); //interrupcion
externa por cambio de estado y nivel bajo en
INT0
89 //EICRA |= (1 << ISC00);
90 EIMSK |= (1 << INT0); //habilita interrupciones
externa en INT0
91 sei(); //habilita las interrupciones
92 cont=0; //variable del contador
93 while(1)
94 {sei();
95
96 if (estadoBoton==1)//verifica si el estado de
boton es 1
97 {
98 cli();//activa las interupciones
99 cont++;//aumenta el conteo de interrupciones
100 estadoBoton=0;//regresa el valor del estado de
boton a 0
101 _delay_ms(50);//espera 50 ms para evitar
rebotes
102 lcd_write(LCD_INST, 0x01);//borra pantalla
103 lcd_write(LCD_INST,LINEA1);//manda a escribir
en la linea 1
104 lcd_print1("Interrupcion: ");//escribe
105 lcd_write(LCD_INST,LINEA2);//manda el puntero
a escribir en la segunda linea
106 lcd_print(valor[cont-1]);//escribe el conteo

9
 de interrupciones
107 _delay_ms(10);//espera 10 ms para visualizar
108 }
109 lcd_write(LCD_INST, 0x01);//borra la pantalla
110 lcd_write(LCD_INST,LINEA2);//se habilita la
escritura en la linea 2
111 j=i/10; //operacion para hacer j como decenas
112 k=1 %10; //operacion para solo tomar valores del
array para las unidades
113 lcd_print(norm[j]);//se imprimen las decenas
114 lcd_print(norm[k]); //se imprimen las unidades
115 _delay_ms(100); //retardo
116 i++; //incremento
117 }
118 }
119 ISR (INT0_vect)//etiqueta que apunta a la direccion de
interrupcion INT0
120 {
121 estadoBoton = 1;//si se realiza la interrupcion
activa el estado del boton
122 }

10
 3. Parte 2: Código completo
A continuación se presenta el codigo sin comentarios desarrollado en el
Atmega328p y posteriormente el correspondiente al Arduino UNO
1 #define F_CPU 8000000UL
2 #include <avr/io.h>
3 #include <avr/interrupt.h>
4 #include <util/delay.h>
5 #define LCD_Dport PORTD
6 #define LCD_Dpin DDRD
7 #define LCD_Cport PORTC
8 #define LCD_Cpin DDRC
9 #define LCD_INST 0
10 #define LCD_DATA 1
11 #define RSPIN PB0
12 #define ENPIN PB1
13 #define LINEA1 0x80
14 #define LINEA2 0xC0
15 #define CLEAR 0x01
16 int estadoBoton=0,cont=0;
17 void lcd_start();
18 void lcd_write(uint8_t type, uint8_t inst_data);
19 void lcd_init();
20 void lcd_print(char s);
21 void lcd_print1(char *s);
22
23 void lcd_start()
24 {
25 PORTB &=˜ (1<<PORTB0);
26 _delay_ms(10);
27 PORTB |= (1<<PORTB0);
28 }
29
30 void lcd_write(uint8_t type, uint8_t inst_data)
31 {
32 if(type)
33 PORTB |= (1<<PORTB1);

11
34 else
35 PORTB &=˜ (1<<PORTB1);
36 PORTD = (PIND & 0x0F) | (inst_data & 0xF0);
37 lcd_start();
38 PORTD = (PIND & 0x0F) | ((inst_data<<4) & 0xF0);
39 lcd_start();
40 _delay_ms(20);
41 }
42
43 void lcd_init()
44 {
45 LCD_Dpin = 0x0F | 0x030;
46 LCD_Dpin = 0x0F | 0x020;
47 DDRD |= 0xF0;
48 DDRB |= (1<<DDB0) | (1<<DDB1);
49 PORTB &=˜ ((1<<PORTB0) | (1<<PORTB0));
50
51 lcd_start();
52 _delay_us(100);
53
54 lcd_write(LCD_INST, 0x2C);
55 lcd_write(LCD_INST, 0x08);
56 lcd_write(LCD_INST, 0x0C);
57 lcd_write(LCD_INST, 0x06);
58 lcd_write(LCD_INST, 0x01);
59 }
60
61 void lcd_print(char s)
62 {
63 lcd_write(LCD_DATA, s);
64 }
65 void lcd_print1(char *s)
66 {
67 while(*s)
68 {
69 lcd_write(LCD_DATA, *s);
70 s++;
71 }

12
 72 }
73 char valor[]={"0123456789F9876543210"};
74 char norm[]={"0123456789"};
75 int i,j,k;
76 int main(void)
77 {
78 lcd_init();
79 lcd_write(LCD_INST,LINEA1);
80 lcd_print1("Conteo:");
81 LCD_Dpin = 0x0F;
82 LCD_Cpin = 0x00;
83 LCD_Dport = 0x0F;
84 LCD_Cpin = 0b0001111;
85 LCD_Dpin = 0xF0;
86 DDRD &= ˜(1 << DDD2);
87 EICRA |= (1 << ISC01) | (1 << ISC00);
88 //EICRA |= (1 << ISC00);
89 EIMSK |= (1 << INT0);
90 sei();
91 cont=0;
92 while(1)
93 {sei();
94
95 if (estadoBoton==1)
96 {
97 cli();
98 cont++;
99 estadoBoton=0;
100 _delay_ms(50);
101 lcd_write(LCD_INST, 0x01);
102 lcd_write(LCD_INST,LINEA1);
103 lcd_print1("Interrupcion: ");
104 lcd_write(LCD_INST,LINEA2);
105 lcd_print(valor[cont-1]);
106 _delay_ms(10);
107 }
108 lcd_write(LCD_INST, 0x01);
109 lcd_write(LCD_INST,LINEA2);

13
110 j=(i/10);
111 k=(i %10);
112 lcd_print(norm[j]);
113 lcd_print(norm[k]);
114 _delay_ms(100);
115 i++;
116 }
117 }
118 ISR (INT0_vect)
119 {
120 estadoBoton = 1;
121 }

14
4. Parte 3: Práctica en fisico
En esta seccion se muestran imagenes de la conexion y el funcionamiento
del circuito. En el PCINT que es el pin del Atmega328P se ha conectado
un pulsador para crear la interrupción externa. El puerto se ha declarado
como puerto LCD, es decir se conectaran los buses de datos, el control y la
habilitacion de lectura/escritura.
Por ultimo la salida del potenciometro regula la intensidad de la LCD en
su pin V0.

Figura 4: Conteo en el numero 10

15
Figura 5: Interrupcion

16
Figura 6: El conteo continua

17
Referencias
[Gonzalez, 2009] Rafael C. Gonzalez, et al. (2009) Digital Image Processing
Pearson Education

[Forsyth, 2012] David Forsyth, et al.(2012) Computer Vision: A Modern

Approach Pearson Education

[Snyder, 2004] Wesley E. Snyder, et al.(2004) Machine Vision Cambridge

University Press

[González, 2006] Ana González Marcos, et al.(2006) Técnicas y Algoritmos

Básicos de Visión Artificial Universidad de la Rioja, Servicio de Publi-
caciones

18