PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU

FACULTAD DE CIENCIAS E INGENIERIA

SECCION ELECTRICIDAD Y ELECTRONICA

Laboratorio 4
Programación del UART (Universal Asynchronous Receiver\Transmitters)
Programación del temporizador del sistema (SysTick timer)

I. OBJETIVO
Comprender el funcionamiento del temporizador del sistema y del dispositivo de comunicación serial
que dispone el microcontrolador TM4C123GH6PM.
Programar correctamente utilizando sus registros de configuración que presentan ambos periféricos.

II. MATERIALES Y EQUIPOS

 1 Módulo de desarrollo LaunchPad Tiva C - TM4C123GH6PM
 1 Modulo de expansión de E/S Tiva
 1 cable de extensión USB
 Entorno de desarrollo Code Composer Studio 6.1
 1 computadora personal

III. INTRODUCCIÓN TEÓRICA

El Módulo de transmisión y recepción asíncrona universal UART (Universal Asynchronous

Receiver Transmtitter)

Una característica importante de todos los microcontroladores es la comunicación serial con otros
dispositivos. Se estudiará en el Laboratorio la programación del módulo serial UART del
microcontrolador TM4C123GH6PM.
Trama de una comunicación serial del UART, es programable:

Generación de Baud-Rate (velocidad en baudios)

El baud-rate, es un número de 22 bits que consta de un entero de 16 bits y una parte fraccionaria de 6
bits. El valor entero de 16 bits se carga a través del registro UARTIBRD (UART Entero Baud-Rate
Divisor) y la parte fraccionaria de 6 bits se carga con el registro UARTFBRD (UART fraccional
Baud-Divisor de Velocidad). La velocidad (BRD) es programable, hasta 1/16 de la frecuencia de
reloj del sistema (SysClk), mediante la siguiente relación:

Donde BRDI es la parte entera de la BRD y BRDF es la parte fraccionaria.

Ejemplo:
Si el Reloj de UART fuese 8 Mhz entonces:
BRDI(Parte entera) + BRDF(Parte Fraccional) = 52.083333
La parte entera será BRDI = 52
La parte Fraccional es: 0.08333 y debe extraerse la parte entera de la siguiente operación INT(Fracc*64 + 0.5)
La parte Fraccional quedaría: BRDF = INT(5.83) = 5

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 1

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU
FACULTAD DE CIENCIAS E INGENIERIA
SECCION ELECTRICIDAD Y ELECTRONICA

El temporizador del sistema (SysTick timer)

El microcontrolador tiene un temporizador de sistema de 24 bits, el SysTick, que cuenta

descendentemente hasta cero, cuando pasa de “1” a “0”, se activa la señal fin de cuenta, luego en el
siguiente flanco de reloj se reinicia desde el valor programado en el registro NVIC_ST_RELOAD_R
(abreviado STRELOAD) otra vez en forma descendente.
Cuando el microcontrolador es detenido (estando en el modo depuración en el entorno Code Composer
Studio detenemos el programa), el contador se detiene (no decrementa).
El temporizador consta de tres registros:
SysTick Control and Status (STCTRL): Registro de configuración, para configurar su reloj, activar
el contador, permitir la interrupción SysTick, y determinar el estado del contador.
SysTick Reload Value (STRELOAD): Se utiliza para recargar el valor del contador.
SysTick Current Value (STCURRENT): Contiene el valor actual del contador.

SysTick Control and Status (STCTRL):

Donde:

COUNT ENABLE
0; La cuenta no ha llegado a 0 0:SysTick desactivado
1: La cuenta ha llegado a 0 1: Systick activado

CLK_SRC (Clock source) INTEN (Interrupt enable)

0:Reloj externo (NO IMPLEMENTADO) 0: No genera interrupciones
1:Reloj del sistema (usar este valor) 1: Interrupciones habilitadas

Secuencia de configuración
1. Desactivar el SysTick (ENABLE=0)
NVIC_ST_CTRL_R &= ~NVIC_ST_CTRL_ENABLE;
2. Programar valor de recarga (STRELOAD)
NVIC_ST_RELOAD_R
Considere:
TTEMP=TCLK_SYST(RELOAD + 1)
Si FSYS_CLK = 8 Mhz para temporizar cada 0.5 seg  RELOAD = 3999999 =0X3D08FF
 NVIC_ST_RELOAD_R |= 0x3D08FF;
