21-22 PI Prac1a Enunciado

ESCUELA DE INGENIERÍA INFORMÁTICA
Grado en Ingeniería Informática
PERIFÉRICOS E INTERFACES
PRÁCTICAS DE LABORATORIO
Práctica 1a
Interfaces paralelos en el µC ATmega 2560
Última actualización: 14 septiembre 2021

Contenido
1 Competencias y objetivos de la práctica ...........................................................................................4
2 Documentación previa ......................................................................................................................5
3 Introducción a la plataforma hardware de prácticas .........................................................................6
4 Descripción general de la tarjeta Arduino Mega 2560 .....................................................................7
4.1 Componentes básicos .................................................................................................................7
4.2 Entradas/salidas en la tarjeta Arduino Mega 2560 ...................................................................11
4.2.1 Entradas/salidas digitales de propósito general ................................................................13
4.2.2 Puertos de comunicación serie ..........................................................................................16
4.2.3 Salidas de control de potencia (PWM) .............................................................................19
4.2.4 Entradas analógicas (A0-A15) ..........................................................................................20
4.2.5 Líneas de alimentación y reset ..........................................................................................22
4.3 Sistema de interrupciones del microcontrolador ATmega 2560 ..............................................23
4.3.1 Configuración y habilitación de interrupciones externas ..................................................24
4.3.2 Subrutina de servicio de una interrupción (ISR) ...............................................................29
4.3.3 Funciones Arduino para la gestión de interrupciones .......................................................30
5 Tarjeta de expansión .......................................................................................................................32
5.1 Componentes básicos ...............................................................................................................32
5.1.1 Visualizador de 7 segmentos.............................................................................................34
5.1.2 Pulsadores .........................................................................................................................35
5.1.3 Zumbador y/o altavoz .......................................................................................................35
5.1.4 Otros componentes ............................................................................................................35
5.2 Diagrama de conexiones de la tarjeta expansión......................................................................36
5.3 Detalles del conexionado de los periféricos .............................................................................39
5.3.1 Visualizador 7-segmentos .................................................................................................39
5.3.2 Pulsadores .........................................................................................................................40
5.3.3 Zumbador/altavoz .............................................................................................................41
6 Entorno de programación Arduino .................................................................................................42
7 Realización práctica ........................................................................................................................44
7.1 Tarea 1. Salidas digitales ..........................................................................................................46
7.2 Tarea 2. Comunicación serie ....................................................................................................46
7.3 Tarea 3. Sincronización por consulta de estado .......................................................................46
7.4 Tarea 4. Visualización sincronizada por interrupción externa .................................................47
7.5 Tarea 5. Sensor de temperatura (opcional, mejora)..................................................................48
8 Defensa y entrega del informe de práctica ......................................................................................49
Practica 1a Interfaces paralelos en el uc ATmega 2560
40964-Periféricos e Interfaces 3
Práctica 1a Interfaces paralelos en el uC ATmega 2560
1 Competencias y objetivos de la práctica

Esta práctica de la asignatura Periféricos e Interfaces se centra en el uso del sistema de
entrada/salida de un sistema empotrado (sistema que integra los componentes básicos de un
computador, procesador, memoria y entrada/salida, en un mismo chip) ya que ofrece más
facilidades para el desarrollo de aplicaciones a bajo nivel que, por ejemplo, un computador tipo PC.
Este tipo de computadores tiene un hardware más complejo y difícilmente utilizable a bajo nivel ya
que el sistema operativo impediría al usuario acceder directamente a los recursos hardware en aras
de garantizar el funcionamiento fiable y seguro del computador, además de garantizar la integridad
de la información perteneciente a otros usuarios. Es por ello que, en estos sistemas, el usuario
accede a los recursos hardware a través de llamadas al sistema operativo. Por tanto, con objeto de
trabajar directamente con los interfaces de entrada/salida y familiarizarnos con ellos, es más
adecuado el uso de un sistema empotrado que nos permite trabajar con todos los recursos hardware
sin limitaciones.
El sistema empotrado seleccionado está basado en el microcontrolador AVR ATmega 2560 de
Atmel (empresa comprada por Microchip en 2016) que cuenta con una gran cantidad de
información y soporte de la comunidad de desarrolladores. Este sistema (disponible en la tarjeta
Arduino Mega 2560) se complementa con una tarjeta con diferentes periféricos que se pueden
conectar fácilmente a los puertos del microcontrolador. Como alternativa a trabajar con los
componentes físicos directamente, se propone el uso del simulador Proteus con el que se puede
diseñar y simular todas las prácticas planificadas de la asignatura presentando grandes ventajas,
sobre todo en condiciones de restricciones por Covid-19 por lo que será la herramienta principal de
trabajo.
El microcontrolador AVR ATmega 2560 está dotado de un procesador de 8 bits, memorias, timers y
un potente sistema de entrada/salida, multifuncional y reconfigurable que lo hacen idóneo para el
desarrollo de una gran cantidad de aplicaciones en múltiples campos (automatización, robótica,
hobby, control de dispositivos, ...).
Los diferentes interfaces, vistos por el programador de bajo nivel (como es nuestro caso) como un
conjunto de registros, serán programados para llevar a cabo el control y el intercambio de
información con los dispositivos externos o periféricos. En este contexto se pondrán en práctica los
conocimientos teóricos adquiridos en las clases de teoría. Básicamente, se utilizarán la
sincronización por consulta de estado e interrupciones y las transferencias de datos por programa.
Con la realización de esta práctica se pretende que el estudiante alcance las siguientes
competencias:
1. Capacidad para hacer uso de periféricos o dispositivos externos que se puedan conectar a las
entradas/salidas del sistema empotrado e intercambiar información haciendo uso de las técnicas
adecuadas en cada caso.
2. Capacidad para entender los diversos aspectos software y hardware involucrados en los
métodos de sincronización.
3. Capacidad para diseñar e implementar el software necesario para la gestión de interrupciones
en un sistema empotrado basado en microcontrolador.
GII: 40964-Periféricos e Interfaces 4

4. Capacidad para aprender y aplicar nuevos conceptos de forma autónoma e interdisciplinar.

5. Capacidad para emplear la creatividad en la resolución de los problemas.
6. Capacidad para trabajar en equipo y colaborar eficazmente con otras personas.
Para alcanzar estas competencias se plantea la consecución de los siguientes objetivos:
1. Conocer y usar un sistema empotrado como la plataforma Arduino Mega 2560 para la
ejecución y depuración de programas sencillos realizados en el entorno de programación de la
plataforma Arduino o, preferentemente, del simulador Proteus..
2. Conocer y entender los aspectos básicos de funcionamiento y programación de algunos de los
interfaces de entrada/salida del sistema empotrado.
3. Realizar programas sencillos que impliquen operaciones de entrada/salida con los periféricos
seleccionados utilizando la consulta de estado como método de sincronización.
4. Conocer y entender la gestión de interrupciones en el sistema empotrado, así como los recursos
de la plataforma para facilitar su uso.
5. Diseñar y programar una aplicación sencilla que implique operaciones de entrada/salida con los
periféricos combinando la consulta de estado y las interrupciones como métodos de
sincronización y las transferencias de datos por programa.
2 Documentación previa
La documentación básica a utilizar para la realización de esta práctica (además de los propios
relacionados con la teoría del módulo 1y 2) está disponible en el Campus Virtual de la ULPGC en
el curso que corresponde a Periféricos e Interfaces. La documentación mínima a manejar será la
siguiente:
- Documento 1: Enunciado de la práctica (este documento)
- Documento 2: Presentación de la práctica
- Transparencias del módulo 1 y 2
- Datasheet Atmel ATmega 2560 (435 páginas)
o http://ww1.microchip.com/downloads/en/devicedoc/atmel-2549-8-bit-avr-
microcontroller-atmega640-1280-1281-2560-2561_datasheet.pdf
- Software: Entorno de programación de Arduino y simulador Proteus
https://www.arduino.cc/en/Main/Software
https://www.hubor-proteus.com/
- Internet: Búsqueda de cualquier otra información que se considere necesaria
3 Introducción a la plataforma hardware de prácticas

Las prácticas de la asignatura Periféricos e Interfaces se desarrollarán sobre la plataforma hardware
mostrada en la Figura 1 que será simulada en el simulador Proteus. El sistema consta de dos
elementos básicos: una tarjera Arduino Mega 2560 basada en el microcontrolador AVR ATmega
2560 de 8 bits y una tarjeta de expansión con múltiples componentes (teclado, visualizador 7-
segmentos, pantalla OLED y LCD, memoria I2C, etc..) cuyas señales de control se llevan a
conectores ubicados en la propia tarjeta de expansión con el objetivo de que sean fácilmente
accesibles para interconectarlos al microcontrolador mediante cables, que pueden ser fácilmente
reconfigurados de acuerdo a las necesidades de cada aplicación. Para las aplicaciones que se
plantean a lo largo de las prácticas, es más que suficiente las conexiones preestablecidas cuyos
detalles se irán presentando en los sucesivos enunciados de prácticas. Por ello, el estudiante, salvo
excepciones, solo ha de centrarse en el desarrollo de software haciendo uso del entorno de
programación de Arduino.
Figura 1. Arduino Mega 2560 + tarjeta de expansión
En los siguientes apartados, realizaremos una breve descripción de la estructura de las tarjetas que
conforman nuestro hardware experimental y del entorno de programación Arduino. Una vez
estudiado los diferentes aspectos de hardware tendremos una visión general del sistema que nos va
a permitir afrontar con éxito el desarrollo de las primeras aplicaciones planteadas en el apartado de
"realización práctica".
4 Descripción general de la tarjeta Arduino Mega 2560

