Práctica 3 de Arduino:

Calculadora
Prof. Victor Manuel Fuentes Olivares
[email protected]

Nombre del estudiante:

1. ___________________________________

Contenido
• Introducción
• Objetivos
• Actividades
• Evaluaciones
• Conclusiones

Introducción

Microcontroladores programables.
Un microcontrolador contiene toda la estructura (arquitectura) de un sencillo pero completo
computador contenidos en el corazón (chip) de un circuito integrado. Los resultados de tipo
práctico, que pueden lograrse a partir de estos elementos, son sorprendentes.

Se trata de un circuito integrado de alta escala de integración que incorpora la mayor parte de los
elementos que configuran un controlador. Se dice que es “la solución en un chip” porque su
reducido tamaño minimiza el número de componentes y el coste.

Los componentes de los que dispone normalmente un microcontrolador son:

 Procesador o UCP (Unidad central de proceso).

 Memoria RAM para contener los datos.
 Memoria para el programa tipo ROM/PROM/EPROM.
 Líneas de E/S para comunicarse con el exterior.
 Diversos módulos para el control de periféricos (Temporizadores, puertas serie y paralelo,
CAD, etc.)
 Generador de impulsos de reloj que sincronizan el funcionamiento de todo el sistema.

Fig. Estructura típica de un microcontrolador.

Según el modelo de microcontrolador que se trate, el tamaño y el tipo de memoria pueden diferir,
así como el número de líneas de E/S y los módulos de control de periféricos. La diversificación de
modelos permite seleccionar el más adecuado según la aplicación de que se trate. Una estructura
interna fija supone una limitación, que se convierte en una ventaja en el caso de que en un simple
circuito integrado residan todos los componentes que necesita el controlador.

La única limitación que tienen las aplicaciones de los microcontroladores actuales está en la
imaginación del diseñador. Los campos más destacados en los que se emplean
microcontroladores son los siguientes:

 Automatización industrial.
 Medida y control de procesos.
 Enseñanza e investigación.
 Periféricos y dispositivos auxiliares de las computadoras.
 Electrodomésticos.
 Aparatos portátiles y de bolsillo.
 Máquinas expendedoras y juguetería.
 Instrumentación.
 Industria de la automoción.
 Electromedicina.
 Robótica.
 Sistemas de navegación.
 Sistemas de seguridad y alarma.
  Domótica.
 Termorregulación.

La industria de la informática acapara gran parte de los microcontroladores que se fabrican. Casi
todos los periféricos de un ordenador, desde el ratón hasta la impresora o el teclado, son regulados
por el programa de un microcontrolador.

Los electrodomésticos de gama blanca (lavadoras, hornos, lavavajillas, etc.) y de línea marrón
(televisores, vídeos, aparatos musicales, etc.) incorporan numerosos microcontroladores.
Igualmente, los sistemas de supervisión, vigilancia y alarma en los edificios utilizan estos chips
para optimizar el rendimiento de ascensores, calefacción, aire acondicionado, alarmas de incendio
y robo, etc.

Las comunicaciones y sus sistemas de transferencia de información utilizan profusamente estos

pequeños computadores, incorporándolos en los grandes automatismos y en los modernos
teléfonos.

La instrumentación y la electromedicina son dos campos idóneos para la implantación de estos

circuitos integrados. Una importante industria consumidora de microcontroladores es la de
automoción, que los aplica en el control de aspectos tan populares como la climatización o los
frenos ABS.

Tipos de memoria en Arduino

Existen tres tipos de memoria en los micro-controladores Arduino: memoria Flash,
memoria SRAM y memoria EEPROM. (Memorias tipo AVR compatibles con toda la gama de
Arduino excepto Arduino DUE, que utiliza otro tipo de arquitectura)

La configuración de Harvard resulta ser una buena elección para las aplicaciones embebidas y el
chip Atmega 328 usado en el UNO de Arduino utiliza una arquitectura relativamente pura de
Harvard. 
Los programas se almacenan en la memoria Flash y los datos se almacenan en SRAM.

El resto de componentes de la placa Arduino sirven para regular voltajes, su gestión en las
diferentes salidas, y conexiones y buses que interconectan otros componentes para la
comunicación.

A continuación, se pueden ver las características de los diferentes tipos de memoria más utilizadas.

Memoria Características

RAM Se pueden leer y escribir, pero son volátiles

DRAM Dynamic Random Access Memory, Son las memorias típicas de los PCs. Se

construyen a base de condensadores y se pueden integrar cantidades ingentes de
Memoria Características

ellas en un único chip de forma barata. A cambio tiene que ser refrescadas cada
poco, lo que complica el diseño con mecanismos de refresco de la memoria ( Por
supuesto fuera de los ojos del orgullosos propietario)

 Synchronous Dynamic Random-Access Memory. Como las DRAM, pero el