3. Borrar valor actual (STCURRENT)
Escribir cualquier valor en NVIC_ST_CURRENT_R
4. Configurar SysTick (STCTRL)

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 2

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU
FACULTAD DE CIENCIAS E INGENIERIA
SECCION ELECTRICIDAD Y ELECTRONICA

Introducción al software de comunicaciones serial

Para conectar el módulo TIVA con el puerto serial de la PC, se emplea un software de comunicación serial,
en el laboratorio se empleará el Hyperterminal o el Putty, que se pueden descargar de una página web
confiable. La computadora personal solo servirá como un terminal, el CPU que procesa el programa es la
que corresponde al del microcontrolador TIVA y no al de la PC.

I. Comunicación serial utilizando el Hyperterminal:

Pasos a seguir:
1. Ejecute el Hyperterminal, y abrir una nueva Conexión le pedirá un nombre de sesión, por ejemplo
escriba Tiva_serial, como se observa en la Figura 1.

Figura 1
2. Luego seleccione el puerto serial activo, en la Figura 2, se ha seleccionado el puerto de comunicaciones
COM42 de la PC, el cual está conectado al puerto serial del módulo LaunchPad TIVA (Puede ser
también otro dirección del Puerto diferente a COM42, revise en Administrador de dispositivos/Puertos,
ver la Figura 8, donde está activo el puerto COM6 )

Figura 3
Figura 2

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 3

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU
FACULTAD DE CIENCIAS E INGENIERIA
SECCION ELECTRICIDAD Y ELECTRONICA

3. Luego, ingrese los parámetros de transmisión serial, por ejemplo como se muestra en la Figura 3 con
los siguientes datos:

Bits por segundo: 9600 bps

Bits de datos: 8
Paridad: Ninguno
Bits de parada: 1
Control de flujo: Ninguno

Haga clic, en aceptar.

4. Finalmente, podrá ver el resultado de la programación en la pantalla virtual del Hyperterminal siempre
que el módulo Tiva esté ejecutando el código del programa.

PuTTY
Es otra aplicación portable que nos permite conectarnos entre dos computadoras, en este caso el Módulo
TIVA y la PC. Es gratuito y de código abierto de interfaz sencilla y manejable.
Pasos a seguir:

1. Ejecute la aplicación Putty

Figura 4

2. Crea una sesión de nombre Serial_Tiva, seleccione en Connection la pestaña Serial e ingrese los
parámetros de Transmisión serial del UART del TIVA y la PC, como se observa en las siguientes
figuras 5 y 6. En este ejemplo se ha seleccionado el puerto de comunicaciones COM6 de la PC, el
cual está conectado al puerto serial del módulo LaunchPad TIVA (Puede ser también otro dirección
del Puerto diferente a COM6, ver figura 8).

3. Luego, presione Open para ingresar a la pantalla virtual (Figura 7) donde se mostrarán nuestros
resultados del programa en ejecución, para ello la tarjeta Tiva debe estar ejecutando un programa.

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 4

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU
FACULTAD DE CIENCIAS E INGENIERIA
SECCION ELECTRICIDAD Y ELECTRONICA

Figura 5 Figura 6

Figura 7

Figura 8

ADMINISTRADOR DE DISPOSITIVOS
Estando conectado la tarjeta TIVA LaunchPad con la PC, para ver el puerto serial activo, ingrese a
Admistrador de dispositivos y presione la pestaña Puertos, como en la Figura 8, donde se observa que el
puerto activo es COM6, en su PC puede estar activo otro puerto.

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 5

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU
FACULTAD DE CIENCIAS E INGENIERIA
SECCION ELECTRICIDAD Y ELECTRONICA

Programa 1
Ejemplo con el UART0
Se utiliza el UART0 para realizar el programa ECO que significa que el microcontrolador ha recibido un
dato de la PC por su puerto serial (bit a bit) y lo transmite serialmente por el mismo puerto.

Ejemplo: Si se presiona la Tecla “H”, el microcontrolador recibe este carácter por su puerto serial, luego lo
retransmite, observando este carácter en la pantalla virtual de la PC denominado Hyperterminal. (También
se puede usar Putty).

Diagrama de Flujo