4.1 Componentes básicos
La tarjeta Arduino Mega 2560 es una plataforma hardware de tipo "open-source" y bajo coste
dotada de un microcontrolador ATmega 2560 de 8 bits de bajo consumo con amplias capacidades
de entrada y salida que le permiten un gran desempeño en múltiples campos de la informática y la
automatización. Las diferentes tarjetas Arduino se integran en un entorno de programación que
posibilita las tareas básicas en el desarrollo de software (edición, compilación, carga y depuración)
de una forma cómoda y amigable para el usuario que le permiten trabajar en lenguaje C/C++ con el
soporte de un gran número de librerías.
La figura 2 muestra una imagen de la tarjeta con los principales componentes.
Figura 2. Componentes básicos de la tarjeta Arduino Mega 2560
El componente más importante de la tarjeta es el microcontrolador ATmega 2560 de 100 patas (o

pines) que integra básicamente los siguientes elementos: procesador, memoria e interfaces de
entrada y salida, entre otros. Veamos las características más importantes de cada uno de ellos:
Procesador
- 8 bits, low power, arquitectura RISC
- 131 instrucciones
- 1 instrucción por ciclo (1 MIPS per MHz)
- 32 registros de 8 bits de propósito general
- Modos de ahorro de energía: Idle, power-down, power-save, ADC noise reduction y standby
Memoria
- Memoria Flash (256 KB), SRAM (8KB) y EEPROM (4 KB)
Entrada/salida
Los pines de entrada/salida del microncontrolador son multifuncionales, es decir, son compartidos
por los diferentes interfaces y pueden tener las siguientes capacidades:
- 86 líneas de entrada/ salida digital de propósito general agrupadas en puertos de 8 y 6 bits
- 6 Interrupciones externas
- USART programables (comunicación serie)
- SPI (Serial Peripheral Interface)
- TWI: two-wire interface (i2c)
- ADC: 16 canales, 10-bit resolución
- 15 salidas de timers
Otros
- 1 comparador analógico
- Timer Watchdog, programable y con oscilador interno
- JTAG
En la figura3 se muestra un diagrama de bloques del microcontrolador AT mega 2560 donde se

pueden ver todos sus componentes internos y los puertos de entrada y salida.
Figura 3. Diagrama de bloques del microcontrolador ATmega 2560
La figura 4 muestra el encapsulado y patillaje (pines) del microcontrolador así como otras
características en cuanto a consumos, temperatura de funcionamiento y versiones.
Figura 4. Encapsulado y patillaje (pines) del microcontrolador de 8 bits ATmega 2560
4.2 Entradas/salidas en la tarjeta Arduino Mega 2560

El microcontrolador ATmega 2560 puede controlar hasta un total de 86 señales de entrada-salida a
través de las que se comunica con el exterior. Estas señales de entrada/salida se agrupan en su
mayoría en grupos de 8 bits denominados puertos. Existen un total de 11 puertos (10 puertos de 8
bits y 1 puerto de 6 bits) etiquetados con una letra (A-B-C-D-E-F-G-H-J-K-L):
PA[7:0]PB[7:0]PC[7:0]PD[7:0]PE[7:0]PF[7:0]PG[5:0]PH[0:7]PJ[0:7]PK[7:0]PL[7:0]
Cada bit de un puerto se lleva al exterior a través de una pata (pin) del microcontrolador haciendo
un total de 86 pines asociados a las entradas/salidas. En la tarjeta Arduino, gran parte de los pines
del microcontrolador son llevados a conectores externos donde el usuario pueda realizar sus
conexiones. De los 86 pines, sólo 70 tienen conexión con los conectores de la tarjeta Arduino Mega
2560. Los 16 pines que faltan (PE2-6-7, PD4-5-6, PG3-4, PH2-7, PJ2-3-4-5-6-7) no se podrán
utilizar salvo que, por algún otro medio, se acceda directamente al pin del microcontrolador para
realizar la conexión con el exterior.
En la figura 5, podemos apreciar los diferentes conectores y el etiquetado de los pines con un
número que luego se puede utilizar como parámetro, en las diferentes funciones del entorno de
programación de Arduino, para realizar operaciones de entrada-salida sobre el pin. En el circuito
impreso de la tarjeta se puede apreciar el rotulado de los pines y el agrupamiento en 5 grupos según
la funcionalidad principal:
-DIGITAL. Entradas/salidas digitales de propósito general: pines 22-53
- COMMUNICATION. Canales de comunicación serie: pines TX0/RX0,..., SDA/SCL
- PWM. Salidas de control de potencia: pines 2-13 (12 canales)
- ANALOG IN. Entradas analógicas: pines A15-A0
- POWER. Líneas de alimentación y reset: pines Vin, GND, +5v, +3.3v, reset
Figura 5. Tarjeta Arduino Mega 2560 (microcontrolador ATmega2560)

La mayoría de los pines del microcontrolador son multifuncionales desempeñando distintas
funciones en función de la programación de los interfaces que tengan asociados. En cualquier caso,
prevalecen las funciones de entrada/salida digital de propósito general sobre otras de carácter
alternativo que se activan cuando se realiza la programación adecuada de su interfaz.
Los interfaces son visibles al programador a través de un conjunto de registros que se mapean en el
espacio de direccionamiento de memoria del microcontrolador. Concretamente, el microcontrolador
ATmega 2560 mapea estos registros en el rango de direcciones 0x20-0x1FF (0x200-0x20 = 512-32
= 480 bytes) aunque muchas de estas direcciones están libres y reservadas para usos futuros del
microcontrolador. El acceso a los registros se realiza con instrucciones nativas del microcontrolador
del tipo IN/OUT o LD/ST (LOAD/STORE) según se acceda a ellos a través del espacio de
entrada/salida
1
(puertos) o del espacio de memoria, respectivamente.
Las instrucciones IN/OUT solo pueden acceder a un espacio de entrada/salida de tamaño 64 bytes
(0x00-0x3F) en la que se encuentran mapeados diferentes registros (port mapped I/O). Los registros
también se encuentran mapeados como memoria (memory mapped I/O) a los que se accede con
instrucciones del tipo LD/ST en el rango de direcciones 0x020-0x1FF (480 direcciones o registros)
espacio más que suficiente para mapear gran número de registros. Tenga en cuenta que parte de este
2
espacio no se llega a utilizar o está reservado para un uso futuro.
En la figura 6 se muestra los diferentes pines de los conectores de la tarjeta Arduino Mega 2560
especificándose las diferentes funcionalidades que pueden tener cada uno de ellos y los puertos del
microcontrolador a los que se conecta.
13
12
11
10
14
15
16
17
18
19
20
21
3
9
8
7
6
5
4
3
2
1
0
PH6/OC2B
PH4/OC4B
PG5/OC0B
TX0 PE1/TXD0/PDO
AREF
PH5/OC4C
PB7/OC0A/OC1C/PCINT7
PB5/OC1A/PCINT5
PB4/OC2A/PCINT4
PE3/OC3A/AIN1
RX0 PE0/RXD0/PCINT8
TX3 PJ1/TXD3/PCINT10
RX3 PJ0/RXD3/PCINT9
TX2 PH1/TXD2
RX2 PH0/RXD2
TX1 PD3/TXD1/INT3
RX1 PD2/RXD1/INT2
SDA PD1/SDA/INT1
SCL PD0/SCL/INT0
PH3/OC4A
PB6/OC1B/PCINT6
PE5/OC3C/INT5
PE4/OC3B/INT4
22
PA0/AD0
23
PA1/AD1
24
PA2/AD2
25
PA3/AD3
26
PA4/AD4
27
PA5/AD5
4 28
PA6/AD6
29
PA7/AD7
30
PWM COMUNICATION PC7/A15
31
PC6/A14
32
PC5/A13
33
DIGITAL
PC4/A12
34
PC3/A11
35
PC2/A10
36
PC1/A9
37
5 PC0/A8
ATMEGA2560 38
16AU 1126 PD7/T0
39
PG2/ALE
40
PG1/RD
41
PG0/WR
42
PL7
43
PL6
44
PL5/OC5C
45
PL4/OC5B
ANALOG IN PL3/OC5A
46
47
6 PL2/T5
48
PK2/ADC10/PCINT18
PK3/ADC11/PCINT19
PK4/ADC12/PCINT20
PK5/ADC13/PCINT21
PK6/ADC14/PCINT22
PK7/ADC15/PCINT23
PL1/ICP5
PK0/ADC8/PCINT16
PK1/ADC9/PCINT17
49
PL0/ICP4
50
PF5/ADC5/TMS
PF6/ADC6/TDO
PF4/ADC4/TCK
PB3/MISO/PCINT3
PF7/ADC7/TDI
51
PB2/MOSI/PCINT2
52
PF0/ADC0
PF1/ADC1
PF2/ADC2
PF3/ADC3
PB1/SCK/PCINT1
53
PB0/SS/PCINT0
RESET
7 ARDUINO MEGA2560 R3
A0
A1
A2
A3
A7
A6
A5
A4
A8
A9
A10
A11
A12
A13
A14
A15
Figura 6. Multifuncionalidad de los pines del Arduino Mega 2560
4.2.1 Entradas/salidas digitales de propósito general

