Programación de puertos E/S

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERÚ
FACULTAD DE CIENCIAS E INGENIERÍA

SECCIÓN ELECTRICIDAD Y ELECTRÓNICA
LABORATORIO 2
PROGRAMACIÓN EMPLEANDO PUERTOS DE E/S
I. OBJETIVO
• Aprender a desarrollar programas elementales en lenguaje C para programar los puertos de E/S
del microcontrolador TM4C123GH6PM.
II. MATERIALES
• Computadora personal
• Entorno de desarrollo Keil uVision 4.74
• Módulo de desarrollo Tiva Launchpad EK-TM4C123GXL de Texas Instruments.
• 1 cable de extensión USB.
III. PROCEDIMIENTO
Mediante 3 proyectos desarrollados se practicará con el entorno IDE Keil uVision 4.74 para aprender a
programar el microcontrolador TM4C123GH6PM de la tarjeta Tiva Launchpad.
• El primer proyecto consiste en desarrollar un programa que calcule el menor de tres números
ingresados con los pulsadores y el promedio de los dos mayores, haciendo uso de la librería
TivaES.
• El segundo proyecto consiste en alternar el color del led RGB (rojo, verde y azul) cada vez que se
pulse tres veces el pulsador SW2.
• El tercer proyecto consiste en generar un número aleatorio y mostrarlo en el led RGB del Tiva
Launchpad.
IV. KEIL uVISION 4.74 IDE y LIBRERÍA TivaES
a) Circuito esquemático simplificado b) Módulo Tiva LaunchPad EK-TM4C123G
Fig.1 Diagrama de conexiones del TM4C123GH6PM en el Tiva Launchpad
El módulo de desarrollo Tiva Launchpad EK-TM4C123GXL posee periféricos conectados directamente al

procesador central, el microcontrolador TM4C123GH6PM, tal como se puede apreciar en la figura 1a,
donde se muestran tres leds (rojo, verde y azul) unidos físicamente en un solo componente vista en la
figura 1b (RGB user LED), asimismo, se observan dos pulsadores SW1 y SW2 en la parte inferior del
módulo y un pulsador de Reset en la parte superior.
En la figura 1a, se observa que tanto los pulsadores como los leds se encuentran físicamente conectados
a algunos pines del puerto F; específicamente: PF4, PF0 (pulsadores SW1 y SW2) y PF1, PF2 y PF3 (leds
rojo, azul y verde respectivamente).
IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 1

En esta etapa del curso controlaremos dichos periféricos haciendo uso de una librería precompilada, la
librería TivaES, que contiene procedimientos y funciones ya probadas para el control del led RGB y los
pulsadores SW1 y SW2, mediante la manipulación del puerto F.
Creación de un proyecto en Keil uVision 4.76 utilizando librería TivaES
Utilice los mismos pasos que los mencionados en la guía 1 del curso para crear el proyecto.
Fig.2 Creación de un proyecto nuevo (Lab2_ejemplo1) en Keil uVision
Con fines de orden, podemos crear un nuevo grupo de archivos fuente. Ver figura 3.
Fig. 3 Crear un nuevo grupo de archivos fuente para la librería TivaES
Podemos cambiar el nombre de grupo creado haciendo clic izquierdo sostenido sobre el nombre y
editándolo.

Fig. 4 Edición del nombre del grupo creado
Como parte de la experiencia se les hará llegar los archivos TivaES.h y TivaES.obj, los cuales deberán
copiarlos a la carpeta actual del proyecto. Lo que sigue es simplemente añadir dichos archivos al proyecto,
en el nuevo grupo creado. Luego de añadir dichos archivos, su proyecto deberá quedar:
Fig. 5 Proyecto en Keil uVision 4 con librería TivaES añadida
La implementación de la librería TivaES se da en dos archivos: TivaES.h y TivaES.obj. El archivo

TivaES.h contiene las definiciones y declaraciones necesarias para utilizar la librería, mas no contiene el
código fuente que especifica los procedimientos a seguir para realizar la tarea. El código máquina
necesario para realizar la tarea en el Tiva se encuentra en el archivo TivaES.obj. Es por ello que es muy
importante que AMBOS archivos se incluyan en nuestro proyecto.
Nótese que se incluye el archivo objeto (código máquina) mas no el archivo fuente (codigo C) al proyecto,
haciendo que su uso sea transparente al usuario. Es decir, que no conocemos y no tenemos porque saber
cómo la librería realiza específicamente su trabajo, simplemente la invocamos y la tarea se realiza.