Código documentado del programa.

/***************************************************************************/
/***** Proyecto: Prog01_UART_ECO *****/
/***************************************************************************/
/***** Microcontrolador: TM4C123GH6PM *****/
/***** EvalBoard: Tiva C Series TM4C123G LaunchPad *****/
/***** Autor: Rolando Sánchez Ponce *****/
/***** Fecha: 2016-1 *****/
//***** Enunciado: *****/
/***** Se utiliza el UART0 para realizar ECO: dato recibido por el *****/
/***** puerto serial lo transmite por el mismo puerto. *****/
/***************************************************************************/

#include <stdint.h>
#include "tm4c123gh6pm.h"

void ConfiguraUART0(void){
// Habilitamos reloj para el UART0
SYSCTL_RCGC1_R |= SYSCTL_RCGC1_UART0;
// Habilitamos reloj para GPIOA
SYSCTL_RCGC2_R |= SYSCTL_RCGC2_GPIOA;

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 6

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU
FACULTAD DE CIENCIAS E INGENIERIA
SECCION ELECTRICIDAD Y ELECTRONICA
// Inhabilitamos el UART0
UART0_CTL_R &= ~UART_CTL_UARTEN;
// Velocidad 9600bps (Fsysclk = 16MHz)
UART0_IBRD_R = (UART0_IBRD_R & 0xFFFF0000) | 104;
UART0_FBRD_R = (UART0_FBRD_R & 0xFFFFFFC0) | 11;
// 8, N, 1, FIFOs habilitados
UART0_LCRH_R = (UART0_LCRH_R & 0xFFFFFF00) | 0x70;
// Habilitamos el UART0
UART0_CTL_R |= UART_CTL_UARTEN;
// Desactivamos modo analógico en PA0 y PA1
GPIO_PORTA_AMSEL_R &= ~(0x03);
// Conectamos UART0 a PA0 y PA1
GPIO_PORTA_PCTL_R = (GPIO_PORTA_PCTL_R&0xFFFFFF00)|0x00000011;
// Activamos funciones alternas en PA0 y PA1
GPIO_PORTA_AFSEL_R |= 0x03;
// Activamos funciones digitales en PA0 y PA1
GPIO_PORTA_DEN_R |= 0x03;
}

int main(void){
unsigned char datoRx;
ConfiguraUART0();
while(1){
// Esperamos mientras Buffer Rx esté vacío
while(UART0_FR_R & UART_FR_RXFE);
// Se lee el dato recibido
datoRx = UART0_DR_R;
// Esperamos mientras Buffer Tx esté lleno
while(UART0_FR_R & UART_FR_TXFF);
// Se escribe el dato para su transmisión
UART0_DR_R = datoRx;
} //Fin de while
} // Fin de main

Resultado

Abrir la aplicación Hypeterminal: Darle un nombre, por ejemplo Serial_1.

Seleccione el puerto correcto, por ejemplo COM34 (Puede verlo en Administrador de dispositivos)

Ingrese los parámetros de comunicación serial:

Bits por segundo: 9600 bps
Bits de datos: 8
Paridad: Ninguno
Bits de parada: 1
Control de flujo: Ninguno

En Code Composer, ejecute el programa

En el Hyperterminal teclee HolA, con lo cual ha comprobado el funcionamiento del programa ECO. El
ultimo carácter ingresado es A, que se observa en la siguiente figura:

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 7

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU
FACULTAD DE CIENCIAS E INGENIERIA
SECCION ELECTRICIDAD Y ELECTRONICA
Programa 2
Ejemplo con el UART
Implemente un sistema basado en el microcontrolador TM4C123GH6PM que, conectado por su puerto
serial a una computadora personal en la cual se ejecuta el programa HyperTerminal, cumpla con realizar la
siguiente aplicación:
El programa debe permitir recibir caracteres ingresados por el teclado, para comparar con una palabra oculta
grabada en su memoria. Al inicio, la palabra debe ser mostrada en pantalla virtual como asteriscos para
luego ser reemplazados con cada carácter acertado.
Parámetros UART: 9600bps, 8 bits de datos 1 bit de parada, sin paridad, habilitación del FIFO.

Diagrama de flujo

INICIO

Inicialización oculta[], palabra[],

aciertos ß 0

Configuración de UART