Las 86 líneas de entrada/salida asociadas a los puertos del microcontrolador, se pueden programar
para ser utilizadas como entradas o salidas binarias (1 o 0) de propósito general. Para esta
funcionalidad, cada puerto dispone de un interfaz con tres registros internos que se utilizan para
configurar cada bit de un puerto como de entrada o de salida y, luego, realizar las operaciones de
entrada y salida de datos binarios.
4.2.1.1 Registros internos del interfaz de un puerto

El interfaz de cada puerto x consta de tres registros: DDRx, PORTx, y PINx , siendo "x" la letra del
puerto (A-B-C-D-E-F-G-H-J-K-L). Por ejemplo, para el interfaz del puerto B, tendríamos los
registros: DDRB, PORTB y PINB.
Los nombres de todos estos registros están definidos en el entorno de programación de Arduino lo
que permite al programador leer y escribir en ellos desde el lenguaje de programación C/C++ de
una manera fácil y directa.
Registro DDRxn: Port x Data Direction Register

A través de este registro se define si un bit “n” del puerto “x” es de entrada o de salida.
Si DDRxn es "0", el bit n del puerto x (Pxn) será de entrada
Si DDRxn es "1",el pin n del puerto x (Pxn) será de salida
Ejemplo para puerto A de 8 bits (PA[7:0])

DDRA = B00001111; // Define los pines PA[7:4] de entrada y los pines PA[3:0] de salida
DDRA = 0x0F; // la misma operación, pero en hexadecimal
B: Binario
0x: Hexadecimal
PORTx: Port x Data Register

La salida de datos se realiza escribiendo en el registro PORTx. Los pines asociados a un puerto
digital están en estado de alta impedancia cuando la condición de "reset" está activa. El efecto de
escribir en un bit de este registro (PORTXn) depende de si el bit del puerto está previamente
configurado como entrada o salida. En la siguiente tabla, se resume el efecto de escribir un "1" o
"0" en un bit del puerto, dependiendo de si éste es de entrada o de salida.
PORTxn de entrada PORTxn de salida

Operación
(DDRxn=0) (DDRxn=1)
Escribir un "1" Conecta la resistencia de pull-up 1
Escribir un "0" Desconecta la resistencia de pull-up 0
Ejemplos:
// Programación de la dirección de los pines del PORTL
DDRL=B11110000; // PL[7:4]: pines de salida PL[3:0]: pines de entrada
// Escritura en el puerto PORTL
PORTL= B11110011; // PL[7:4]: Salidas a "1"; PL[3:2]: Res. pull-up desconectadas; PL[1:0]: Res.
pull-up conectadas
// Programar solo los pines 7 y 0 del puerto B de salida
DDRB = DDRB | B1000001;
PINx: Port x Input Pins

La entrada de datos se realiza leyendo el puerto PINx. A través del registro PINx se puede leer el
estado de los pines del puerto x, independientemente de si los pines del puerto x están programados
como de entrada o de salida.
Ejemplos:
// Lectura de los pines del PORTA (PA[7:0])
val1 = PINA; // lectura de los 8 pines del PORTA
// Lectura de los pines del PORTL
val2=PINL; //lectura de los 8 pines del PORTL
En la figura 7 se muestra los registros del interfaz del PORTA tal y como aparecen en el manual de
usuario del microcontrolador ATmega 2560. Para cada registro se especifica su nombre, el nombre
de cada uno de sus bits y la dirección en el espacio de E/S o la dirección del espacio de memoria
(entre paréntesis) donde se ubica o mapea el registro.
Para el caso particular del puerto A, vemos que el registro DDRA tiene la dirección 0x01 cuando
accedemos al registro con instrucciones del tipo IN/OUT y la dirección de memoria 0x21 cuando
accedemos con instrucciones del tipo LD/ST.
Figura 7. Registros asociados al PA (puerto A): PORTA, DDRA y PINA
4.2.1.2 Funciones Arduino para el manejo de las entradas/salidas digitales

Además de manejar los puertos de entrada/salida digitales de propósito general directamente a
través de los registros del interfaz, el entorno de programación Arduino proporciona otras funciones
de más alto nivel que facilitan la programación desde el lenguaje de programación c/C++.
Las funciones básicas son:

// Programar un pin de entrada o de salida
pinMode(nº pin, 1/0)
pinMode(13,INPUT); // pin 13 de entrada (INPUT=0)
pinMode(10,OUTPUT); // pin 10 de salida (OUTPUT=1)
// Poner un pin a "1" (HIGH) o a "0" (LOW)

digitalWrite(pin, 1/0)
digitalWrite(10, HIGH); // escribe un "1"
digitalWrite(10, LOW); // escribe un "0"
// Leer el estado de un pin

digitalRead(nº pin)
var1 = digitalRead(13); // lee pin 13 y deja el valor en var1
4.2.2 Puertos de comunicación serie

La tarjeta Arduino Mega 2560 dispone de 4 canales de comunicación serie: TX0/RX0, TX1/RX1,
TX2/RX2 y TX3/RX3.
- TXn: Línea de transmisión del canal n (salida)
- RXn: Línea de recepción del canal n (entrada)
4.2.2.1 Interfaz de las comunicaciones serie

Cada pareja de líneas TX/RX(voltaje 0-5v) está asociada a una USART (Universal Synchronous
Asynchronous Receiver and Transmitter) que es un interfaz, altamente flexible, para las
comunicaciones serie dotado de múltiples registros a través de los que se configura y controla las
comunicaciones serie del canal. La figura 8 muestra tales registros remitiendo al estudiante al
manual del microcontrolador para un mayor detalle del funcionamiento.
Figura 8. Registros asociados al interfaz de una USARTn

La comunicación serie consiste básicamente en el envío secuencial de los bits de un dato (de 7 u 8
bits, mayoritariamente) bit a bit, por una línea de transmisión a un ritmo constante síncronamente
con una señal reloj y de acuerdo a un protocolo. La velocidad de transmisión se mide en baudios o
bits por segundo siendo frecuentes los valores de 2400, 4800, 9600, ... 115200 baudios. El
protocolo de transmisión serie (ver figura 9) establece cómo se han de trasmitir los datos definiendo
la estructura de las palabras que se envían por el canal para garantizar la correcta recepción de los
datos por el receptor sin errores o pérdidas de datos. Para el envío de un dato el protocolo establece
la siguiente estructura o información a enviar:
- 1 bit de START
- 7/8 bits de datos
- 1 bit de paridad (si está habilitada)
- 1 o 2 STOP bits
Figura 9. Transmisión serial de datos

La USART se encarga de realizar todas las operaciones de sincronización y envío de datos y avisa,
a través de sus registros, de eventos diversos que pueden producirse durante la transmisión-
recepción de los datos teniendo también capacidades para la generación de interrupciones asociadas
dichos eventos tales como:
- Errores en la transmisión/recepción de datos
- Buffer de transmisión vacío
- Recepción de un dato
- y otros.
4.2.2.2 Funciones Arduino para la comunicación serie
a) Configuración de un canal serie: velocidad y protocolo

- Velocidad (protocolo el de por defecto)
Serial.begin(speed); //para TX0/RX0
Serial1.begin(speed); //para TX1/RX1
....
- Velocidad y protocolo específico a través de config
Serial.begin(speed,config); // para TX0/RX0
Serial3.begin(speed,config); //para TX3/RX3
speed: 2400, 4800, 9600, ... 115200 (baudios o bits/seg)

config: SERIAL_5N1, SERIAL_8N2, .... (SERIAL_tamaño-dato|paridad|stop bits)
Donde:
Tamaño del dato: 5,6,7,8
Paridad: None (N), Even-par (E), Odd-impar (O)
Stop bits: 1,2
b) Transmisión de datos por el canal serie

Serial.write()
Serial.print()
Serial.println()
c) Recepción de datos por el canal serie

Serial.available()
Serial.read()
d) Deshabilitación del canal serie

Serial.end()
Para más información y uso de las funciones consultar la página web de Arduino.
4.2.3 Salidas de control de potencia (PWM)

Son salidas en las que se genera señales del tipo Pulse Width Modulation (PWM), es decir, una
onda de frecuencia fija, pero de ciclo de trabajo (duty cycle) variable como se muestra en la
figura10:
Figura 10. Señal de control de potencia PWM (Pulse Width Modulation)

El valor medio del voltaje que se aplica al dispositivo que esté conectado al pin en el que se genera
una señal PWM oscila entre 0 y 5 voltios. Con esta señal se puede controlar el nivel de iluminación
de un LED, velocidad de un motor, nivel de apertura y cierre de una válvula, temperatura y otras
acciones.
Estas señales son generadas por los TIMERS de que dispone el microcontrolador. El ATmega 2560
dispone de un total de 6 timersde 8 y 16 bits con aplicaciones en multitud de campos que van desde
el establecimiento de temporizaciones hasta la generación de señales PWM. Los timers disponibles
son:
Timer0: 8 bits (uso por las funciones: delay(), millis(), micros())
Timer1: 16 bits
Timer2: 8 bits (uso por la función tone())
Timer3-4-5: 16 bits
El uso de los timers es esencial en un uso avanzado del microcontrolador. Sin embargo, en esta
práctica no profundizaremos más en su interfaz queserá objeto de un estudio más detallado en
futuras prácticas por lo que ahora sólo comentaremos las funciones del entorno de programación
Arduino que manejan este tipo de señales.
4.2.3.1 Funciones Arduino para la generación de señales PWM

La función Arduino que nos permite la generación de señales PWM es:
analogWrite(pin, valor); // escritura analógica
Donde:
- Pin: nº de pin por donde sale la señal PWM generada por el timer. Posibles pines a utilizar:
Pines: 4-13 (timer 0)
Pines: 11-12-13 (timer 1)
Pines: 9-10 (timer 2)
Pines: 44-45-46 (timer5)
- valor: Número entre 0 (0% duty cycle) y 255 (100% duty cycle)
4.2.4 Entradas analógicas (A0-A15)

Las entradas analógicas permiten la lectura de valores analógicos en el rango de los 0 a 5 voltios
mediante un proceso de digitalización basado en un conversor analógico-digital (ADC: Analog
Digital Converter) de 10 bits de resolución disponible en el microcontrolador. Ver figura11. De esta
forma, 0v en una entrada analógica da lugar al valor digital 0000000000 y 5v al valor digital
1111111111, ambos representados internamente como enteros de 16 bits, con una resolución
mínima de 4.88mv (5v/1024 = 4.88mv). Estas entradas permiten la conexión de dispositivos
analógicos (ej. sensores) y, tras la conversión de los datos, tratar la información digitalmente con el
correspondiente programa.
Figura 11. Conversión analógica-digital de una señal
Uso de las líneas analógicas como puertos de entrada y salida digitales

Después de un reset las líneas analógicas del microcontrolador quedan como entradas analógicas
por defecto siendo necesaria su reprogramación para utilizarlas como líneas de entrada y salida
digitales con lo que se aumentaría el número de este tipo de líneas. Para ello, veamos el siguiente
ejemplo que reprograma las entradas analógicas A7-A0 asociadas al puerto F (PF[7:0]) como de
entradas digitales:
DDRF = B00000000; pines asociados: 61(A7) ... 54(A0)
Nota: A las nuevas líneas de entrada digitales se les asigna un número correlativo a las digitales ya
existentes (pines 22-53) por lo que el pin A0 sería la línea 54 y el pin A7 la línea 61.
Para más información sobre la estructura interna del interfaz asociado a las entradas analógicas
remitimos al estudiante al manual del microcontrolador.
4.2.4.1 Funciones Arduino para las entradas analógicas

Las funciones Arduino asociadas con las entradas analógicas son:
analogRead(pin); // pin: A0-A15
analogReference(type); // type: DEFAULT, INTERNAL1V1, INTERNAL2V56, EXTERNAL
(pin AREF)
pinMode(pin, INPUT_PULLUP); //pin A0-A15
La función analogRead(pin) lee el valor analógico del pin y lo convierte a un valor digital de 10
bits (0-1023 en decimal).
La función analogReference(type) fija un voltaje de referencia para el conversor analógico digital
según el valor máximo esperado para las señales a digitalizar y conectadas a las entradas analógicas.
Para ello, hay varias opciones que van desde los 5v internos (valor por defecto) hasta el valor de un
voltaje externo (entre 0 y 5v) aplicado al pin AREF. Cuando se cambia este valor de referencia, las
primeras lecturas que se hagan con analogRead() puede que no sean muy exactas.
La función pinMode(pin, INPUT_PULLUP) conecta una resistencia de pull-up en la entrada
analógica indicada por el parámetro "pin" para que la entrada no quede al aire cuando no hay nada
conectado.
Ejemplo:
analogReference(INTERNAL2V56); // se fija un voltaje de referencia interno de 2.56v
pinMode(A0,INPUT_PULLUP); // conecta resistencia de pull-up
int val = analogRead(A0); // val= 0-1023 (para entradas de 0 a 2.56 voltios)
4.2.5 Líneas de alimentación y reset

En la clasificación inicial de los pines del Arduino Mega 2560 tenemos un último grupo de pines
asociados a la alimentación y reset. Estos pines son:
- Vin: Entrada de 5 voltios, voltaje regulado y estabilizado como alternativa al USB.
- 5V: Salida de 5 voltios regulados (estables)
- 3V3: Salida de 3.3 voltios a partir de los reguladores de tensión de la tarjeta
- GND: Tierra
- IOREF: Proporciona el voltaje de referencia con el que trabaja el microcontrolador
- RESET: Un "0" en este pin da lugar a un reset del microcontrolador.
Además de estos pines, existen otras conexiones en la tarjeta que son:
- Puerto USB: Alimentación y comunicaciones con el Computador Personal (PC)
- Conector 7-12v: Para alimentación externa de 7-12v mediante adaptador AC-DC
4.3 Sistema de interrupciones del microcontrolador ATmega 2560

El microcontrolador Atmega 2560 tiene un sistema de interrupciones autovectorizado (vectores
fijos, es decir, vectores preasignados a las diversas fuentes de interrupción) con una tabla de
interrupciones a partir de la posición 0 de memoria. Cada vector ocupa dos bytes y contiene una
instrucción de salto (jmp) a la rutina de servicio de la interrupción (ISR: Interrupt Service Routine).
Las prioridades quedan establecidas según el número del vector siendo el vector 1 (reset) el más
prioritario y el vector 57 (USART3 TX) el menos prioritario. A continuación, se muestra una parte
de la tabla de vectores de interrupción y su contenido:
......
Address Code Comments

0x0000 jmp RESET RESET handler
0x0002 jmp INT0_vect IRQ0 handler
... ... ...
0x0070 jmp USART3_TX_vect USART3 TX Complete Handler
Figura 12. Tabla de vectores de interrupción
Las interrupciones pueden ser externas o internas. Las interrupciones externas tienen su origen en el
exterior del microcontrolador y son producidas por dispositivos que cuando requieren atención del
procesador interrumpen para que se les atienda de forma inmediata. Las interrupciones internas
tienen su origen en los múltiples interfaces y dispositivos internos del microcontrolador y sus
requerimientos son similares a las de las interrupciones externas.
Operaciones básicas en el uso de las interrupciones

Para gestionar una interrupción, interna o externa, se deben realizar las siguientes operaciones
básicas:
1. Configurar y habilitar la interrupción para que pueda interrumpir. Esto se hace a través de
los registros del interfaz que corresponda y del registro estado del procesador.
2. Definir la subrutina de servicio para la interrupción, ISR(intr_vect), y cargarla en memoria.
Inicializar la entrada de la tabla de vectores de interrupción asociada al evento o vector de
interrupción, intr_vect, para que dicha entrada contenga la instrucción:
jmp ISR(intr_vect)
Cada evento ya tiene asignado un vector intr_vect (vectores fijos) que sirve de índice para
entrar en la tabla de vectores de interrupción.
Todo esto se realiza automáticamente, y de forma transparente para el usuario, al declarar la
función Arduino ISR(intr_vect). Solo hemos de seleccionar el intr_vect que corresponda al
evento que produce la interrupción.
El microcontrolador tiene múltiples interfaces para soportar los diferentes canales de comunicación,
tanto digitales como analógicos, y todos ellos tienen capacidad para generar interrupciones cuando
en su funcionamiento se producen determinados eventos.
En primer lugar, trataremos las interrupciones externas del tipo INTn y PCINTn y sus registros
asociados a través de los que se configuran. Una vez configuradas y definidas las subrutinas de
servicio de interrupción, el sistema de interrupciones queda listo para su funcionamiento.
4.3.1 Configuración y habilitación de interrupciones externas

La habilitación de una interrupción, normalmente, requiere de dos operaciones. La primera
operación, de carácter global, afecta todas las interrupciones y se realiza a través de un bit del
registro de estado del procesador. La segunda operación, de carácter más individual, está
relacionada con la configuración y habilitación de cada una de las interrupciones en particular a
través de los registros del interfaz de interrupciones que será objeto de descripción en los siguientes
apartados.
El registro de estado del procesador tiene la siguiente estructura:
Para las interrupciones, solo nos interesa el bit 7 de este registro. Este bit afecta a todas las
interrupciones del microcontrolador, permitiéndolas o no. Para manipular este bit se dispone de las
instrucciones:
SEI: Habilita interrupciones (I=1)

CLI: Deshabilita las interrupciones (I=0)
Cuando ocurre y se trata una interrupción este bit se pone a cero. Cuando se retorna de la subrutina
de servicio de la interrupción este bit vuelve a ponerse a "1".
4.3.1.1 Interrupciones externas de tipo INTn

La siguiente tabla muestra los pines asociados a las interrupciones externas del tipo INTn.
Interrupción externa Pin

INT0 21
INT1 20
INT2 19
INT3 18
INT4 2
INT5 3
Las interrupciones INTn son de carácter individual y se programan de forma independiente a través
de los registros de su interfaz. Los dispositivos externos pueden hacer uso de estas interrupciones a
través de los pines mencionados en la tabla. Los registros a los que hay que acceder para configurar
y habilitar una interrupción externa, tipo INTn, son los siguientes:
EXTERNAL INTERRUPT CONTROL REGISTER A (EICRA)
Permite configurar el funcionamiento de las interrupciones INT3-0 de acuerdo a la siguiente tabla:
EXTERNAL INTERRUPT CONTROL REGISTER B (EICRB)
Permite configurar el funcionamiento de las interrupciones INT7-4 de acuerdo a la siguiente tabla:
EXTERNAL INTERRUPT MASK REGISTER (EIMSK)
Con los bits de este registro se puede habilitar o deshabilitar una interrupción externa de tipo INTn
de forma individual. A este registro se le conoce con el nombre de registro de máscaras y actúa de
la siguiente forma:
Bit=1: Habilita la interrupción y puede interrumpir (desenmascara)
Bit=0: Deshabilita la interrupción y no puede interrumpir (enmascara)
EXTERNAL INTERRUPT FLAG REGISTER (EIFR)
Este registro nos permite conocer las interrupciones que están pendientes de ser atendidas. Cuando
se ejecuta la rutina de servicio de una interrupción, el bit correspondiente se pone a 0. También se
puede resetear (poner a cero) si en él se escribe un "1".
4.3.1.2 Interrupciones externas de tipo PCINTn

