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 2016-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 2016-2 Página 2

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

Introducción al software de comunicaciones

El Hyperterminal

Para conectar el módulo TIVA con el puerto serial de la PC, se emplea un software de comunicación
serial, en este caso el Hyperterminal. 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.

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 )

Figura 3
Figura 2

IEE 256 SISTEMAS DIGITALES - LABORATORIO SEMESTRE 2016-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.
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.
Luego, presione Open para ingresar a la pantalla virtual donde se mostrarán nuestros resultados del
programa en ejecución.

Figura 4 Figura 5

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. En la siguiente Figura se observa que el
puerto activo es COM34.

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

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: Mayo 2016 *****/
//***** 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 2016-2 Página 5

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 Coce 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 2016-2 Página 6

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

Programa 2
Ejemplo con el UART0 para adivinar una palabra oculta grabada en memoria
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 2016-2 Página 7

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 2016-2 Página 8

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 2016-2 Página 9

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 2016-2 Página 10

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 2016-2 Página 11

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 2016-2 Página 12

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 2016-2 Página 13

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 2016-2 Página 14

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 2016-2 Página 15

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 14 de octubre de 2016

Guias_iee256_/2016-2/zcm/

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