Transmitir texto
¿aciertos < longitud de palabra[]?
No “Palabra correcta”

Sí

Transmitir texto Fin

“Ingrese letra”

Recibir carácter

¿carácter pertenece a palabra[]? ¿carácter ingresado antes?

No Sí

Sí No

Reemplazar carácter en oculta[]

aciertos ß aciertos + 1

Transmitir oculta[]

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 8

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU
FACULTAD DE CIENCIAS E INGENIERIA
SECCION ELECTRICIDAD Y ELECTRONICA

Código documentado del programa.

/* Proyecto: Palabra_Oculta
* Autor: Ing. Fedra Trujillano
* Semestre: 2016-1
* Descripcion:
* El programa recibe los caracteres ingresados por el teclado e
* identifica si pertenecen a una palabra oculta. Al inicio la
* palabra se muestra en pantalla como asteriscos y se reemplazan
* por el caracter correspondiente una vez acertado.
* Parámetros UART: 9600bps, 8 bits dedatos 1 bit de parada,
* sin paridad, habilitacióndel FIFO.
*/

#include"tm4c123gh6pm.h"
#include"stdint.h"

/*Funcion de configuración del UART*/

void config_uart0 (void){
unsigned long temp;
SYSCTL_RCGC1_R |= SYSCTL_RCGC1_UART0; // Se activa el reloj del UART
temp = SYSCTL_RCGC2_R; // Espera de unos ciclos de reloj
SYSCTL_RCGC2_R |= SYSCTL_RCGC2_GPIOA; // Se activa el reloj del puerto A
// PA0 (U0Rx) PA1( U0Tx)
temp = SYSCTL_RCGC2_R; // Espera de unos ciclos de reloj
UART0_CTL_R &= ~ UART_CTL_UARTEN; // Se desactiva el UART
UART0_IBRD_R = (UART0_IBRD_R & ~UART_IBRD_DIVINT_M)|104; // Se configura DIVINT
// 16MHz/(16*9600)
// Parte entera
UART0_FBRD_R = (UART0_FBRD_R & ~UART_FBRD_DIVFRAC_M)|10; //Se configura DIVFRAC
//Parte fraccionaria*64
UART0_LCRH_R = ((UART0_LCRH_R & ~0x000000FF)|(UART_LCRH_WLEN_8)|(UART_LCRH_FEN));
// Se configuran los bits de datos, 1 bit de parada, sin paridad y habilita el FIFO
UART0_CTL_R |= UART_CTL_UARTEN; // Se habilita el UART
GPIO_PORTA_AFSEL_R |= 0x03; // Se activan las funciones alternas de PA0 y PA1.
GPIO_PORTA_DEN_R |= 0x03; // Habilitación PA0 y PA1 para señales digitales.
}
/*Función para la transmisión de un caracter*/
void txcar_uart0(uint32_t car){
while ((UART0_FR_R & UART_FR_TXFF)!=0); //Espera que esté disponible para transmitir
UART0_DR_R = car;
}
/*Función para la recepción de un carácter de 8 bits*/
uint8_t rxcar_uart0(void){
uint8_t temp;
while ((UART0_FR_R & UART_FR_RXFE)!=0); // Se espera que llegue un dato
temp= UART0_DR_R&0xFF; // Se toman solo 8 bits
return temp;
}
/*Funcion para el envio de una cadena*/
void txmens_uart0(uint8_t mens[]){
uint8_t letra;
uint8_t i=0;
letra= mens[i++];
while (letra != '\0'){ //Se envían todos los caracteres hasta el fin de cadena
txcar_uart0(letra);
letra= mens[i++];
}
}

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 9

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU
FACULTAD DE CIENCIAS E INGENIERIA
SECCION ELECTRICIDAD Y ELECTRONICA