Las interrupciones externas PCINTn (Pin Change Interrupt) son sensibles o se disparan cuando el
pin cambia de estado. Tienen la particularidad de que ciertas operaciones de configuración y
habilitación se hacen a nivel de grupo de interrupciones y no de forma individual.
La siguiente tabla muestra los nombres de las interrupciones y los pines asociados.
Interrupción externa Pin

PCINT0-PCINT7 53,52,51,50,10,11,12,13
PCINT8-PCINT15 0,15,14,-,-,-,-,-
PCINT16-PCIN23 A8-A15
Note que ciertas interrupciones del tipo PCINTn, marcadas con el carácter "-", no tienen salida a los
conectores de la tarjeta Arduino.
Los registros del interfaz para configurar y habilitar este tipo de interrupciones son:
PIN CHANGE INTERRUPT CONTROL REGISTER (PCICR)
Habilita o deshabilita un grupo de interrupciones externas de la siguiente forma:

PCIE0: Un "1" habilita las interrupciones PCINT7-0. Un "0" las deshabilita.
PCIE1: Un "1" habilita las interrupciones PCINT15-8.Un "0" las deshabilita.
PCIE2: Un "1" habilita las interrupciones PCINT23-16.Un "0" las deshabilita.
PIN CHANGE INTERRUPT FLAG REGISTER (PCIFR)
Este registro nos permite conocer los grupos de interrupciones que están pendientes de ser atendidos
(pero no que interrupción dentro del grupo!). Cuando se ejecuta la rutina de servicio de una
interrupción, el bit correspondiente se pone a "0". También se puede resetear (poner a cero) si en él
se escribe un "1".
PIN CHANGE MASK REGISTER 0 (PCMSK0)
Registro de máscaras para las interrupciones PCINT7-0.



4.3.2 Subrutina de servicio de una interrupción (ISR)

La idea básica es declarar una función ISR(intr_vect) que automáticamente se carga en memoria
como una subrutina de atendimiento para la interrupción con vector “intr._vect”.
Cuando se produce una interrupción cuyo vector de interrupción es "intr_vect", automáticamente se
ejecutará la función ISR(intr_vect) que atenderá al dispositivo que interrumpió. El entorno de
programación de Arduino facilita la definición de estas subrutinas de servicio utilizando una
función con el nombre ISR() con la sintaxis que se muestra a continuación:
ISR(intr_vect){
// Cuerpo de la subrutina ISR()
// Se ejecutará cuando se produzca una interrupción
// con el nº de vector "intr_vect"
}
El parámetro "intr_vect" es el vector de interrupción que cada fuente de interrupción tiene ya fijado
(interrupciones autovectorizadas) y al que se hace referencia de forma muy cómoda a través de un
nombre o etiqueta. La siguiente tabla muestra algunos de estos nombres de vectores (del 0 al 31)
que se utilizan como índice para entrar en la tabla de vectores de interrupción desde donde se salta a
la subrutina de servicio de interrupción o función ISR() del vector.
RESET INT7_vect TIMER1_CAPT_vect SPI_STC_vect

INT0_vect PCINT0_vect TIMER1_COMPA_vect USART0_RX_vect
INT1_vect PCINT1_vect TIMER1_COMPB_vect USART0_UDRE_vect
INT2_vect PCINT2_vect TIMER1_COMPC_vect USART0_TX_vect
INT3_vect WDT_vect TIMER1_OVF_vect ANALOG_COMP_vect
INT4_vect TIMER2_COMPA_vect TIMER0_COMPA_vect ADC_vect
INT5_vect TIMER2_COMPB_vect TIMER0_COMPB_vect EE_READY_vect
INT6_vect TIMER2_OVF_vect TIMER0_OVF_vect TIMER3_CAPT_vect
Para una lista completa de vectores de interrupción y sus nombres consultar el fichero:
C:\Program Files (x86)\Arduino\hardware\tools\avr\avr\include\avr\iomxx0_1.h
Veamos ahora algunos ejemplos.
Ejemplo 1: Definición de la función ISR de la interrupción externa INT3 (pin 20)

ISR(INT3_vect){
// Cuerpo de la subrutina de servicio de interrupción a ejecutar cuando
// se interrumpa por el pin 20 (INT3).
}
Ejemplo 2: Definición de la función ISR de la interrupción interna del TIMER1_COMPA

ISR(TIMER1_COMPA_vect){
// Cuerpo de la subrutina de servicio de interrupción a ejecutar cuando
// interrumpa el TIMER1_COMPA.
}
Una vez visto cómo se define una función ISR(), es necesario afrontar la programación de los
interfaces para que puedan generar interrupciones. Como son varios los interfaces disponibles en el
microcontrolador, en esta práctica solo abordaremos el estudio del que corresponde a las
interrupciones externas y de forma más superficial, el interfaz del TIMER1, solo en la
programación necesaria para que genere una interrupción cada cierto tiempo.
4.3.3 Funciones Arduino para la gestión de interrupciones

El entorno de programación de Arduino ofrece un conjunto de funciones que permiten al usuario
hacer uso de las interrupciones externas de una manera cómoda y sencilla, sin tener que conocer los
detalles de bajo nivel del microcontrolador Atmega 2560.
Las funciones básicas Arduino para el manejo de interrupciones externas son:
Deshabilitar interrupciones
noInterrupts()
cli()
Conectar/asociar una interrupción externa de tipo INTn a un pin
attachInterrupt(digitalPinToInterrupt(pin), miRutina, Mode)
pin: nº del pin por donde se interrumpe 21-20-19-18-2-3 (INT0-1-2-3-4-5)
miRutina: Función a ejecutar para atender a la interrupción
Mode: Modo de disparo de la interrupción: LOW, CHANGE, RISING, FALLING
Habilitar interrupciones
interrupts()
sei()
Declarar una función ISR() para una interrupción
ISR(intr_vect){....}
Desconectar una interrupción de un pin

detachInterrupt(digitalPinToInterrupt(pin))
Como se intuye de las anteriores funciones, para las interrupciones externas de tipo INTn (INT0-1-
2-3-4-5) el entorno Arduino proporciona todo lo necesario para que el usuario, de forma muy
cómoda, configure, habilite y declare la subrutina de servicio que se ha de ejecutar cuando por un
pin externo, con capacidad de interrumpir, se interrumpa. El usuario apenas necesita conocer
detalles internos del microcontrolador para utilizar este tipo de interrupciones.
Sin embargo, el manejo del resto de tipos de interrupciones requiere de una mayor implicación del
programador, en el sentido que, ha de conocer la estructura interna de los interfaces, sus registros y
funcionalidades para programar adecuadamente las operaciones de configuración y habilitación de
interrupciones. Se puede decir que el programador ha de hacer una programación directa, de bajo
nivel, accediendo al hardware de los interfaces a nivel de bits. No es necesario comentar que las
interrupciones de tipo INTn se pueden gestionar de esta forma, a bajo nivel, sin hacer uso de las
funciones de alto nivel de Arduino.
5 Tarjeta de expansión
5.1 Componentes básicos
Con objeto de poder facilitar y desarrollar aplicaciones con dispositivos periféricos de uso frecuente
se ha diseñado y construido una tarjeta de expansión (ver figura 13) que integra varios periféricos
de entrada y salida. Las señales de control de estos periféricos terminan en unos conectores que
luego mediante un cableado se pueden conectar fácilmente a los pines de la tarjeta Arduino Mega
2560. La tarjeta dispone de los siguientes elementos:
1) Pulsadores
2) Visualizador de 4 dígitos 7-segmentos
3) Zumbador
4) Teclado matricial de 12 teclas (4 filas x 3 columnas)
5) Memoria EEPROM (I2C)
6) Pantalla LCD (serial/I2C)
7) Pantalla OLED (I2C)
8) Otros componentes: resistencias y transistores
En la realización de esta práctica sólo será necesario el uso de los pulsadores, el visualizador de 7
segmentos y el zumbador, que serán objeto de descripción en los siguientes apartados, dejando la
descripción del resto de los componentes para prácticas futuras y cuando se haga uso de ellos.
Conectores Memoria Pantalla

EEPROM OLED
Conector
Bus I2C
Pantalla
LCD
Transistores
Resistencias
Visualizador
Zumbador 7-segmentos
Resistencias
Pulsadores
Figura 13.- Tarjeta de expansión
Teclado
matricial
5.1.1 Visualizador de 7 segmentos

La tarjeta de expansión tiene un visualizador de 7-segmentos de 4 dígitos. La figura14 muestra la
estructura interna de un visualizador de 7-segmentos (HP 5082-7740) formado por los segmentos a,
b, c, d, e, f y g y un punto (dot), conectados en una configuración de ánodo común o cátodo común.
El utilizado en esta práctica será de cátodo común por lo que para encender los segmentos será
necesario aplicar una tensión positiva a la entrada del segmento y conectar a tierra (0 voltios) la pata
o pin de cátodo común. En las hojas de características del visualizador podrá consultar todos los
detalles relativos a las tensiones y corrientes necesarias para el correcto funcionamiento. Según
dichas hojas, será suficiente una corriente de IF= 20 mA para que un segmento brille fuertemente.
En nuestro caso y para no cargar demasiado los puertos del Arduino, limitaremos esta corriente a 8-
10 mA que será suficiente para una visualización satisfactoria.
Figura 14. a) Visualizador de 7 segmentos;b) Pines del HP 5082-7740)

También existen en el mercado visualizadores de 4 dígitos, con un conexionado interno
preestablecido, que simplifica enormemente el diseño cuando se necesita un visualizador de varios
dígitos siendo ésta la solución adoptada en el diseño de la tarjeta de expansión. En la figura15 se
muestra elvisualizador de cátodo común modelo SMA420564, de 4 dígitos (Digit1,
Digit2,Digit3,Digit4) donde se aprecia los pines asociados a los segmentos de los dígitos
(A,B,C,D,E,F,dp) y los pines de los cátodos comunes de los dígitos (1,2,3,4).
Figura 15. Visualizadorde 4 dígitos SMA420564
5.1.2 Pulsadores
Los pulsadores son elementos muy sencillos que cuando se pulsan establecen una conexión entre
dos terminales. Se comercializan en distintas calidades definidas por el número de pulsaciones que
son capaces de soportar sin fallos de conexión.
Figura 16. Pulsador
5.1.3 Zumbador y/o altavoz

Como avisador acústico se hará uso de un altavoz o zumbador. Este dispositivo transductor
convierte la energía eléctrica en acústica a través de una membrana o elemento similar. Puede
generar sonidos de diferentes frecuencias según la frecuencia de la señal eléctrica aplicada. Ver
figura 17.
Figura 17. Altavoz/zumbador
5.1.4 Otros componentes

Además de los componentes anteriormente citados se utilizan otros que son necesarios para el
funcionamiento conjunto del sistema. Básicamente, nos estamos refiriendo a resistencias discretas o
en formato array (DIL: Dual In Line), transistores PNP como drivers de los visualizadores de 7
segmentos, conectores varios y cables de conexionado. Las resistencias se utilizan como limitadores
de corriente mientras que los transistores, en este caso, se utilizan como interruptores que dejan
pasar o no, corrientes de intensidades de hasta 500 mA.
La línea de selección de cada uno de los dígitos del visualizador (cátodo común) no debe conectarse
directamente a un pin del Arduino ya que la corriente del cátodo común puede alcanzar los 96-120
mA, suponiendo que todos los segmentos estén encendidosy 12-15 mA por segmento. Estos valores
de intensidad son excesivos para un pin del Arduino que según las especificaciones puede trabajar
con valores típicos de hasta 20 mA. A partir de los 40 mA se corre el riesgo de quemar el pin o
línea. Es aquí donde utilizamos un transistor que actúa como un interruptor controlado por una señal
de mando generada por el Arduino. Así podremos controlar el paso de corrientes de colector (Ic) de
100-200 mA a partir de una señal de mando del orden de 10-20 mA aplicada a la base (Ib). Ver
figura 18.
La corriente de base es la que tendría que manejar (dar o recibir) el pin del Arduino que como
puede observarse es 10 veces más pequeña que la corriente del terminal de colector(proveniente del
cátodo común del visualizador 7 segmentos).
Figura 18. Transistor PNP 2N2907
5.2 Diagrama de conexiones de la tarjeta expansión

Una vez descritos los componentes básicos a utilizar en esta práctica, vamos a continuar con el
esquema de conexionado de todos los componentes que es mostrado en la figura 19. Como se
aprecia, todas las señales de datos y control de los periféricos son llevadas a conectores terminales
convenientemente etiquetados.
La figura 20 muestra el mapeo (correlación) de señales realizado entre los conectores de la tarjeta
de expansión (donde terminan todas las señales de los periféricos de la tabla) y los conectores del
Arduino Mega 2560. Este mapeo ya se encuentra implementado a través de cables de conexión por
lo que, salvo excepciones, el estudiante únicamente debe centrar su atención en conocer qué
controla cada pin del Arduino (de acuerdo al mapeo de señales establecido) y el desarrollo de
software que la aplicación a desarrollar demande.
Figura 19. Diagrama de conexiones en la tarjeta prototipo
Figura 20. Interconexiones entre el Arduino Mega 2560 y la tarjeta de expansión
5.3 Detalles del conexionado de los periféricos

Solo se detallan los periféricos a utilizar en esta práctica. El resto de las conexiones pertenecientes a
otros periféricos se deja para futuras prácticas.
5.3.1 Visualizador 7-segmentos

El control del visualizador de 7 segmentos de 4 dígitos requiere de dos grupos de señales: 1)
Información a visualizar en los segmentos a-b-c-d-e-f-g-dp y 2) señales de control para los cátodos
comunes del visualizador.
El primer grupo de señales lo proporciona el PORTA del Arduino, pines 22-29, de acuerdo a la
información suministrada en la tabla de la figura 21 que muestra la correspondencia entre los
segmentos del visualizador y los pines del PORTA. La tabla muestra los valores a enviar al puerto
para visualizar los dígitos decimales 0, 1 y 2. El resto de la tabla se deja como ejercicio para el
estudiante.
Puerto PA[7:0] del Arduino

bit  PA7 PA PA5 PA4 PA3 PA2 PA1 PA0
Valor
pin 29 28 27 26 25 24 23 22
Seg. dot g f e d c b a
0 - 0 1 1 1 1 1 1 0x3F=63
1 - 0 0 0 0 1 1 0 0x06=06
2 - 1 0 1 1 0 1 1 0x5B=91
3
4
5
6
7
8
9
Figura 21. Conexiones de los segmentos del visualizador
En segundo grupo de señales, asociadas al control del cátodo común de cada uno de los dígitos del
visualizador, es proporcionado por el PORTL del Arduino de acuerdo a la información mostrada en
la figura 22. El cátodo común del dígito más a la derecha (unidades) está conectado al emisor de un
transistor y se gobierna con la señal D4-C1(pin 49, PL0). Cuando dicha señal está a cero el
transistor se satura o conduce conectando el cátodo común a tierra y, por tanto, todos aquellos
segmentos que tenga un “1”, o 5 voltios, a la entrada se encenderán. De igual forma, se ha
conectado el dígito de la izquierda (decenas) pero en este caso es la señal D3-C2(pin 48, PL1) la
encargada de activar el dígito. De igual forma, las señales de control D2-C3 (pin 47, PL2) y D1-nn
(pin46, PL3), controlan los dígitos de las centenas y unidades de millar. La tabla de la figura 22
resume las conexiones comentadas anteriormente a los pines PL0, PL1, PL2 y PL3. El resto de los
pines del puerto L no es objeto de estudio es esta práctica ya que están relacionados con el teclado
matricial, objeto de estudio en futuras prácticas.
PORTL
Nº pin Puerto Nombre señal Función
42 PL7-in fila_R1 Leer fila R1 del teclado
46 PL3-out D1---- activar D1(mill.)
47 PL2-out D2-C3 activar D2 (cent.) + col. 3 teclado
48 PL1-out D3-C2 activar D3 (dec.) + col. 2 teclado
49 PL0-out D4-C1 activar D4 (uds.) + col. 1 teclado
Figura 22. Conexiones de las señales de control D1-D2-D3-D4
5.3.2 Pulsadores
Los pulsadores son conectados a los pines PC[7:3] del Arduino Mega 2560 de modo que cuando se
pulsa un pulsador el pin se pone a "0" y cuando no está pulsado el pin queda a "1". Será necesario
activar las resistencias de pull-up internas del Arduino para definir el estado HIGH de un
pulsador cuando éste no esté pulsado. En la figura 23, se muestra la conexión de los pulsadores a
los pines del PORTC del Arduino.
PORTC
Nº pin Puerto Nombre señal Función
30 PC7-in pright Derecha
31 PC6-in pdown Abajo
32 PC5-in pleft Izquierda
33 PC4-in penter Enter
34 PC3-in pup Arriba
35 PC2 -
36 PC1 -
37 PC0-out speaker Altavoz
Figura 23. Conexiones de los pulsadores
Para una correcta detección de las señales de los pulsadores es necesario conectar las resistencias de
pull-up de los pines que correspondan para lo que se pueden utilizar las siguientes líneas de código
en el apartado de setup() de nuestro programa:
DDRC = B00000001; // Definimos el PORTC de entrada salvo PC0 (salida)

PORTC= B11111000;// activar pull-up interno de los pines de entradaPC7-PC3
5.3.3 Zumbador/altavoz
El zumbador o altavoz, según de los que se disponga, permite generar una señal acústica de una
frecuencia de terminada. Para ello, haremos uso de la función tone():
tone(pin, frecuencia, duración en ms)
Inicialmente el zumbador de la tarjeta de expansión está ya cableado para hacer uso del pin 37
(PC0).
6 Entorno de programación Arduino

El software para implementar las diferentes actividades prácticas se desarrollará bajo el entorno de
programación de Arduino haciendo uso de las utilidades que nos ofrece su lenguaje de
programación para controlar los diversos aspectos del hardware. Cada programa,llamado "sketch"
en el entorno de programación de Arduino, requiere de un directorio con el mismo nombre y consta
de las siguientes secciones:
1.- Declaración de variables

2.- Función setup()
- void setup() {....}: Código de inicialización (se ejecuta sólo una vez)
3.- Opcional: otras funciones de la aplicación, librerías, ...
3.- Función loop()
- void loop() {....}: Código de ejecución indefinida
La figura muestra el entorno de programación con un programa en edición.
Ejemplo de programa:
/*
Blink:Turns on an LED on for one second, then off for one second, repeatedly.
*/
// Declaración de variables
// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;
// Inicialización: setup()
// the setup routine runs once when you press reset:
void setup() {
// initialize the digital pin as an output.
pinMode(led, OUTPUT);
}
// otras funciones
void function_1() { … }
void function_2() { … }
ISR(vector de interrupción){.....}
// Bucle indefinido: loop()

// the loop routine runs over and over again forever:
void loop() {
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
// posibles llamadas a funciones

function_1();
function_2();
.....
}
7 Realización práctica
Para familiarizarse con el sistema de entrada y salida y con el entorno de programación de Arduino,
plantearemos un conjunto de actividades prácticas, de complejidad creciente, de modo que, una vez
realizadas, se tenga una cierta habilidad y soltura para el desarrollo de aplicaciones que impliquen
emplear las técnicas de transferencias de datos y sincronización en las operaciones de entrada y
salida. El estudiante tiene completa libertad para realizar cualquier otra actividad complementaria, o
de ampliación a las actividades básicas planteadas, con la posibilidad de incrementar la calificación
de la práctica, hasta en 1 punto, por mejoras. El siguiente esquema muestra un diagrama de bloques
del display de 7-segmentos, pulsadores y un teclado (en principio, no usado en esta práctica) y las
conexiones al microcontrolador. Dadas las condiciones en las que se desarrolla la docencia, la
práctica se desarrollará, íntegramente, en el simulador Proteus. Diseñe el sistema propuesto
en dicho simulador, o bien, descargue el proyecto disponible en la carpeta de la práctica 1 en
el campus virtual.
En la siguiente página se muestra un esquema tanto del microcontrolador (con un etiquetado de

pines compatible con la tarjeta Arduino Mega 2560) como de la tarjeta de expansión con los
periféricos disponibles en la tarjeta física o real, diseñado todo ello en el simulador Proteus. El
estudiante podrá modificar este esquema para añadir nuevas funcionalidades o rediseñar aspectos
que sean de su interés.
30 97
RESET RESET PF0/ADC0 AD0 AD0 IO54
96
PF1/ADC1 AD1 AD1 IO55
34 95
XTAL1 PF2/ADC2 AD2 AD2 IO56
33 94
XTAL2 PF3/ADC3 AD3 AD3 IO57
93
PF4/ADC4/TCK AD4 AD4 IO58
78 92
IO22 PA0/AD0 PF5/ADC5/TMS AD5 AD5 IO59
77 91
IO23 PA1/AD1 PF6/ADC6/TDO AD6 AD6 IO60
76 90
IO24 PA2/AD2 PF7/ADC7/TDI AD7 AD7 IO61
75
IO25 PA3/AD3 AD8 IO62
74 51
IO26 PA4/AD4 PG0/WR IO41 AD9 IO63
73 52
IO27 PA5/AD5 PG1/RD IO40 AD10 IO64
72 70
IO28 PA6/AD6 PG2/ALE IO39 AD11 IO65
71 28
IO29 PA7/AD7 PG3/TOSC2 AD12 IO66
29
PG4/TOSC1 AD13 IO67
19 1
IO53 PB0/SS/PCINT0 PG5/OC0B IO4 AD14 IO68
16
15
14
13
12
10
11
20
9
IO52 PB1/SCK/PCINT1 AD15 IO69
21 12
IO51 PB2/MOSI/PCINT2 PH0/RXD2 IO17
IO50
22
PB3/MISO/PCINT3 PH1/TXD2
13
IO16 IO14 TXD3 RN1
23 14 330
IO10 PB4/OC2A/PCINT4 PH2/XCK2 IO15 RXD3
24 15
IO11 PB5/OC1A/PCINT5 PH3/OC4A IO6 IO16 TXD2
25 16
IO12 PB6/OC1B/PCINT6 PH4/OC4B IO7 IO17 RXD2
10
12
26 17 PORTA U2:C U2:D U2:E U2:F
8
IO13 PB7/OC0A/OC1C/PCINT7 PH5/OC4C IO8 IO18 TXD1
1
2
3
4
5
6
7
8
18 74HC07 74HC07 74HC07 74HC07
PH6/OC2B IO9 IO19 RXD1 IO22
53 27
IO37 PC0/A8 PH7/T4 IO20 SDA IO23
54
IO36 PC1/A9 IO21 SCL IO24
55 63
IO35 PC2/A10 PJ0/RXD3/PCINT9 IO15 IO53 SS IO25
11
13
56 64
IO34 PC3/A11 PJ1/TXD3/PCINT10 IO14 IO51 MOSI IO26
57 65
IO33 PC4/A12 PJ2/XCK3/PCINT11 IO50 MISO IO27
58 66
IO32 PC5/A13 PJ3/PCINT12 IO52 SCK IO28
59 67
IO31 PC6/A14 PJ4/PCINT13 IO1 TXD IO29
60 68 LS1
IO30 PC7/A15 PJ5/PCINT14 IO0 RXD
69
PJ6/PCINT15
43 79
IO21 PD0/SCL/INT0 PJ7 +5V
44 PUP
IO20 PD1/SDA/INT1
45 89
IO19 PD2/RXD1/INT2 PK0/ADC8/PCINT16 AD8
46 88
3
IO18 PD3/TXD1/INT3 PK1/ADC9/PCINT17 AD9 IO13
47 87 PORTL
PD4/ICP1 PK2/ADC10/PCINT18 AD10 IO37 SPEAKER
48 86
49
PD5/XCK1
PD6/T1
PK3/ADC11/PCINT19
PK4/ADC12/PCINT20
85
AD11
AD12
IO42
IO43
A
1 2 3
50 84 PENTER
IO38 PD7/T0 PK5/ADC13/PCINT21 AD13 IO34 IO44
83
PK6/ADC14/PCINT22 AD14 IO33 IO45
2 82
IO0
IO1
3
PE0/RXD0/PCINT8/PDI PK7/ADC15/PCINT23
PE1/TXD0/PDO
AD15
RESET
IO32
IO31
IO46
IO47
B
4 5 6
4 35
PE2/XCK0/AIN0 PL0/ICP4 IO49 IO30 IO48
5 36
IO5 PE3/OC3A/AIN1 PL1/ICP5 IO48 IO49
6 37 PORTC
IO2
IO3
7
PE4/OC3B/INT4
PE5/OC3C/INT5
PL2/T5
PL3/OC5A
38
IO47
IO46
PL0
C
7 8 9
8 39
PE6/T3/INT6 PL4/OC5B IO45
9 40
PE7/ICP3/CLKO/INT7 PL5/OC5C IO44 LED & Reset
41
AREF
98
AREF
PL6
PL7
42
IO43
IO42
D
0 #
100 PDOWN
+5V AVCC
Arduino Mega 2560
U3 U4
U2:A U2:B 7 3 7 3
WC E2 WC E2
5 2 5 2
SDA E1 SDA E1
1 2 3 4 R9 R10 6
SCL E0
1 6
SCL E0
1
SDA_out M24C01 M24C01

IO5 74HC07 74HC07
SCL_out
IO4
SDA
IO3
SCL
IO2
GND
VCC
1
2
3
4
GND
VCC
SCL
SDA
TXD RXD
VT52, VT100, ANSI
RXD TXD
RTS
Xmodem, Ymodem, Zmodem
CTS
LCD1
OLED12864I2C
7.1 Tarea 1. Salidas digitales

Hacer un programa para que haga parpadear (encender y apagar) todos los segmentos del dígito de
las unidades (D4) durante 2 segundo, aproximadamente. Luego hacer que el parpadeo pase de
forma secuencial al resto de los dígitos:
Unidades-D4 (parpadeo2 seg)decenas-D3 (parpadeo 2 seg) centenas-D2 (parpadeo2
seg)millares-D1 (parpadeo2 seg)  unidades-D4 (parpadeo2 seg) y así sucesivamente.
Al cambiar de dígito, generar una señal acústica para avisar al usuario. Tiene completa libertad para
elegir la duración y la frecuencia del pitido (o señal acústica) que se oirá por el zumbador/altavoz.
7.2 Tarea 2. Comunicación serie

Uso de las comunicaciones serie (TX0/RX0). Aprovechando el código de las tareas anteriores,
escribir un nuevo programa consistente en presentar al usuario un menú en el "monitor serie" del
entorno de programación Arduino (Herramientas->Monitor Serie) con al menos 6 opciones con las
que podamos seleccionar una de las siguientes acciones (el carácter inicial a visualizar en los dígitos
del display será todos los segmentos encendidos):
1. Parpadeo de las unidades
2. Parpadeo de las decenas
3. Parpadeo de las centenas
4. Parpadeo de las unidades de millar
5. Parpadeo secuencial con todos los dígitos (tarea1)
6. Selección del carácter hexadecimal (0-F) a visualizar en el display
Entrar opción:
7.3 Tarea 3. Sincronización por consulta de estado

Realizar un contador electrónico de dos dígitos (decenas-unidades) que se actualiza dependiendo
del pulsador que se pulse: pulsador “pup” incrementa en una unidad, pulsador “pdown” decrementa
en una unidad y pulsador"pcenter" inicializa a “0”. La detección de la pulsación se ha de hacer por
consulta de estado. Si estando el contador a 00 se pulsa el pulsador “pdown” el contador ha de
cambiar a 99. Si con este último valor se pulsa “pup” el contador deberá regresar a 00. Cada vez
que cambie el estado del contador ha de oírse un pitido corto por el zumbador.
En este apartado se deberá afrontar la complejidad adicional de mostrar varios dígitos
simultáneamente en el visualizador. Para ello, es necesario de un mecanismo de visualización
“entrelazada” en el que se va alternando la visualización de las unidades y las decenas a una cierta
frecuencia (100Hz, 10ms). Por ejemplo: en el primer ciclo (10 ms), se visualizan las unidades y se
apagan las decenas; en el segundo ciclo, se apagan las unidades y se encienden las decenas; en el
tercer ciclo se visualizan las unidades y se apagan las decenas y así, sucesivamente. Si el
entrelazado se hace lentamente, se observa un parpadeo en el visualizador. Sin embargo, a partir de
una cierta frecuencia se ve estático porque el ojo humano no es capaz de apreciar la conmutación
entre dígitos. A continuación, se muestra la estructura general del programa que le puede ayudar a
realizar este apartado:
boolean estado=false;
Setup(): Inicialización
Loop(): Programa principal {
Leer pulsadores y actualizar variables del contador
If (estado) then {
Apagar decenas, encender y visualizar unidades
Delay 10 ms}
Else {
Apagar unidades, encender y visualizar decenas
Delay 10 ms }
estado = !estado;
}
7.4 Tarea 4. Visualización sincronizada por interrupción externa

El objetivo de esta tarea es que la visualización de los dígitos del contador de la tarea anterior, la
realice una subrutina de servicio de interrupción, de forma sistemática, cada 10 ms. Para ello,
generaremos una interrupción de tipo externa cada 10 ms (frecuencia 100 Hz). Utilice un generador
de señal y, ajústelo adecuadamente, para obtener la señal especificada y utilícela para generar una
interrupción externa de nivel 2 por el pin 19 de la tarjeta Arduino.
Veamos cuál sería la estructura general de un programa para habilitar y tratar estas interrupciones
adecuadamente. Para más información consultar la documentación de las clases de teoría.
// Declaración de variables volátiles

// Las variables que se modifiquen en ISR() y se utilicen
// fuera de ISR() han de declararse “volatile”
// ejemplo:
volatile boolean estado;
// función de setup()
void setup(){
// Habilitación de la interrupción INT2, flanco de subida (rising)
cli();
EICRA |= (1<<ISC21) | (1<<ISC20);
EIMSK |= (1<<INT2);
sei();
}
ISR (INT2_vect) {
// Rutina de servicio para la visualización entrelazada
// en el display de 4 dígitos de 7-segmentos
…
}
void loop(){
...
}
Para implementar la visualización entrelazada se procederá de forma que, la primera vez que se
interrumpa, la ISR() de la interrupción INT2 apagará el dígito de las decenas y activará el dígito de
las unidades (solo se visualizaría las unidades del contador); en la segunda interrupción, la ISR()
apagará el dígito de las unidades y activará el dígito de las decenas (solo se visualizará las decenas
del contador) y así, sucesivamente, de forma alternada cada 10 ms entre unidades y decenas.
Observe que, si baja la frecuencia del generador de señal el display parpadeará y podrá observar el
funcionamiento de la visualización entrelazada.
Además de la funcionalidad anterior, se han de implementar las siguientes:

a) Mostrar en la pantalla del PC (o en el terminal virtual de Proteus) el siguiente menú de opciones
para poder elegir una de las acciones mostradas:
1.- Mostrar el contador en los dos dígitos inferiores del display (decenas-unidades)
2.- Mostrar el contador en los dos dígitos superiores del display (millares-centenas)
Elegir opción:
b) Añadir la funcionalidad de que cuando se pulse el pulsador “pright” el contador se incremente o
decremente de dos en dos.
c) Añadir la funcionalidad de que cuando se pulse el pulsador “pleft” el contador se incremente o
decremente de uno en uno.
7.5 Tarea 5. Sensor de temperatura (opcional, mejora)

Como mejora se sugiere la conexión al sistema de un sensor de temperatura a través de un canal
analógico y que, cada cierto tiempo (1 o 2 segundos), vuelque a la pantalla del PC (o al terminal
virtual de Proteus) la temperatura actual. También podría optar por visualizar la temperatura en el
propio display de 7 segmentos alternando entre el valor del contador y la temperatura, como lo hace
cualquier panel de información. Escoja de las librerías de componentes de Proteus el que le resulte
más adecuado o consulte con el equipo docente.
8 Defensa y entrega del informe de práctica

Una vez realizadas cada una de las tareas planteadas, se subirá al Campus Virtual de la asignatura el
proyecto Proteus (*.pdsprj) de cada una de ellas con el código del programa convenientemente
documentado. El conjunto de los proyectos será el informe de la práctica cuya calificación supone
el 10% de la calificación de la práctica. En la sección de la práctica del Campus Virtual habrá un
enlace para subir los proyectos. Según lo comentado, para esta práctica se subirán un total de
cuatro o cinco ficheros (o proyectos), uno por cada tarea realizada. En cuanto a los nombres de los
ficheros se ha de seguir la siguiente nomenclatura:
"nº práctica_nº tarea_Iniciales de nombre-apellidos.pdsprj"
Ejemplo:
p1a_tarea2_amf.pdsprj
Fichero correspondiente al informe de la práctica 1a, tarea 2 entregado por Anabel Medina Falcón.
La presentación de los informes fuera de plazo implica que el estudiante pierde dicha puntuación.
Una vez transcurrido el plazo para la realización de la práctica, y en hora convenida, se realizará un
control práctico (prueba, cuestionario, …) relativo a las actividades que habrá tenido que desarrollar
durante la realización de la práctica.

21-22 PI Prac1a Enunciado

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

21-22 PI Prac1a Enunciado

Cargado por

Copyright:

Formatos disponibles

ESCUELA DE INGENIERÍA INFORMÁTICA

Grado en Ingeniería Informática

Interfaces paralelos en el µC ATmega 2560

Última actualización: 14 septiembre 2021

1 Competencias y objetivos de la práctica

GII: 40964-Periféricos e Interfaces 4

4. Capacidad para aprender y aplicar nuevos conceptos de forma autónoma e interdisciplinar.

3 Introducción a la plataforma hardware de prácticas

Figura 1. Arduino Mega 2560 + tarjeta de expansión

4 Descripción general de la tarjeta Arduino Mega 2560

Figura 2. Componentes básicos de la tarjeta Arduino Mega 2560

El componente más importante de la tarjeta es el microcontrolador ATmega 2560 de 100 patas (o

En la figura3 se muestra un diagrama de bloques del microcontrolador AT mega 2560 donde se

Figura 3. Diagrama de bloques del microcontrolador ATmega 2560

Figura 4. Encapsulado y patillaje (pines) del microcontrolador de 8 bits ATmega 2560

4.2 Entradas/salidas en la tarjeta Arduino Mega 2560

Figura 5. Tarjeta Arduino Mega 2560 (microcontrolador ATmega2560)

Figura 6. Multifuncionalidad de los pines del Arduino Mega 2560

4.2.1 Entradas/salidas digitales de propósito general

4.2.1.1 Registros internos del interfaz de un puerto

Registro DDRxn: Port x Data Direction Register

Ejemplo para puerto A de 8 bits (PA[7:0])

PORTx: Port x Data Register

PORTxn de entrada PORTxn de salida

PINx: Port x Input Pins

Figura 7. Registros asociados al PA (puerto A): PORTA, DDRA y PINA

4.2.1.2 Funciones Arduino para el manejo de las entradas/salidas digitales

Las funciones básicas son:

// Poner un pin a "1" (HIGH) o a "0" (LOW)

// Leer el estado de un pin

4.2.2 Puertos de comunicación serie

4.2.2.1 Interfaz de las comunicaciones serie

Figura 8. Registros asociados al interfaz de una USARTn

Figura 9. Transmisión serial de datos

4.2.2.2 Funciones Arduino para la comunicación serie

a) Configuración de un canal serie: velocidad y protocolo

speed: 2400, 4800, 9600, ... 115200 (baudios o bits/seg)

b) Transmisión de datos por el canal serie

c) Recepción de datos por el canal serie

d) Deshabilitación del canal serie

4.2.3 Salidas de control de potencia (PWM)

Figura 10. Señal de control de potencia PWM (Pulse Width Modulation)

4.2.3.1 Funciones Arduino para la generación de señales PWM

4.2.4 Entradas analógicas (A0-A15)

Figura 11. Conversión analógica-digital de una señal

Uso de las líneas analógicas como puertos de entrada y salida digitales

4.2.4.1 Funciones Arduino para las entradas analógicas

4.2.5 Líneas de alimentación y reset

4.3 Sistema de interrupciones del microcontrolador ATmega 2560

Address Code Comments

Operaciones básicas en el uso de las interrupciones

4.3.1 Configuración y habilitación de interrupciones externas

SEI: Habilita interrupciones (I=1)

4.3.1.1 Interrupciones externas de tipo INTn

Interrupción externa Pin

EXTERNAL INTERRUPT CONTROL REGISTER A (EICRA)

Permite configurar el funcionamiento de las interrupciones INT3-0 de acuerdo a la siguiente tabla:

EXTERNAL INTERRUPT CONTROL REGISTER B (EICRB)

Permite configurar el funcionamiento de las interrupciones INT7-4 de acuerdo a la siguiente tabla:

EXTERNAL INTERRUPT MASK REGISTER (EIMSK)

EXTERNAL INTERRUPT FLAG REGISTER (EIFR)

4.3.1.2 Interrupciones externas de tipo PCINTn