SDRAM
mecanismo de refresco es síncrono

Double Data Rate Synchronous Dynamic Random Access Memory. Estas son las

DDR actuales memorias utilizadas en los PCS de sobremesa. Actualmente están en la
versión DDR4

ROM Read Only Memory, son no volátiles, pero solo se pueden leer, no escribir.

Programable Read Only Memory No son volátiles y se pueden escribir y reescribir

PROM
en unos equipos especiales. Hoy prácticamente están en desuso

Electically Erasable Programable Read only Memory Son igual que las PROM,
pero con la curiosidad que se pueden reescribir eléctricamente lo que evita el
EEPROM
engorro de llevarlas a reprogramar a maquinas raras. A cambio son lentas de
escribir y tienen un número limitado de escrituras antes de morir.

Es un derivado de la EEPROM, con varias ventajas, la principal es que no pierde

la información cuando le quitamos la corriente y además pueden leerse y
FLASH
escribirse sobre la marcha. El inconveniente es que son lentas. Es la clase de
memoria que se utiliza para fabricar las memorias USBs pendrives y demás

Diagrama de bloques de un microcontrolador:

Diagrama de bloques simplificado de un microcontrolador. Se compone de tres bloques

fundamentales: la CPU (central Processing Unit), memoria (RAM y ROM) y las entrada y salidas.
Los bloques se conectan entre sí mediante grupos de líneas eléctricas denominadas buses o
pistas. Los buses pueden ser de direcciones (si transportan direcciones de memoria o entrada y
salida), de datos (si transportan datos o instrucciones) o de control (si transportan señales de
control diversas).
La CPU es el cerebro central del microprocesador y actúa bajo control del programa almacenado
en la memoria. La CPU se ocupa básicamente de traer las instrucciones del programa desde la
memoria, interpretarlas y hacer que se ejecuten. La CPU también incluye los circuitos para realizar
operaciones aritméticas y lógicas elementales con los datos binarios, en la denominada Unidad
Aritmética y Lógica (ALU: Aritmetic and Logic Unit).

En un registro interno del microcontrolador se encuentran 5 opciones diferentes de reloj que son
seleccionadas por medio de un Multiplexor.

La señal de reloj es distribuida por la unidad de control a los diferentes bloques existentes: la CPU,
las memorias, los módulos de entrada/salida, los contadores/timers, el SPI y la USART, al igual
que el conversor Análogo Digital ADC.

Memoria Flash (espacio del programa) en Arduino:

La memoria Flash (espacio del programa) es donde Arduino almacena el sketch. Un sketch es el

nombre que usa Arduino para un programa. Es la unidad de código que se sube y ejecuta en la
placa Arduino. Esta memoria es no volátil, si Arduino deja de ser alimentado eléctricamente los
datos que haya en esta memoria permanecerán. 

El tamaño de la memoria Flash de Arduino puede variar dependiendo del microcontrolador, aunque
no es muy grande. Por ejemplo, para el chip ATmega168 el tamaño de la memoria Flash es de 16
kilobytes, de los cuales 2 kilobytes son utilizados por el bootloader. Para el caso del
microcontrolador ATmega328 (como el que incorpora Arduino UNO) el tamaño de la memoria
Flash es de 32KB, de los cuales el bootloader usa 0,5KB. Por lo que debemos desarrollar los
programas de forma muy optimizada, usando los tipos de variables que menos memoria requieran,
en la medida de lo posible. También debemos optimizar el código fuente de la aplicación para no
repetir líneas de código.
La memoria flash se utiliza para almacenar la imagen del programa y cualquier información
inicializada. Puede ejecutar código de programa desde flash, pero no puede modificar los datos en
la memoria flash de su código de ejecución. Para modificar los datos, primero se debe copiar en
SRAM.

La memoria flash es la misma tecnología utilizada para las unidades de pulgar y tarjetas SD.  

La memoria Flash tiene una vida útil limitada de unos 100.000 ciclos de escritura. Así que, si subes
10 programas al día, todos los días durante los próximos 27 años, podrías agotarlo.

En un dispositivo simple, como un microcontrolador, es un desafío implementar un asignador de

memoria dinámica que sea lo suficientemente simple para que los requisitos de tamaño de código
se mantengan bajos, pero lo suficientemente potente como para evitar la fragmentación de
memoria innecesaria y para hacer todo con unos ciclos de CPU razonablemente bajos. Los
microcontroladores a menudo son bajos en el espacio y también funcionan a velocidades mucho
más bajas que la PC típica en estos días.

El asignador de memoria implementado en avr-libc intenta hacer frente a todas estas restricciones,
y ofrece algunas opciones de ajuste que se pueden usar si hay más recursos disponibles que en la
configuración predeterminada.