void main(void){
/*Mensajes a utilizar*/
uint8_t mInicio[]= "Ingrese letra\n\r";
uint8_t mFin[]= "Palabra correcta\n\r";
uint8_t oculta[]= "************\n\n\r"; // Arreglo para guardar las letras acertadas
uint8_t palabra[]= "TivaLauchpad";
uint8_t aciertos=0; // Contador de aciertos
uint8_t letra, i;
uint8_t longPalabra;
config_uart0(); // Se configura el UART
longPalabra = sizeof(palabra)-1; // Longitud de la palabra sin el caracter nulo
while(aciertos<longPalabra){ // Se esperan los aciertos de la
// longitud de la palabra
txmens_uart0(mInicio);
letra= rxcar_uart0();
for(i=0; i<longPalabra; i++){
if ((letra == palabra[i])&&(oculta[i]=='*')){
oculta[i]= letra;
aciertos++;
} // Se reemplazan los asteriscos por la letra correspondiente
} // y se incrementa el número de aciertos siempre que no hayan
// sido previamente reemplazados
txmens_uart0(oculta);
}
txmens_uart0(mFin); // Se transmite el mensaje de Fin
while (1);
}

Resultado
Se observa los resultados obtenidos, luego de ejecutar el programa con la aplicación hyperterminal.

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 10

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU
FACULTAD DE CIENCIAS E INGENIERIA
SECCION ELECTRICIDAD Y ELECTRONICA

Programa 3
Ejemplo con el Systick Timer
El programa hace parpadear el led D1 del módulo LaunchPad Tiva con distintos periodos de tiempo
obtenidos a partir de la programación del módulo Systick Timer del microcontrolador. Los periodos son
variados de manera cíclica al presionar y soltar el pulsador SW1 del módulo y son los siguientes:
0.5seg, 0.25seg, 0.125seg, 0.0625seg y 0.03125seg.

Diagrama de flujo:

Inicio

Configuración puertos,
configuración Systick

incrementar ß 0

Sí
¿Llegó a 0 el Conmutar Led
temporizador?

No Sí
¿incrementar =
No 0?
¿Se presionó y
soltó SW1?

Sí cuenta ß cuenta +1

incrementar ß incrementar +1
No
¿cuenta>=5?

Sí

cuenta ß 0

temporizador ß tiempo[cuenta]

incrementar ß 0

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 11

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU
FACULTAD DE CIENCIAS E INGENIERIA
SECCION ELECTRICIDAD Y ELECTRONICA

/* Proyecto: Temporizador
* Autor: Ing. Fedra Trujillano
* Semestre: 2016-1
* Descripción:
* El programa hace parpadear el led D1 del módulo Tiva Launchpad con distintos
* Periodos que son variados de manera cíclica al presionar y soltar el pulsador SW1.
* Los periodos son los siguientes:
* 0.5seg, 0.25seg, 0.125seg, 0.0625seg y 0.03125seg.
*/

#include "tm4c123gh6pm.h"
#include "stdint.h"

uint32_t tiempos[5] = { 0x7A11FF, 0x3D08FF, 0x1E847F, 0xF423F, 0x7A11F };

// 0.5 = 1/16MHz(Reload + 1) -> Reload = 0x7A11FF.

void config_pulsador_led(void) {
unsigned long temp;

SYSCTL_RCGC2_R |= SYSCTL_RCGC2_GPIOF; // Se habilita el reloj del Puerto F

temp = SYSCTL_RCGC2_R; // Espera a que se estabilice el reloj
GPIO_PORTF_AMSEL_R &= ~(0X12); // Se deshabilitan las funciones analógicas
GPIO_PORTF_PCTL_R &= ~(0X000FFFFF); // Se asegura que los pines no estén
// configurados para otras funciones (no GPIO)
GPIO_PORTF_DIR_R &= ~(0X10); // Se configura PF4(SW1) como entrada
GPIO_PORTF_DIR_R |= 0X02; // Se configura PF1(D1) como salida
GPIO_PORTF_AFSEL_R &= ~(0X12); // Se configuran los pines como GPIO
GPIO_PORTF_PUR_R |= 0X10; // Se activan la resist. pull-up de la entrada PF4
GPIO_PORTF_DR8R_R |= 0X02; // Se activan los controladores de hasta 8mA
GPIO_PORTF_DEN_R |= 0X12; // Se habilitan las salidas digitales
}

// Función que tiene como parámetro de entrada el indice de la tabla de tiempos.

// y configura el Systick para iniciar el decremento de la cuenta en ese valor.