La inspección del archivo TivaES.h nos lleva a un listado rápido de las tareas que permite realizar la
librería, una descripción del funcionamiento de cada una de ellas (comentarios) y los argumentos con los
que trabaja (mediante el análisis de la declaración o prototipo de la función).
Por ejemplo, la figura 6 muestra la declaración de la función TivaES_inicializa. Los comentarios (en verde)
describen claramente el funcionamiento de la función, es decir, configurar los pines del puerto F para poder
manejar los periféricos. Tanto los comentarios como la declaración de la función especifican que la función
no necesita ningún argumento de entrada para realizar su labor y en la salida de la función tampoco existe
alguna variable como resultado de la llamada a la función.
Fig. 6 Declaración de la función TivaES_Inicializa
Fig. 7 Declaración de la función TivaES_LedParpadeo
La figura 7 muestra el comentario y declaración asociada a la funcion TivaES_LedParpadeo. El

comentario indica claramente la tarea a realizar por la función. Ademas, la declaración de la función
nos dice que la función espera dos argumentos de tipo uint8_t (tipo entero de 8 bits sin signo) para
la realización de la tarea. La función no arroja ningún resultado.
Las ocho constantes definidas para su uso con la variable color, son:
Fig. 8 Definición de las constantes para colores del led RGB
De esta manera, para hacer parpadear el led RGB 15 veces en color cian, escribiríamos la siguiente
línea de código en nuestro programa:
TivaES_LedParpadeo(CIAN, 15);
La figura 9 muestra el comentario y declaración asociada a la función TivaES_SolicitaNumero. La

declaración o prototipo de la función nos indica que la función espera dos argumentos de tipo uint8_t.

El primer argumento indica el número de dígitos que espera la función antes de terminar su tarea,
mientras que el segundo argumento indica si se activa o no el indicador luminoso (led RGB) para cada
paso del proceso de adquisición del número.
Fig. 9 Declaración de la función TivaES_SolicitaNumero
Ejemplo: Si deseo ingresar un número de tres dígitos (unidades, decenas y centenas) con el indicador
luminoso activado, se deberá escribir en mi código fuente:
numero = TivaES_SolicitaNumero(3, TRUE);
Luego, una vez llegado al punto de ejecución de la función, el microcontrolador empieza a ejecutar la
función y SÓLO SALDRA DE ELLA una vez que se haya COMPLETADO el proceso de adquisición
del número, tal y como se describe en el comentario asociado a la función (figura 9).
Es decir, si el usuario desea ingresar el número 241 al sistema, deberá activar los pulsadores SW1 y
SW2 del TivaLaunchpad en el siguiente orden:
SW1 SW1 SW2 SW1 SW1 SW1 SW1 SW2 SW1 SW2
2 4 1
Luego de activar los pulsadores en el orden descrito la función regresará el valor 241 y la almacenará
en la variable número.

V. EJEMPLOS
Ejemplo 1. Calcular el menor de tres números y el promedio de los dos mayores.
Planteamiento del problema
Desarrollar un programa para el TM4C123GH6PM tal que el usuario pueda ingresar tres números de dos
dígitos cada uno, hasta 99 inclusive, para acto seguido hacer el cálculo del menor de dichos números y
hallar el promedio sin considerar el menor de los tres números. Se muestra el promedio mediante
parpadeos en color blanco del led RGB.
Es decir, si el promedio en mención es 7, entonces se hará parpadear 7 veces en color blanco el led RGB.
Hacer uso de las funciones de la librería TivaES.
Diagrama de flujo
Fig. 10 Diagrama de flujo del ejemplo 1: calcular el menor y el promedio de tres números

Pseudocódigo
De acuerdo al enunciado de nuestro ejemplo y en correspondencia al diagrama de flujo anterior,

planteamos el pseudocódigo correspondiente. Planteamos la solución de la función que calcula el menor
de tres números ya que dicha solución no la tenemos en la librería TivaES.
Función menor  NotaMenor(n1, n2, n3)

Si ((n1 <= n2) y (n1 <= n3)) entonces
menor  n1
Caso Contrario Si ((n2 <= n1) y (n2 <= n3)) entonces
menor  n2
Caso Contrario
menor  n3
FinSi
FinFunción
Algoritmo Calcula_MenorDeTresNumeros_PromediaMayores
Constantes
BLANCO
Variables
Entero: nota1, nota2, nota3, menor, promedio
Inicio
ConfigurarPuerto()
Mientras (Verdadero)
nota1  SolicitaNumero ()
menor  NotaMenor(nota1, nota2, nota3)
promedio  (nota1 + nota2 + nota3 – menor)/2
ParpadeaLed(promedio, BLANCO)
FinMientras
FinAlgoritmo

Codificación
/****************************************************************************************/
/****************************************************************************************/
/***** PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ *****/
/***** FACULTAD DE CIENCIAS E INGENIERÍA *****/
/***** SISTEMAS DIGITALES *****/
/****************************************************************************************/
/***** Tema: Programación de puertos de E/S con TivaES *****/
/***** Proyecto: Lab2_ejemplo1 *****/
/****************************************************************************************/
/***** Microcontrolador: TM4C123GH6PM *****/
/***** EvalBoard: Tiva C Series TM4C123G LaunchPad *****/
/***** Autor: Rolando Sánchez Ponce *****/
/***** Fecha: Abril 2019 *****/
/***** *****/
/****************************************************************************************/
/***** Enunciado: *****/
/***** El programa calcula el promedio de tres notas sin considerar la menor de *****/
/***** ellas. El usuario ingresa las tres notas mediante los pulsadores y visualiza *****/
/***** el promedio en el led RGB. *****/
/****************************************************************************************/
/****************************************************************************************/
#include <stdint.h>
#include "tm4c123gh6pm.h"
#include "TivaES.h"
/****************************************************************************************/
/***** numMenor3() *****/
/****************************************************************************************/
/***** Determina el menor de tres números. *****/
/****************************************************************************************/
/***** ENTRADAS: a, b, c: Tres números de 8 bits. *****/
/***** SALIDA: El menor de los tres números *****/
/****************************************************************************************/
uint8_t numMenor3(uint8_t a, uint8_t b, uint8_t c){

uint8_t menor;
if((a<=b)&&(a<=c)) menor = a;
else if((b<=a)&&(b<=c)) menor = b;
else menor = c;
return menor;
}
/****************************************************************************************/
/***** P R O G R A M A P R I N C I P A L *****/
/****************************************************************************************/
int main(void) {
uint8_t nota1, nota2, nota3, promedio, notaMenor;
TivaES_Inicializa();
while(1){
nota1 = TivaES_SolicitaNumero(2, TRUE);
notaMenor = numMenor3(nota1, nota2, nota3);
promedio = (nota1 + nota2 + nota3 - notaMenor)/2;
TivaES_LedParpadeo(BLANCO, promedio);
}
}
/****************************************************************************************/
/***** F I N D E L P R O G R A M A *****/
/****************************************************************************************/
Fig. 11 Código del ejemplo 1: determinación del menor y el promedio de tres números

Copiamos el código fuente (figura 11) al archivo main.c y luego procedemos a compilar nuestro proyecto
con la herramienta Project->Build Target de la barra de menú. Hasta este punto no deberían mostrarse
errores tal como se muestra en la figura 12.
0 Error (S)
Fig. 12 Proyecto Lab2_ejemplo1
Depuración en el entorno Keil uVision 4.74 IDE utilizando el Simulador
Utilizamos el simulador como herramienta de depuración (debug). Para ello en la barra de menú
seleccionamos Project->Options for Target, pestaña Debug, seleccionamos Use Simulator. Acto
seguido iniciamos la depuración mediante la opción Debug->Start/Stop Debug sesión, o mediante el
icono asociado .
Fig 13. Entorno de depuración del ejemplo 1, utilizando el simulador

Recordar que las opciones de menú Debug y Peripherals contienen herramientas para utilizar en este
entorno de depuración (figura 13). En este contexto podemos destacar las diferentes secciones resaltadas:
sección de variables locales, herramientas de depuración y el simulador visual TExaS LaunchPadDLL.
Para la simulación de nuestro proyecto utilizaremos estas secciones principalmente.
Utilizamos la herramienta Step Over (F10) para avanzar por el código de nuestro programa. Así,
ubicados en la sentencia TivaES_Inicializa(); (figura 13, línea de código resaltada en verde) al hacer clic
en la herramienta Step Over o pulsando F10 el simulador ejecutará TODAS las acciones internas a la
función TivaES_Inicializa y por lo tanto realizará la tarea completa, es decir, configurará todos los registros
necesarios del puerto F para hacer uso de los periféricos conectados a el: led RGB, pulsadores SW1 y
SW2.
Es importante recordar que esta función deberá utilizarse SIEMPRE cada vez que se necesite controlar
los periféricos de la tarjeta TivaLaunchpad.
Fig. 14 Capturas de pantalla antes y después de depurar la sentencia TivaES_Inicializa con F10 (Step Over). Nótese que el
puntero de programa paso de la línea 47 a la 48 en la figura, vale decir, la función TivaES_Inicializa se ejecutó en forma
completa.
Realicemos la misma prueba, pero ahora con la opción de depuración Step Into (F11). Para ello
reiniciemos la depuración y estando en el punto de ejecución de la sentencia TivaES_Inicializa();
procedemos a depurar esta vez con Step Into (F11) . Podemos notar que la ejecución del programa
se traslada a la ventana Disassembly, la cual recorre la ejecución de la función, pero esta vez en lenguaje
ensamblador, ya no en C.
Esta peculiaridad se da porque no disponemos de la implementación en lenguaje C de la función

TivaES_inicializa, solo tenemos la implementación de la función en código máquina.

Fig. 15 Capturas de pantalla antes y después de depurar la sentencia TivaES_Inicializa con F11 (Step Into). Nótese que la
ejecución del programa (depuración) se traslada a la ventana Disassembly. En ella se ejecutan las instrucciones en lenguaje
ensamblador cada vez que se pulse F11 (cursor amarillo).
Podemos concluir entonces que, dado que la operación en lenguaje ensamblador no está contemplado en
esta etapa del curso, todas las funciones de la librería TivaES las procederemos a depurar con la
herramienta Step Over (F10).
Especial atención nos merece la depuración de la sentencia nota1 = TivaES_SolicitaNumero(2, TRUE);

que como bien se explicó anteriormente espera el ingreso de un número de dos dígitos, unidades y
decenas, mediante el accionamiento de los pulsadores SW1 y SW2 del TivaLaunchpad.
Cuando lleguemos a la depuración de esta sentencia, al igual que con cualquier otra que incluya funciones
de la librería TivaES, lo haremos con Step Over (F10). Al depurar así esta sentencia el simulador realiza,
o intenta realizar, todas las acciones necesarias hasta salir de la función. Sin embargo, el diseño de esta
función es tal que solo se saldrá cuando se haya completado la formación del número según las reglas de
adquisición de la función (ver figura 9).
Entonces, para que esto suceda, deberá realizarse dicho procedimiento utilizando el simulador grafico
TExaS LaunchPadDLL.
Inicio de la depuración:
Los cursores amarillo y cian apuntan
ambos a la línea a depurar.
El simulador grafico (TExaS
LaunchPadDLL) no muestra actividad.
También se puede ver el valor de los
registros del puerto F (DATA, DIR, DEN,
PUR).
Variables locales con valor desconocido.
Fig. 16-a Depuración de la sentencia

nota1 = TivaES_SolicitaNumero(2,TRUE);

Se activa la opción Step Over (F10).

Note que los cursores se separan ahora
indicando las instrucciones en assembler
que se están ejecutando ya que sólo
disponemos del código máquina de la
función.
El simulador grafico no muestra actividad.
Notar que las herramientas de depuración
aparecen desactivadas excepto la opción
para parar y resetear la simulación. Esto
se debe a que en estos momentos se
están ejecutando las instrucciones de la
función hasta que se dé por terminada la
función.
Esto significa que se debe esperar las

acciones de los pulsadores para salir de la
función y seguir depurando.
Por ejemplo, si deseo ingresar el número
12 se deberá accionar SW1, SW2, SW1,
SW1, SW2. Cada vez que un digito se
incremente en uno se enciende el led azul
y cuando se dé por valido el dígito se
enciende el led verde. Antes de salir de la
función se enciende el led rojo.
Luego de realizar estas acciones se da

por terminada la ejecución de la
sentencia.
Los cursores amarillo y cian vuelven a
apuntar ambos juntos a la siguiente línea
a depurar.
Las herramientas de depuración vuelven a
estar activas.
La función devuelve el valor ingresado
mediante los pulsadores SW1 y SW2.
Dicho valor se observa en la ventana de
variables locales, en este caso nota1 toma
el valor 0x0C (12).
Fig. 16-b Depuración de la sentencia nota1 = TivaES_SolicitaNumero(2, TRUE);
De la misma manera continuamos la depuración para las siguientes dos variables: nota2 y nota3.
Ya que tenemos disponible la implementación de la función numMenor3, podemos usar para la

depuración de la variable notaMenor ya sea la herramienta Step Into como también Step Over. En el
caso de usar la opción Step Into, la ejecución se trasladaría junto con los cursores a la implementación
de la función numMenor3.

Fig. 17 Depuración de la sentencia notaMenor3 = numMenor3(nota1, nota2, nota3)
La figura 17 muestra la captura de pantalla justo después de ejecutar Step Into (F11) en la depuración de
la variable notaMenor. Puede notarse que ambos cursores se trasladan a la definición de la función
numMenor3, además las variables nota1, nota2 y nota3 quedan con los valores ingresados con los
pulsadores: 12, 3 y 10 respectivamente.
Fig. 18 Resultado final de la depuración. La variable promedio queda con valor 12 y la variable notaMenor con valor 3. El led
RGB deberá parpadear 12 veces en color blanco.
Depuración utilizando la tarjeta Tiva Launchpad y Keil uVision 4.74 IDE
Conecte la tarjeta Tiva LauchPad a su computador. En la pestaña Debug, seleccionamos Use Simulator.
Verifique que el panel de configuración de la derecha correspondiente al hardware de depuración del
microcontralador cumpla con las especificaciones entregadas en la Guía_Lab01_2022_2.pdf (pag12).
Acto seguido iniciamos la depuración mediante la opción Debug->Start/Stop Debug sesión, o mediante
el icono asociado .

Fig. 19 Configuración para el depurador con la tarjeta Tiva Lauchpad.
Como usted ya tiene un programa que ha logrado ejecutar exitosamente en la simulación, haga clic en
Run (F5). Proceda a ingresar los números con los pulsadores (acceda a los registros asociados al
módulo de entrada salida GPIO puerto F, al visualizador de variables del programa y memoria del
microcontrolador) y observe en el led RGB el resultado esperado.
Fig. 20 Depuración de la función TivaES_SolicitaNumero con el comando Step Over (F10) en la tarjeta de evaluación Tiva
Launchpad. Una vez ejecutado el comando (F10) se procede a la ejecución de la función. En la foto, cada vez que se ingresan
las decenas del número se prende el led RGB en color azul.

Ejemplo 2. Alternar el color del led RGB (rojo, verde y azul) cada vez que se presione y
suelte tres veces el pulsador SW2.
Desarrollar un programa para el TM4C123GH6PM tal que al inicio el led tricolor RGB esté prendido en
color ROJO, se esperen tres pulsos de SW2 para pasar a color AZUL y se esperen tres pulsos más del
mismo pulsador para pasar al color VERDE. El funcionamiento es cíclico.
Hacer uso de las funciones de la librería TivaES.
Diagrama de flujo
Fig. 21 Diagrama de Flujo del ejemplo 2: Alternar el color del led RGB con tres pulsos de SW2

Pseudocódigo
Algoritmo AlternarColorLedRGB_con_SW2
Constantes
ROJO
AZUL
VERDE
SW2
Variables
Entero: color, pulsos
Inicio
ConfigurarPuerto()
color  Rojo
Mientras(Verdadero)
PrenderLed(color)
pulsos  0
Mientras (pulsos <= 3)
EsperaPulsarSoltarPulsador(SW2)
pulsos  pulsos + 1
FinMientras
Si (color = ROJO) entonces

color  AZUL
Caso Contrario Si (color = AZUL) entonces
color  VERDE
Caso contrario
color  ROJO
FinSi
FinMientras
FinAlgoritmo

Codificación
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
/***** Autor: Rolando Sánchez Ponce *****/
/***** Fecha: Marzo 2019 *****/
/****************************************************************************************/
/***** Enunciado: *****/
/***** El led RGB toma los colores rojo, azul y verde alternadamente, para cambiar *****/
/***** de color se debe presionar tres veces el pulsador SW2. *****/
/****************************************************************************************/
/****************************************************************************************/
#include <stdint.h>
#include "TivaES.h"
int main(void) {
uint8_t pulsos, color;
color = ROJO;
while(1){
TivaES_LedColor(color); // Encendemos el led

for(pulsos=0; pulsos<3; pulsos++){
TivaES_EsperaPulsador(SW2); // Estructura for que espera que se
} // presione tres veces el pulsador SW2
if(color == ROJO) // Estrucutura if..else if..else

color = AZUL; // que actualiza la variable color
else if(color == AZUL)
color = VERDE;
else
color = ROJO;
}
}
/****************************************************************************************/
/***** F I N D E L P R O G R A M A *****/
/****************************************************************************************/
Fig. 22 Código del ejemplo 2: Alternar el color del led RGB con tres pulsos de SW2
Como en el ejemplo anterior podemos depurar el proyecto mediante la opción Step Over (F10) y ver en el
simulador gráfico (TExaS LaunchPadDLL) los cambios que produce la ejecución de cada sentencia de
nuestro programa.
Para este ejemplo usemos la opción de depuración Run (F5) para depurar el proyecto.

Luego de ejecutar la herramienta Run
(F5) podemos ver que el led RGB se
prende en color rojo en el simulador
gráfico.
Esto es consistente con el código que

enciende el led y espera los pulsos en
SW2.
Entonces, debemos generar tres pulsos

en SW2 para que el led cambie de color.
Para simular un pulso en SW2 debemos

marcar la casilla SW2 en el simulador
gráfico (pulsador presionado) y luego
desmarcar la casilla SW2 (pulsador
liberado).
Esta secuencia debemos realizarla tres

veces para simular tres pulsos en SW2 y
conseguir el cambio de color.
Al simular tres pulsos el led RGB cambia

de color a BLUE (azul).
De la misma manera podemos realizar

los mismos pasos para cambiar el color a
GREEN (verde).
Fig. 23 Depuración del ejemplo 2: Lab2_ejemplo2.
La figura 23 muestra los resultados de la depuración del ejemplo Lab2_ejemplo2. Debido a la naturaleza
de la aplicación nos conviene usar la opción Run (F5) para mostrar el funcionamiento completo del
ejemplo. Esta opción no nos permite depurar las variables intermedias en la programación, entonces, la
interacción con el simulador gráfico TExaS LaunchPadDLL es lo más apropiado.

Ejemplo 3. Generar un número aleatorio y mostrarlo en el led RGB
Desarrollar un programa para el TM4C123GH6PM tal que cuando el usuario pulse SW1 se inicie el cálculo
de un número aleatorio mayor o igual que 0 y menor o igual que 7. El cálculo termina cuando se suelta
SW1. Además, cuando el usuario pulse SW2 se muestre ese número en el led RGB.
Hacer uso de las funciones de la librería TivaES. No hacer uso de la librería matemática o ninguna otra
para el cálculo del número aleatorio.
Diagrama de flujo
INICIO
INICIO
InicializaPuerto( )
aleatorio  0
NO ¿Se presionó SW1?
SI
aleatorio  aleatorio+1
¿aleatorio=8? NO ¿Sigue presionado SI

SW1?
SI NO
aleatorio  0
¿Presiona y Suelta NO
SW2?
SI
LedColor(aleatorio)
Fig. 24 Diagrama de Flujo del ejemplo 3: Alternar el color del led RGB con SW1

Pseudocódigo
Algoritmo CalcularNumeroAleatorio_con_SW1_mostrar_con_SW2
Constantes
SW1
SW2
NIVEL_BAJO
Variables
Entero: color, aleatorio
Inicio
ConfigurarPuerto()
aleatorio  0
Mientras(Verdadero)
EsperaPulsadorPresionado(SW1)
Hacer
aleatorio  aleatorio + 1
Si (aleatorio = 8) entonces
Aleatorio  0
FinSi
Mientras (LeerPulsador(SW1) = NIVEL_BAJO)
EsperaPulsarSoltarPulsador (SW2)
color  aleatorio << 1
PrenderLed(color)
FinMientras
FinAlgoritmo

Codificación
La generación del número aleatorio se realiza incrementando en uno la variable aleatorio indefinidamente
mientras el usuario mantenga pulsado SW1, y acotándolo entre 0 y 7 inclusive. Cuando se suelta SW1 se
da por generado el número aleatorio y es el que se muestra en el led RGB.
Nótese que hemos utilizado tres diferentes funciones para el manejo de los pulsadores:
TivaES_EsperaPresionarPulsador, TivaES_LeePulsador y TivaES_EsperaPulsador. ¿Indicar la razón

del uso de estas funciones y en qué se diferencia cada una de ellas?
…………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
/***** Autor: Rodia Santivañez Santivañez *****/
/***** Fecha: Abril 2020 *****/
/****************************************************************************************/
/***** Enunciado: *****/
/***** Cuando se presiona SW1 se calcula un numero aleatorio entre 0 y 7 inclusive *****/
/***** Cuando se presiona SW2 se muestra el numero en el led RGB *****/
/****************************************************************************************/
/****************************************************************************************/
#include <stdint.h>
#include "TivaES.h"
int main(void) {
uint8_t color, aleatorio = 0;
while(1){
TivaES_EsperaPresionarPulsador(SW1);
do
{
aleatorio++;
if(aleatorio == 8) aleatorio = 0;
}while(TivaES_LeePulsador(SW1) == LOW);
TivaES_EsperaPulsador(SW2);
color = aleatorio<<1;
TivaES_LedColor(color);
}
}
/****************************************************************************************/
/***** F I N D E L P R O G R A M A *****/
/****************************************************************************************/
Fig. 25 Código del ejemplo 3: Alternar el color del led RGB con SW1

Utilicemos todas las herramientas de depuración vistas hasta ahora.
Inicio de la depuración. Nótese

que en la ventana de variables
locales las variables color y
aleatorio no tienen valores
definidos y los cursores amarillo y
cian se encuentran juntos
apuntando a la línea a ejecutarse,
la línea 26. En ella la variable
aleatorio obtiene un valor (cero)
mientras que la variable color no
se define en esa línea.
Como sabemos, debemos utilizar

la herramienta Step Over (F10)
para depurar las funciones de la
librería TivaES.
La figura de la izquierda muestra

cómo queda la depuración
después de pulsar cinco veces la
tecla de función F10.
Nótese que la variable aleatorio se

define en 0, los cursores ya no
están juntos pues se está
depurando la línea 30 (sin código
en C), las herramientas de
depuración están desactivadas
pues se espera una acción del
usuario, en este caso, se espera
se pulse SW1.
No hay cambio en el simulador
gráfico.

Para salir del estado anterior debo

marcar en el simulador gráfico
SW1 (pulsador presionado) y
seguir depurando con la tecla F10.
Podemos notar que se sale del

estado anterior y si seguimos
depurando con F10 los cursores
pasaran indefinidamente por el
bucle do-while, esto siempre y
cuando siga marcado SW1.
Podemos notar también como se

va incrementando nuestra
variable aleatorio en la ventana de
variables locales.
Ubiquemos un punto de ruptura

(breakpoint) en la línea 42 y
procedamos a ejecutar la
herramienta Run (F5). La captura
de pantalla quedaría como la
figura de la izquierda.
En este estado se están

esperando las acciones
necesarias para llegar a la línea
42.
Para salir del bucle do-while

proceda a desmarcar SW1 y para
pasar la línea 38 necesita pulsar
SW2, esto se consigue marcando
y desmarcando SW2 en la
ventana de depuración gráfica.

La figura de la izquierda muestra
la captura de pantalla luego de
ejecutar las acciones descritas
anteriormente.
Los cursores se vuelven a unir en

la línea 42 y los valores de las
variables quedan establecidas en
la ventana de variables locales.
En la línea 42, al ejecutar Step

Over (F10) se prende el led RGB
de color amarillo.
Fig. 26. Depuración del ejemplo 3: Lab2_ejemplo3
Cuestionario
• ¿Por qué es necesaria la sentencia color = aleatorio<<1; en la línea 40 y que es lo que realiza
exactamente?
• ¿Por qué el led enciende de color amarillo?
• Complete la tabla de correspondencia entre el valor aleatorio generado y el color que deberá
prenderse el led RGB.
Variable aleatorio Color led RGB

0
1
2
3
4
5 amarillo
6
7

Problemas propuestos
Los siguientes problemas propuestos se implementan para el microcontrolador TM4C123GH6PM.
Tarjeta de evaluación: EK-TM4C123GXL
se pide:
• Diagrama de flujo
• Código en lenguaje C, debidamente comentado
• Simulación del programa
1. Se ingresa tres números a través de los pulsadores SW1 y SW2, para formar los lados de un
triángulo. Si el triángulo es escaleno, se enciende el led verde. Si es isósceles se enciende el led
rojo y si el triángulo es equilátero se enciende el led VERDE. Si el triángulo no existe se prende el
led de color blanco. Escriba el programa que cumpla con las condiciones dadas.
2. Desarrollar un programa en Lenguaje C haciendo uso de la librería TivaES, realice lo siguiente:

• Ingresar dos números mediante los pulsadores SW1 y SW2.
• Prender el led RGB de color Rojo.
• Si se presiona y suelta SW1 parpadear el led de color Magenta conforme a la suma de los
números.
• Si se presiona y suelta SW2 parpadear el led de color Cian conforme a la resta de los
números (mayor – menor).
3. La tarjeta de evaluación EK-TM4C123GXL cuenta con dos pulsadores (SW1 y SW2) y tres diodos
leds (rojo, verde y azul). Implemente un programa que permita realizar las siguientes tareas:
Al presionar y soltar “n” veces el pulsador SW1 se muestra “n-1” parpadeos de color amarillo y “n”
parpadeos de color magenta luego se repite la secuencia en forma cíclica. Al inicio los leds están
apagados y el pulsador sin presionar.
Al presionar y soltar “n” veces el pulsador SW2 se muestra “n” parpadeos de color azul y “n+1”
parpadeos de color blanco, luego se repite la secuencia en forma cíclica. (El programa
implementado debe ser el mismo para cualquier valor de n, solo deberá modificar el valor de una
variable o una constante. Para las pruebas considere n=5).
4. Desarrolle la función:
uint8_t SumaDigitos3(uint16_t Num3Dig, uint8_t color)
Toma como entrada un número de tres dígitos (entre 0, y 999) calcula la suma de los tres dígitos
que conforman el número y los muestra mediante parpadeos del color indicado.
Ejemplo:
suma = SumaDigitos(231, VERDE); //Devuelve 6 y emite 6 parpadeos de color verde.
5. Desarrollar un programa que solicite el ingreso de tres números en base 10 de tres dígitos y muestre
la suma de los dígitos del mayor de ellos mediante parpadeos azules, seguidamente muestre la
suma de los dígitos del número intermedio en parpadeos CIAN y finalmente la suma de los dígitos
del menor de ellos en verde.
6. Escribir un programa que permita leer tres números de 2 cifras y realizar operaciones entre ellos.
Para ingresar los números y visualizarlos se utilizan los pulsadores SW1 y SW2 y el diodo led RGB
Los requerimientos del programa son:
1) Al accionar (presionar y soltar) el pulsador SW1, se visualizan la cifra de las centenas

de los tres números con tiempo de retardo adecuado mediante pulsos de color azul para

mostrar la centena del primer número, pulsos de color amarillo para la centena del
segundo número y para el tercero con pulsos de Magenta.
2) Al accionar el pulsador SW2, se debe mostrar un número aleatorio entre 3 y 9 (se incluye
3 y 9) con pulsos de color blanco.
Use las funciones TivaES_SolicitaNumero y la función TivaES_LedParpadeo para el ingreso de

números y para ver los parpadeos del led RGB. Implemente la función Aleatorio3y9.
7. Un circuito basado en el módulo EK-TM4C123GXL cuenta con dos pulsadores y tres diodos leds
(led RGB). Escriba un programa que controle una cuenta de tres bits y su visualización es como
sigue:
1. Inicialmente, la cuenta está en CERO (leds apagados).
2. Al presionar y soltar el pulsador 1 (SW1), la cuenta aumenta en 1, al llegar a su valor máximo
igual a 7, comienza otra vez desde 1 y se repite cíclicamente por cada pulsada.
3. Al presionar y soltar el pulsador 2 (SW2), la cuenta disminuye en 1 y al llegar a su valor mínimo
que es 1, la cuenta se reinicia desde 7 y se repite cíclicamente.
La cuenta es presentada como una secuencia de pulsos de color azul; la cantidad de pulsos
mostrada por el led corresponde al valor de la cuenta.
8. Se pide implementar un sistema en el circuito basado en el microcontrolador TMC4123GH6PM.

Inicialmente dicho sistema se encuentra bloqueado mostrando el led rojo encendido. Para
desbloquearlo se requiere que el usuario ingrese una contraseña de 3 dígitos. Defina la contraseña
como 123 y utilice la función TivaES_SolicitaNumero, para el ingreso de la clave.
Clave incorrecta:
En caso se ingrese una clave incorrecta se encenderá el led rojo y se volverá a pedir
el ingreso de una clave. Sólo se permitirán 3 intentos. Si los 3 intentos son errados el
led rojo comenzará a parpadear indefinidamente indicando un estado de alarma y no
se permitirá volver a ingresar una contraseña.
Clave correcta:
Si la clave fue correcta se mostrará el led verde por un tiempo y se volverá a bloquear
el sistema.
Referencias Bibliográficas:
• Valvano, Jonathan W. 2014
Embedded systems: real-time interfacing to ARM¿ Cortex?-M microcontrollers
San Bernardino: s.e., 2014.
• Texas Instruments.
Tiva TM4C123GH6PM Microcontroller Datasheet
• Guías de laboratorio del curso de Sistemas Digitales 2020-1. PUCP
Autores
Material del Laboratorio 02 del curso de Sistemas Digitales, elaborado por:
Ing. Rodia Santivañez rsantivanez@pucp.pe
Ing. Zenón Cucho zcucho@pucp.pe
Profesores del curso:

Ing. Hugo Pratt
Ing. Gabriel Jimenez
Actualización: Semestre 2022-2

Programación de puertos E/S

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

Programación de puertos E/S

Cargado por

Copyright:

Formatos disponibles

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERÚ

FACULTAD DE CIENCIAS E INGENIERÍA

PROGRAMACIÓN EMPLEANDO PUERTOS DE E/S

IV. KEIL uVISION 4.74 IDE y LIBRERÍA TivaES

a) Circuito esquemático simplificado b) Módulo Tiva LaunchPad EK-TM4C123G

Fig.1 Diagrama de conexiones del TM4C123GH6PM en el Tiva Launchpad

El módulo de desarrollo Tiva Launchpad EK-TM4C123GXL posee periféricos conectados directamente al

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 1

Creación de un proyecto en Keil uVision 4.76 utilizando librería TivaES

Fig.2 Creación de un proyecto nuevo (Lab2_ejemplo1) en Keil uVision

Fig. 3 Crear un nuevo grupo de archivos fuente para la librería TivaES

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 2

Fig. 4 Edición del nombre del grupo creado

Fig. 5 Proyecto en Keil uVision 4 con librería TivaES añadida

La implementación de la librería TivaES se da en dos archivos: TivaES.h y TivaES.obj. El archivo

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 3

Fig. 6 Declaración de la función TivaES_Inicializa

Fig. 7 Declaración de la función TivaES_LedParpadeo

La figura 7 muestra el comentario y declaración asociada a la funcion TivaES_LedParpadeo. El

Fig. 8 Definición de las constantes para colores del led RGB

La figura 9 muestra el comentario y declaración asociada a la función TivaES_SolicitaNumero. La

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 4

Fig. 9 Declaración de la función TivaES_SolicitaNumero

numero = TivaES_SolicitaNumero(3, TRUE);

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 5

Ejemplo 1. Calcular el menor de tres números y el promedio de los dos mayores.

Planteamiento del problema

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 6

De acuerdo al enunciado de nuestro ejemplo y en correspondencia al diagrama de flujo anterior,

Función menor  NotaMenor(n1, n2, n3)

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 7

uint8_t numMenor3(uint8_t a, uint8_t b, uint8_t c){

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 8

Fig. 12 Proyecto Lab2_ejemplo1

Depuración en el entorno Keil uVision 4.74 IDE utilizando el Simulador

Fig 13. Entorno de depuración del ejemplo 1, utilizando el simulador

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 9

Para la simulación de nuestro proyecto utilizaremos estas secciones principalmente.

Esta peculiaridad se da porque no disponemos de la implementación en lenguaje C de la función

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 10

Especial atención nos merece la depuración de la sentencia nota1 = TivaES_SolicitaNumero(2, TRUE);

Fig. 16-a Depuración de la sentencia

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 11

Se activa la opción Step Over (F10).

Esto significa que se debe esperar las

Luego de realizar estas acciones se da

Fig. 16-b Depuración de la sentencia nota1 = TivaES_SolicitaNumero(2, TRUE);

Ya que tenemos disponible la implementación de la función numMenor3, podemos usar para la

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 12

Fig. 17 Depuración de la sentencia notaMenor3 = numMenor3(nota1, nota2, nota3)

Depuración utilizando la tarjeta Tiva Launchpad y Keil uVision 4.74 IDE

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 13

Fig. 19 Configuración para el depurador con la tarjeta Tiva Lauchpad.

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 14

Planteamiento del problema

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 15

Si (color = ROJO) entonces

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 16

TivaES_LedColor(color); // Encendemos el led

if(color == ROJO) // Estrucutura if..else if..else

Depuración en el entorno Keil uVision 4.74 IDE utilizando el Simulador

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2020-2 17