Cuando se utiliza la asignación de memoria dinámica y la pila y el montón se separan en distintas

áreas de memoria, esta es la forma más segura de evitar una colisión de pila.

Memoria SRAM (Static Random Access Memory ó memoria estática de acceso aleatorio) en
Arduino

La memoria SRAM (Static Random Access Memory ó memoria estática de acceso aleatorio) es de

tipo volátil, es el espacio donde los sketches (programas) almacenan y manipulan variables al
ejecutarse. La información guardada en esta memoria será eliminada cuando Arduino pierda la
alimentación. Esta memoria es de uso exclusivo para el programa en ejecución.

La memoria SRAM de Arduino es muy pequeña, por lo que debemos optimizar nuestros programas
al máximo y no abusar de variables de tipo char muy grandes. Hay que tener en cuenta que cada
carácter de una variable char utiliza un byte. En el microcontrolador ATmega 168 el tamaño de la
memoria SRAM es de 1024 bytes, para el caso de un chip ATmega328 (como el que incorpora
Arduino UNO) el tamaño es de 2KB (2048 bytes). 
Si la SRAM se queda sin espacio, el programa de Arduino fallará de forma imprevista, aunque se
compile y se suba a Arduino correctamente la aplicación no se ejecutará o se ejecutara de manera
extraña.

Variables locales, datos parciales. Usualmente se trata como banco de registros (PIC), Memoria
volátil. Donde el sketch crea y manipula las variables cuando se ejecuta.

La memoria SRAM se utiliza para varios propósitos por un programa en ejecución:

Datos estáticos - Este es un bloque de espacio reservado en SRAM para todas las variables
globales y estáticas de su programa. Para las variables con valores iniciales, el sistema de
ejecución copia el valor inicial de Flash cuando se inicia el programa.
Heap - El montón es para elementos de datos asignados dinámicamente. El montón crece desde la
parte superior del área de datos estáticos hasta que se asignan los elementos de datos.
Stack - La pila es para variables locales y para mantener un registro de interrupciones y llamadas
de función. La pila crece desde la parte superior de la memoria hacia abajo hacia el montón. Cada
interrupción, llamada de función y / o asignación de variable local hace que la pila crezca. Al
regresar de una llamada de interrupción o de función, se recuperará todo el espacio de pila
utilizado por esa interrupción o función.

Memoria EEPROM en Arduino

EEPROM es un espacio de memoria que puede ser utilizado por los programadores para
almacenar información a largo plazo. Este tipo de memoria es no volátil, por lo que los datos
guardados en ella permanecerán, aunque Arduino pierda la alimentación. Esta memoria puede ser
usada para guardar valores si es necesario. 

El tamaño de la EEPROM para un chip ATmega128 es de 512 bytes, para un chip ATmega328 es
de 1KB (1024 bytes). Hay que tener en cuenta que el tamaño de la memoria EEPROM interna de
Arduino es "pequeño" pero Arduino admite añadir módulos de memoria EEPROM externa de
mayor tamaño.
Se puede grabar desde el programa del microcontrolador. Usualmente, constantes de programa.
Memoria no volátil para mantener datos después de un reset. Las EEPROMs tienen un número
limitado de lecturas/escrituras.
Una desventaja de la memoria EEPROM es que es mucho más lenta que la memoria SRAM. El
proceso de escritura de una celda (byte) cuesta en torno a 3.3 ms. El proceso de lectura es mucho
más rápido (aunque sigue siendo más lento que la SRAM), leer 1024 bytes cuesta en torno a
0.3ms, es decir, 10.000 veces más rápida que la escritura.

Objetivos
• Utilizar dispositivos los puertos de entrada y salida de Arduino como
interfaz de datos para controlar la información que aparece en un display.
• Analizar el bus de datos de Arduino como instrumento de análisis para el envió de
información.
• Comprender la dificultad de obtener resultados esperados si se desconocen las
características técnicas de los dispositivos.

Lista de Materiales
 Simulador PROTEUS
 potenciómetro (resistencia variable). O resistencia de 1Kohm
 Datasheet de Teclado matricial
 Datasheet Display
Actividades:

1.- Abrir Proteus ISIS

2.- Ubicar el menú DEVICES (P)

3.- Agregar Arduino

4.- Agregar un display LM016L

5.- Agregar un Teclado matricial (KEYPAD-SMALLCALC)

NOTA: En caso de no aparecer la librería, solicitar al profesor los archivos para agregarla.
6.- Agregar un potenciómetro (Resistencia Variable): POT DEVICES

7.- Armar el circuito

8.- Abrir programa Arduino y crear un sketch para calculadora

Nota: Antes de crear el sketch, entrar al menú Archivo>Preferencias y activar la opción

compilación

Dejo el código para copia:

#include <Keyboard.h>

#include <Keyboard.h>

#include <Keypad.h>
#include <LiquidCrystal.h>