void configSystick(uint16_t valor) {

// Deshabilita el Systick para proceder a la configuración
NVIC_ST_CTRL_R &= ~NVIC_ST_CTRL_ENABLE;
// Carga el tiempo entre encendido y apagado del led.
NVIC_ST_RELOAD_R = tiempos[valor];
//Habilitar el Systickasi como la señal de reloj
NVIC_ST_CTRL_R |= NVIC_ST_CTRL_ENABLE + NVIC_ST_CTRL_CLK_SRC;
}

int main(void) {
uint32_t temp;
uint8_t cuenta = 0;
uint8_t SwNoPresionado = 1; // Bandera que ayuda a determinar si
// el pulsador ya ha sido presionado
uint8_t incrementa = 0;

config_pulsador_led();
configSystick(cuenta); // Inicia con el parpadeo en 0.5 seg

while (1) {
// Se espera que la cuenta del Systick llegue a cero y se sondea
// durante la espera el pulsador SW1.

while ((NVIC_ST_CTRL_R & NVIC_ST_CTRL_COUNT) == 0) {

temp = GPIO_PORTF_DATA_R;

if (((temp & 0x10) == 0x00) && (SwNoPresionado == 1)) {

SwNoPresionado = 0; // para indicar que ya ha sido presionado
}

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 12

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU
FACULTAD DE CIENCIAS E INGENIERIA
SECCION ELECTRICIDAD Y ELECTRONICA

if (SwNoPresionado == 0) {

if (((temp& 0x10) == 0x10)) { // Se sondea si se ha soltado

SwNoPresionado = 1;
incrementa = 1;
}
}
}

GPIO_PORTF_DATA_R ^= 0x02; // Se conmuta el estado del led

if (incrementa == 1) {

cuenta += 1;
if (cuenta == 5) {
cuenta = 0;
}

configSystick(cuenta); // Se configura con el periodo siguiente

incrementa = 0; // Se limpia para saber que ya se ejecutó la acción
}

}
}

Programa 4
Ejemplo con el Systick Timer y UART
Desarrolle un programa, en base a la tarjeta de desarrollo Tiva Launchpad, que genere una cuenta
ascendente del 1 al 9 de forma continua, la cuenta se incrementará en intervalos de 0.5 seg; esta cuenta se
podrá visualizar en un emulador terminal por comunicación serial (Hyperterminal o PuTTY). Con el
pulsador SW1 podrá detener la cuenta, y esta se reanudará cuando vuelva a presionar y soltar el mismo
pulsador, cada vez que presione y suelte el SW2 podrá reiniciar la cuenta.
Los pulsador SW2 (PF0) y SW1 (PF4) son los que se encuentran en la tarjeta Tiva.
Configuración Serial del UART: 115.2k, 8bits, 1bit de parada, sin paridad.

Resultado en la aplicación Putty

Se utilizó el puerto 44, pero en su PC podría ser otro puerto. Revise en administrador de dispositivos el
puerto asignado

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 13

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU
FACULTAD DE CIENCIAS E INGENIERIA
SECCION ELECTRICIDAD Y ELECTRONICA

Diagrama de Flujo

Inicio

Configuración Uart
Configuración de Systick
Configuración de puerto F

Inicialización variables

1
S N
I=I+1 í ¿Pasó 0.1seg? o

N
N N o
¿SW1 ¿SW2
Presionado?
o Presionado?
o I>5

S S S
í í í
N N I=0
¿SW1 o ¿SW2 o Actualizar Cuenta
Soltado? Soltado?

S Txcar_Uart(Cuenta)
í Cuenta = 1
N I=0
¿SW1 o
Presionado
y Soltado?
Sí
Txcar_Uart(Cuenta)

Código documentado del programa.

/* Proyecto: Contador_serial
* Autor: Ing. Jhonnell Fernandez
* Semestre: 2016-1
* Descripción:
Este programa genera una cuenta del 1 al 9 en intervalos de 0.5 seg.
Se podrá visualizar mediante un emulador de terminal serial.
El pulsador SW1 detiene la cuenta y el pulsador SW2 reinicia la cuenta
Uart Conf: 115.2K, 8bits, 1 bit de parada, sin paridad */

#include "tm4c123gh6pm.h"
#include "stdint.h"

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 14

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU
FACULTAD DE CIENCIAS E INGENIERIA
SECCION ELECTRICIDAD Y ELECTRONICA

/** Configuracion del UART **/

void config_uart0 (void)
{

int temp;
SYSCTL_RCGC1_R |= SYSCTL_RCGC1_UART0; // Se activa UART0

temp = SYSCTL_RCGC1_R;

SYSCTL_RCGC2_R |= SYSCTL_RCGC2_GPIOA; // Se activa el puerto A

temp = SYSCTL_RCGC2_R;
UART0_CTL_R &= ~UART_CTL_UARTEN; // Se recomienda deshabilitar el UART para
// cambiar los parametros

UART0_IBRD_R = (UART0_IBRD_R & ~UART_IBRD_DIVINT_M)|8; // IBRD =

//int(16,000,000/(16*115,200)) = int(8.68055)

UART0_FBRD_R = (UART0_FBRD_R & ~UART_FBRD_DIVFRAC_M)|43; // FBRD = round(0.68055 * 64)

// = 43.55

UART0_LCRH_R = ((UART0_LCRH_R & ~0x000000FF)|(UART_LCRH_WLEN_8)|(UART_LCRH_FEN));

// 8 bit, 1 bit de parada, Sin paridad, Se habilitan la FIFO de Tx y Rx

UART0_CTL_R |= UART_CTL_UARTEN; // Habilita UART

GPIO_PORTA_AFSEL_R |= 0x03; // Habilita la func. alternativa de PA0/1
GPIO_PORTA_DEN_R |= 0x03; // Habilita la func. de E/S digital de PA0/1
GPIO_PORTA_PCTL_R = (GPIO_PORTA_PCTL_R&0xFFFFFF00)+0x00000011; //Configura la función
// alternativa en PA0/1
GPIO_PORTA_AMSEL_R &= ~0x03; // Deshabilita func. analogicas de PA0/1

/* Transmite 1 Caracter por Uart */

void txcar_uart0 (uint8_t dato)
{
while((UART0_FR_R & UART_FR_TXFF)!=0);// Espera a que TXFF sea 0 (Buffer vacio)
UART0_DR_R = dato;
}

/* Configuracion del temporizador del reloj del sistema */

void config_systick (void)
{ NVIC_ST_CTRL_R &= ~NVIC_ST_CTRL_ENABLE; // Deshabilita el Systick
NVIC_ST_RELOAD_R |= 0x1869FF; // Se escribe 1599999 en Hex para que cada
//(0.1seg)10Hz = 16000000 / (1599999+1) haya un evento
NVIC_ST_CURRENT_R = 0; // Renicia la cuenta actual
NVIC_ST_CTRL_R |= NVIC_ST_CTRL_ENABLE + NVIC_ST_CTRL_CLK_SRC; // Habilitar el Systick
// y la señal de reloj
}

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 15

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU
FACULTAD DE CIENCIAS E INGENIERIA
SECCION ELECTRICIDAD Y ELECTRONICA
/* Configuracion del puerto F PF0 y PF4 */
void Config_puertoF (void)
{
long temp ;
SYSCTL_RCGC2_R |= SYSCTL_RCGC2_GPIOF; // (0x10) reloj activo para el puerto E
temp= SYSCTL_RCGC2_R; // esperar algunos ciclos de reloj

GPIO_PORTF_LOCK_R = 0x4c4f434b; // Código para quitar la protección en el puerto

GPIO_PORTF_CR_R |= 0X01; // Habilitar modificaciones en registros GPIO, pin PF0
GPIO_PORTF_AMSEL_R &= ~0x11; // Se desactivan funciones analógicas de pines los
// PF0/4 y se habilitan funciones digitales
GPIO_PORTF_PCTL_R &= ~0x11; // Los pines PF0 y PF4 se usarán como GPIO
GPIO_PORTF_DIR_R &= ~0x11; // Configura PF0/4 como pines de entrada
GPIO_PORTF_AFSEL_R &= ~0x11; // configura pines como GPIO
GPIO_PORTF_PUR_R |=0x11; // activar resistencias pull up
GPIO_PORTF_DEN_R |=0x11; // activar PF0/4 pines para acceso digital
}

void main(void)
{
unsigned long j;
uint8_t i=0;
uint8_t cuenta=1;
config_uart0();
config_systick();
Config_puertoF();
while(1)
{
// Para generar mayor maniobrabilidad con los pulsadores se configuro intervalos de
// espera de 0.1s de forma que cuando ocurran 5 veces, la cuenta se incremente en
// una unidad
while( (NVIC_ST_CTRL_R & NVIC_ST_CTRL_COUNT)== 0);
i++;

if((GPIO_PORTF_DATA_R&0x10)==0) // Revisa si se presiono SW1

{
for (j=0;j>500000;j++); // Retardo

while((GPIO_PORTF_DATA_R&0x10)==0); // Espera hasta soltar SW1

for (j=0;j>500000;j++); // Retardo

while((GPIO_PORTF_DATA_R&0x10)==0x10); // Espera que sea presionado

for (j=0;j>500000;j++); // Retardo

while((GPIO_PORTF_DATA_R&0x10)==0); // Espera hasta soltar pulsador

for (j=0;j>500000;j++); // Retardo

}
else if((GPIO_PORTF_DATA_R&0x01)==0) // Revisa si se presiono SW2
{
for (j=0;j>500000;j++); // Retardo

while((GPIO_PORTF_DATA_R&0x01)==0); // Espera hasta soltar SW2

cuenta = 1; // Imprime el numero de cuenta
i = 0;
txcar_uart0(cuenta+48); // Imprime el numero de cuenta
txcar_uart0(13); // Retorno de carro
}
else if (i>5)
{
cuenta++;
if (cuenta>9)
cuenta=1; // Reinicia la cuenta
i=0;
txcar_uart0(cuenta+48); // Imprime el numero de cuenta
txcar_uart0(13); // Retorno de carro
}
}
}

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 16

PONTIFICIA UNIVERSIDAD CATOLICA DEL PERU
FACULTAD DE CIENCIAS E INGENIERIA
SECCION ELECTRICIDAD Y ELECTRONICA

Problemas Propuestos:

1. Se tiene el microcontrolador del módulo LaunchPad Tiva conectado a una PC en la que se está
ejecutando el Hyperterminal. Desarrollar un programa que divida dos números enteros positivos. Los
parámetros de comunicación son: 4800, 8, E, 2

La pantalla debe verse como se muestra a continuación:

Ingrese la división: 010/003; luego mostrará los resultados

Cociente: 003
Residuo: 001

Ingrese la división: 015/000

¡¡Error!! División entre cero

2. Con respecto al manejo del módulo LaunchPad Tiva conectado con el puerto serial de la computadora
personal, implementar un programa que permita mediante el pulsador SW1, al presionar y soltarlo,
mostrar en la pantalla hyperterminal una lista de ocho números aleatorios de 3 cifras (entre 100 y 999).
Luego de mostrar ambas listas, el programa espera que el usuario presione otro pulsador del módulo
E/S Tiva para realizar una aplicación como se indica a continuación:
Si se presiona el pulsador SW2 se muestra la lista generada de aleatorios en orden descendente, si se
presiona SW3 o SW4 se muestra el menor y el mayor de la lista generada.
Para poder tener acceso al sistema debe ingresar una contraseña (se retransmite con asteriscos) que es
su apellido paterno en un tiempo de 5 segundos, de lo contrario indicará incorrecto.
Parámetros de Tx del UART: 4800, 8, e, 1
Conexiones:
SW1, SW2, SW3 Y SW4 conectados a PA4, PA3, PA2 y PA5 respectivamente. (Ver las conexiones
en el módulo E/S Tiva)

Ejemplo:

Password: ******** (no es su apellido)

Incorrecto
Password: (mayor de 5 segundos)
Incorrecto
Password: ******** ( es su apellido)
Correcto
634 254 543 223 987 435 675 333 (se obtiene al presionar SW1)
Presione un pulsador… (al presionar el Pulsador SW2, se muestra:)
987 675 634 543 435 333 254 223
Presione un pulsador ( al presionar el pulsador SW3 o SW4, se muestra:)
223 y 987
Presione un pulsador …

Material del Laboratorio N° 04 del curso de Sistemas digitales

Preparado por: Ing.Fedra Trujillano - Ing.Jhonnell Fernández - Ing.Zenón Cucho - Ing. Freri Orihuela
Profesores del curso: Ing. Hugo Pratt - Ing. Rolando Sánchez
Pontificia Universidad Católica del Perú
Actualizado al 20 de octubre de 2018

Guias_iee256_/2018-2/zcm/

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2018-2 Página 17