const byte ROWS = 4;

const byte COLS = 4;

char hexaKeys[ROWS][COLS] = {
{'1', '2', '3', '-'},
{'4', '5', '6', '*'},
{'7', '8', '9', '/'},
{'X', '0', '=', '+'}
};

byte rowPins[ROWS] = {3, 2, 1, 0};

byte colPins[COLS] = {7, 6, 5, 4};

LiquidCrystal lcd(9, 8, 10, 11, 12, 13);

Keypad myKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);

boolean valorActual = false;

boolean siguiente = false;
boolean final = false;
String num1, num2,num3;
int total;
int movimiento;
char op;

void setup(){
lcd.begin(16,2);
lcd.setCursor(0,0);
lcd.print("@Unitec");
lcd.setCursor(0,1);
lcd.print("@Calculadora");
delay(2500);
lcd.clear();
}

void loop(){
char key = myKeypad.getKey();
if (key != NO_KEY && (key=='1'||key=='2'||key=='3'||key=='4'||key=='5'||key=='6'||key=='7'||key=='8'||key=='9'||key=='0')){
if (valorActual != true){
num1 = num1 + key;
int numLength = num1.length();
movimiento = numLength;
lcd.setCursor(0, 0);
lcd.print(num1);
}
else {
num2 = num2 + key;
int numLength = num2.length();
lcd.setCursor(movimiento+1, 0);
lcd.print(num2);
final = true;
}
}

else if (valorActual == false && key != NO_KEY && (key == '/' || key == '*' || key == '-' || key == '+')){
if (valorActual == false){
valorActual = true;
op = key;
lcd.setCursor(movimiento,0);
lcd.print(op);
}
}

else if (final == true && key != NO_KEY && key == '='){

if (op == '+'){
total = num1.toInt() + num2.toInt();
}
else if (op == '-'){
total = num1.toInt() - num2.toInt();
}
else if (op == '*'){
total = num1.toInt() * num2.toInt();
}
else if (op == '/'){
if(num2.toInt()==0){
total = ' ';
}else{
total = num1.toInt() / num2.toInt();
}
}
num3=String(total);
lcd.clear();
 lcd.setCursor(15,0);
lcd.autoscroll();
if(total==' '){
lcd.print("Sintax Error");
}else if(num3.length()>4){
lcd.print("No hay memoria");
}else{
lcd.print(total);
}
lcd.noAutoscroll();
}
else if (key != NO_KEY && key == 'X'){
lcd.clear();
valorActual = false;
final = false;
num1 = "";
num2 = "";
total = 0;
op = ' ';
}
}

9.- Guardar el archivo como: practica 3 calculadora arduino

10.- Regresar al circuito de la calculadora en Arduino y abrir las propiedades

11.- Ubicar la opción Program File y buscar en la carpeta temporales el archivo

practica_3_calculadora_arduno.ino.hex, abrimos el archivo y posterior damos OK.

12.- Ejecutamos Play en Proteus, debe aparecer la siguiente pantalla de simulación, probar el
funcionamiento con operaciones básicas
Nota: El programa acepta valores y da resultados máximos de 4 dígitos y solo números
enteros.

13- Llenar la siguiente tabla para determinar el tiempo de ejecución del programa.

No. operaciones No. Ciclos Frecuencia Tiempo de Ejecución

Nota: Cuando el microcontrolador ejecuta una instrucción que definimos en el sketch, internamente
hace muchas operaciones y cada una de esas operaciones se ejecuta en un ciclo de reloj. Para el
ATmega 328p que tiene una frecuencia de 16 MHz, es decir, cada ciclo tarda 0,0000000625
segundos = 0,0625 microsegundos = 62,5 nanosegundos

Frecuencia=ciclos/tiempo

Tiempo=ciclos/frecuencia

14.- Revisa cual es el tamaño del archivo creado en Arduino y comenta donde se guarda el archivo
de acuerdo con la arquitectura Harvard.

Nota: Para revisar debes compilar el código Arduino y revisar los resultados

Ejemplo:
15.- De acuerdo con el siguiente esquema, comenta cual fue el proceso ejecutado por el bus de
datos para crear el letrero en Arduino.

Preguntas de evaluación: Lea la introducción de la práctica y conteste

1.- ¿De qué depende el tamaño y el tipo de memoria de un microcontrolador?

2.- ¿Cuáles son los tres tipos de memoria en un microcontrolador?

3.- ¿Cuál es la diferencia entre arquitecturas AVR y DUE en los microcontroladores?

4.- ¿Cuál es la memoria que permite reescribir eléctricamente, es lenta de escribir y tienen un
número limitado de escrituras?

5.- ¿Cuál es el tamaño de la EEPROM para un chip ATmega328?

Conclusiones:

Fuentes de información o consulta: