PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ

FACULTAD DE CIENCIAS E INGENIERÍA

SISTEMAS DIGITALES
IEE256 H0522 H0523
(Segundo Semestre 2019)

TEMPORIZADOR SYSTICK

PROBLEMAS RESUELTOS

PROBLEMA 01:

Desarrollar un programa para el microcontrolador del módulo EK-TM4C123GXL que haga parpadear el led azul,
encendido durante 500ms y apagado durante 500ms. Utilizar el temporizador SysTick. La frecuencia de reloj del sistema
es de 16MHz.

SOLUCIÓN

Código del programa:

/****************************************************************************************/
/****************************************************************************************/
/***** PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ *****/
/***** FACULTAD DE CIENCIAS E INGENIERÍA *****/
/***** SISTEMAS DIGITALES *****/
/****************************************************************************************/
/***** Tema: Temporizador SysTick *****/
/***** Proyecto: SYSTICK_P01_TempLed *****/
/****************************************************************************************/
/***** Microcontrolador: TM4C123GH6PM *****/
/***** EvalBoard: Tiva C Series TM4C123G LaunchPad *****/
/***** Autor: Rolando Sánchez Ponce *****/
/***** Fecha: Octubre 2017 *****/
/***** Última revisión: Junio 2019 *****/
/****************************************************************************************/
/***** Enunciado: *****/
/***** Se configura el SysTick para temporizar 500ms. El led azul permanece 500ms *****/
/***** encendido y 500ms apagado. *****/
/***** Frecuencia de reloj del sistema 16MHz. *****/
/****************************************************************************************/
/****************************************************************************************/
#include <stdint.h>
#include "tm4c123gh6pm.h"
#include "TivaES.h"

/****************************************************************************************/
/***** ConfigSystick500ms() *****/
/****************************************************************************************/
/***** Configura el SysTick para temporizar 500ms. *****/
/***** Frecuencia de reloj del sistema 16MHz *****/
/****************************************************************************************/
/***** ENTRADAS: Ninguna *****/
/***** SALIDA: Ninguna *****/
/****************************************************************************************/
void ConfigSysTick500ms(void){
// Inhabilitamos el módulo SysTick
NVIC_ST_CTRL_R &= ~NVIC_ST_CTRL_ENABLE;
// Escribimos el tope superior del contador
NVIC_ST_RELOAD_R = (NVIC_ST_RELOAD_R&0xFF000000)|0x007A11FF;
// Iniciamos el contador con cero (escribiendo cualquier valor)
NVIC_ST_CURRENT_R &= ~(0x00FFFFFF);
// Habilitamos el módulo SysTick
NVIC_ST_CTRL_R |= (NVIC_ST_CTRL_CLK_SRC | NVIC_ST_CTRL_ENABLE);
}

/****************************************************************************************/
/***** P R O G R A M A P R I N C I P A L *****/
/****************************************************************************************/
int main(void){
uint8_t ledAzulOnFlag;
TivaES_Inicializa();
ConfigSysTick500ms();
ledAzulOnFlag = FALSE;
while(1){
// Esperamos que transcurran 500ms
while(!(NVIC_ST_CTRL_R & NVIC_ST_CTRL_COUNT));
// Actualizamos el color en el led
if(ledAzulOnFlag){
TivaES_LedColor(NEGRO);
ledAzulOnFlag = FALSE;
}
else{
TivaES_LedColor(AZUL);
ledAzulOnFlag = TRUE;
}
}
}

/****************************************************************************************/
/***** F I N D E L P R O G R A M A *****/
/****************************************************************************************/
PROBLEMA 02:

Desarrollar un programa para el módulo EK-TM4C123GXL que haga parpadear al led RGB 300ms encendido y 300ms
apagado inicialmente de color rojo. Cada vez que se presione el pulsador SW1 debe cambiar el color del led RGB según
una tabla de colores, manteniendo el parpadeo de 300ms de semiperiodo.

SOLUCIÓN

Código del programa:

/****************************************************************************************/
/****************************************************************************************/
/***** PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ *****/
/***** FACULTAD DE CIENCIAS E INGENIERÍA *****/
/***** SISTEMAS DIGITALES *****/
/****************************************************************************************/
/***** Tema: Temporizador SysTick *****/
/***** Proyecto: SYSTICK_P02_SondeoTiempoPulsador *****/
/****************************************************************************************/
/***** Microcontrolador: TM4C123GH6PM *****/
/***** EvalBoard: Tiva C Series TM4C123G LaunchPad *****/
/***** Autor: Rolando Sánchez Ponce *****/
/***** Fecha: Junio 2019 *****/
/****************************************************************************************/
/***** Enunciado: *****/
/***** El led RGB parpadea 300ms encendido y 300ms apagado inicialmente de color *****/
/***** rojo. Cada vez que se presiona el pulsador SW1 se debe cambiar el color del *****/
/***** led RGB manteniendo el parpadeo. *****/
/***** Frecuencia de reloj del sistema 16MHz. *****/
/****************************************************************************************/
/****************************************************************************************/
#include <stdint.h>
#include "tm4c123gh6pm.h"
#include "TivaES.h"

const uint8_t TablaColor[] = {ROJO, AZUL, VERDE, AMARILLO, MAGENTA, CIAN, BLANCO};

/****************************************************************************************/
/***** ConfigSystick300ms() *****/
/****************************************************************************************/
/***** Configura el SysTick para temporizar 300ms. *****/
/***** Frecuencia de reloj del sistema 16MHz *****/
/****************************************************************************************/
/***** ENTRADAS: Ninguna *****/
/***** SALIDA: Ninguna *****/
/****************************************************************************************/
void ConfigSysTick300ms(void){
// Inhabilitamos el módulo SysTick
NVIC_ST_CTRL_R &= ~NVIC_ST_CTRL_ENABLE;
// Escribimos el tope superior del contador
NVIC_ST_RELOAD_R = (NVIC_ST_RELOAD_R&0xFF000000)|0x00493DFF;
// Iniciamos el contador con cero (escribiendo cualquier valor)
NVIC_ST_CURRENT_R &= ~(0x00FFFFFF);
// Habilitamos el módulo SysTick
NVIC_ST_CTRL_R |= (NVIC_ST_CTRL_CLK_SRC | NVIC_ST_CTRL_ENABLE);
}

/****************************************************************************************/
/***** SondeaSystick() *****/
/****************************************************************************************/
/***** Revisa si el contador CURRENT alcanzó el valor de cero y por lo tanto el bit *****/
/***** COUNT es 1 *****/
/****************************************************************************************/
/***** ENTRADAS: Ninguna *****/
/***** SALIDA: TRUE: bit COUNT en 1 *****/
/***** FALSE: bit COUNT en 0 *****/
/****************************************************************************************/
uint8_t SondeaSystick(void){
uint8_t pasoTiempoFlag;
pasoTiempoFlag = FALSE;
if(NVIC_ST_CTRL_R & NVIC_ST_CTRL_COUNT){
pasoTiempoFlag = TRUE;
}
return pasoTiempoFlag;
}

/****************************************************************************************/
/***** P R O G R A M A P R I N C I P A L *****/
/****************************************************************************************/
int main(void){
uint8_t ledRGBonFlag, longTabla, antSW1, i, color;

// Configuramos el sistema
TivaES_Inicializa();
ConfigSysTick300ms();

// Inicializamos variables
i = 0;
color = TablaColor[i];
ledRGBonFlag = FALSE;
longTabla = sizeof(TablaColor);
antSW1 = TivaES_LeePulsador(SW1);

// Lazo infinito
while(1){
// Si se presiona SW1 actualizamos el color a mostrar en el led RGB
if(TivaES_SondeaPulsador(SW1, &antSW1)){
i++;
if(i==longTabla) i = 0;
color = TablaColor[i];
}
// Si pasaron 300ms encendemos a apagamos el led RGB
if(SondeaSystick()){
if(ledRGBonFlag){
TivaES_LedColor(NEGRO);
ledRGBonFlag = FALSE;
}
else{
TivaES_LedColor(color);
ledRGBonFlag = TRUE;
}
}
}
}

/****************************************************************************************/
/***** F I N D E L P R O G R A M A *****/
/****************************************************************************************/
PROBLEMA 03:

Desarrollar un programa para el módulo EK-TM4C123GXL que haga parpadear al led RGB inicialmente con un
semiperiodo de 500ms y de color rojo. Cada 5 segundos debe actualizarse el color del led RGB según una tabla de
colores. Cada vez que se presione el SW1 el semiperiodo de parpadeo debe disminuir en 100ms y cada vez que se
presione el SW2 aumentar en 100ms, el semiperiodo debe estar entre 100ms y 1s.

SOLUCIÓN

Código del programa:

/****************************************************************************************/
/****************************************************************************************/
/***** PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ *****/
/***** FACULTAD DE CIENCIAS E INGENIERÍA *****/
/***** SISTEMAS DIGITALES *****/
/****************************************************************************************/
/***** Tema: Temporizador SysTick *****/
/***** Proyecto: SYSTICK_P03_SondeoTiemposPulsadores *****/
/****************************************************************************************/
/***** Microcontrolador: TM4C123GH6PM *****/
/***** EvalBoard: Tiva C Series TM4C123G LaunchPad *****/
/***** Autor: Rolando Sánchez Ponce *****/
/***** Fecha: Junio 2019 *****/
/****************************************************************************************/
/***** Enunciado: *****/
/***** El led RGB parpadea inicialmente 500ms encendido y 500ms apagado inicialmen- *****/
/***** de color rojo. Cada 5 segundos debe cambiar el color del led RGB según una *****/
/***** tabla manteniendo el parpadeo. Cada vez que se presiona el pulsador SW1 el *****/
/***** semiperiodo disminuye en 100ms y cada vez que se presiona SW2 el semiperiodo *****/
/***** aumenta en 100ms, el semiperiodo debe estar entre 100ms y 1s. *****/
/***** Frecuencia de reloj del sistema 16MHz. *****/
/****************************************************************************************/
/****************************************************************************************/
#include <stdint.h>
#include "tm4c123gh6pm.h"
#include "TivaES.h"

const uint8_t TablaColor[] = {ROJO, AZUL, VERDE, AMARILLO, MAGENTA, CIAN, BLANCO};

/****************************************************************************************/
/***** F U N C I O N E S *****/
/****************************************************************************************/

/****************************************************************************************/
/***** ConfigSystick100ms() *****/
/****************************************************************************************/
/***** Configura el SysTick para temporizar 100ms. *****/
/***** Frecuencia de reloj del sistema 16MHz *****/
/****************************************************************************************/
/***** ENTRADAS: Ninguna *****/
/***** SALIDA: Ninguna *****/
/****************************************************************************************/
void ConfigSysTick100ms(void){
NVIC_ST_CTRL_R &= ~NVIC_ST_CTRL_ENABLE;
NVIC_ST_RELOAD_R = (NVIC_ST_RELOAD_R&0xFF000000)|0x001869FF;
NVIC_ST_CURRENT_R &= ~(0x00FFFFFF);
NVIC_ST_CTRL_R |= (NVIC_ST_CTRL_CLK_SRC | NVIC_ST_CTRL_ENABLE);
}
/****************************************************************************************/
/***** SondeaSystick() *****/
/****************************************************************************************/
/***** Revisa si el contador CURRENT alcanzó el valor de cero y por lo tanto el bit *****/
/***** COUNT es 1 *****/
/****************************************************************************************/
/***** ENTRADAS: Ninguna *****/
/***** SALIDA: TRUE: bit COUNT en 1 *****/
/***** FALSE: bit COUNT en 0 *****/
/****************************************************************************************/
uint8_t SondeaSystick(void){
uint8_t pasoTiempoFlag;
pasoTiempoFlag = FALSE;
if(NVIC_ST_CTRL_R & NVIC_ST_CTRL_COUNT){
pasoTiempoFlag = TRUE;
}
return pasoTiempoFlag;
}

/****************************************************************************************/
/***** P R O G R A M A P R I N C I P A L *****/
/****************************************************************************************/
int main(void){
uint8_t ledRGBonFlag, longTabla, antSW1, antSW2, i, color;
uint8_t tempColor, tempLed, cntTpoColor, cntTpoLed;
// Configuramos el sistema:
TivaES_Inicializa();
ConfigSysTick100ms();
// Inicializamos variables:
i = 0;
color = TablaColor[i];
longTabla = sizeof(TablaColor);
ledRGBonFlag = FALSE;
antSW1 = TivaES_LeePulsador(SW1);
antSW2 = TivaES_LeePulsador(SW2);
cntTpoColor = 0;
cntTpoLed = 0;
tempColor = 50;
tempLed = 5;

// Lazo infinito
while(1){
// Si se presiona SW1 disminuimos el semiperiodo en 100ms
if(TivaES_SondeaPulsador(SW1, &antSW1)){
if(tempLed > 1){
tempLed--;
}
}
// Si se presiona SW2 aumentamos el semiperiodo en 100ms
if(TivaES_SondeaPulsador(SW2, &antSW2)){
if(tempLed < 10){
tempLed++;
}
}
// Si pasaron 100ms
if(SondeaSystick()){
// Si se cumplio el tiempo de semiperiodo actualizar el led
cntTpoLed++;
if(cntTpoLed >= tempLed){
cntTpoLed = 0;
if(ledRGBonFlag){
TivaES_LedColor(NEGRO);
ledRGBonFlag = FALSE;
}
 else{
TivaES_LedColor(color);
ledRGBonFlag = TRUE;
}
}
// Si pasaron 5s se debe actualizar el color del led RGB
cntTpoColor++;
if(cntTpoColor >= tempColor){
cntTpoColor = 0;
i++;
if(i==longTabla) i = 0;
color = TablaColor[i];
}
}
}
}

/****************************************************************************************/
/***** F I N D E L P R O G R A M A *****/
/****************************************************************************************/
PROBLEMA 04:

Se tiene conectado al módulo EK-TM4C123GXL una computadora personal en la que se está ejecutando un programa
Terminal Serial (PuTTY). Se quiere desarrollar un programa para el microcontrolador que transmita por el puerto serial,
cada 800ms, un carácter ASCII alfabético mayúscula de manera ascendente o descendente. Cada vez que se presione el
pulsador SW2 debe cambiarse de modo ascendente a descendente y viceversa. Cada vez que se reciba por el puerto
serial un carácter alfabético en mayúscula la transmisión se actualiza con el carácter recibido.

Temporizar utilizando el SysTick, los parámetros de comunicación serial deben ser 9600, 8, N, 1 y la frecuencia del
reloj del sistema es de 16MHz.

SOLUCIÓN

Código del programa:

/****************************************************************************************/
/****************************************************************************************/
/***** PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ *****/
/***** FACULTAD DE CIENCIAS E INGENIERÍA *****/
/***** SISTEMAS DIGITALES *****/
/****************************************************************************************/
/***** Tema: Temporizador SysTick *****/
/***** Proyecto: SYSTICK_P04_SndoTpoPulDatoRx *****/
/****************************************************************************************/
/***** Microcontrolador: TM4C123GH6PM *****/
/***** EvalBoard: Tiva C Series TM4C123G LaunchPad *****/
/***** Autor: Rolando Sánchez Ponce *****/
/***** Fecha: Octubre 2017 *****/
/***** Última revisión: Junio 2019 *****/
/****************************************************************************************/
/***** Enunciado: *****/
/***** Se transmiten por el puerto serial los códigos ASCII de las letras mayúscu- *****/
/***** las de manera cíclica ascendente o descendentemente, con un intervalo de *****/
/***** 800ms entre cada transmisión. Cada vez que se presiona el pulsador SW2 se *****/
/***** cambia el modo de ascendente a descendente o viceversa. Cada vez que se re- *****/
/***** cibe por el puerto serial una letra mayúscula, la transmisión se actualiza *****/
/***** con la letra recibida sin cambiar la temporización ni el modo. *****/
/***** Parámetros para comunicación serial: 9600, 8, N, 1. *****/
/***** Frecuencia de reloj del sistema 16MHz. *****/
/****************************************************************************************/
/****************************************************************************************/
#include <stdint.h>
#include "tm4c123gh6pm.h"
#include "TivaES.h"
#include "UART.h"

#define modoAscendente 0
#define modoDescendente 1

/****************************************************************************************/
/***** F U N C I O N E S *****/
/****************************************************************************************/

/****************************************************************************************/
/***** ConfigSystick800ms() *****/
/****************************************************************************************/
/***** Configura el SysTick para temporizar 800ms. *****/
/***** Frecuencia de reloj del sistema 16MHz *****/
/****************************************************************************************/
/***** ENTRADAS: Ninguna *****/
/***** SALIDA: Ninguna *****/
/****************************************************************************************/
void ConfigSysTick800ms(void){
NVIC_ST_CTRL_R &= ~NVIC_ST_CTRL_ENABLE;
NVIC_ST_RELOAD_R = (NVIC_ST_RELOAD_R&0xFF000000)|0x00C34FFF;
NVIC_ST_CURRENT_R &= ~(0x00FFFFFF);
NVIC_ST_CTRL_R |= (NVIC_ST_CTRL_CLK_SRC | NVIC_ST_CTRL_ENABLE);
}

/****************************************************************************************/
/***** SondeaSystick() *****/
/****************************************************************************************/
/***** Revisa si el contador CURRENT alcanzó el valor de cero y por lo tanto el bit *****/
/***** COUNT es 1 *****/
/****************************************************************************************/
/***** ENTRADAS: Ninguna *****/
/***** SALIDA: TRUE: bit COUNT en 1 *****/
/***** FALSE: bit COUNT en 0 *****/
/****************************************************************************************/
uint8_t SondeaSystick(void){
uint8_t pasoTiempoFlag;
pasoTiempoFlag = FALSE;
if(NVIC_ST_CTRL_R & NVIC_ST_CTRL_COUNT){
pasoTiempoFlag = TRUE;
}
return pasoTiempoFlag;
}

/****************************************************************************************/
/***** actualizaLetra() *****/
/****************************************************************************************/
/***** Actualiza letra dependiendo de su valor actual y del modo que puede ser *****/
/***** ascendente o descendente. *****/
/****************************************************************************************/
/***** ENTRADAS: *****/
/***** letra: Código ASCII de letra mayúscula. *****/
/***** modo: Modo de actualización, puede ser modoAscendente o *****/
/***** modoDescendente. *****/
/***** SALIDA: letra actualizada. *****/
/****************************************************************************************/
uint8_t actualizaLetra(uint8_t letra, uint8_t modo){
if(modo ==modoAscendente){
if(letra=='Z') letra = 'A';
else letra++;
}
else{
if(letra=='A') letra = 'Z';
else letra--;
}
return letra;
}

/****************************************************************************************/
/***** P R O G R A M A P R I N C I P A L *****/
/****************************************************************************************/
int main(void){
uint8_t letra, modoTrabajo, datoRx, antSW2;
// Configuramos el sistema
TivaES_Inicializa();
UART_Inicializa();
ConfigSysTick800ms();
// Inicializamos variables
letra = 'A';
modoTrabajo = modoAscendente;
antSW2 = TivaES_LeePulsador(SW2);
 // Lazo infinito
while(1){
// Si pasaron 800ms
if(SondeaSystick()){
UART_TransmiteDato(letra);
letra = actualizaLetra(letra, modoTrabajo);
}
// Si hay dato recibido en el puerto serial
if(UART_SondeaRx(&datoRx)){
if(('A'<=datoRx)&&(datoRx<='Z')) letra = datoRx;
}
// Si se ha presionado el pulsador SW2
if(TivaES_SondeaPulsador(SW2, &antSW2)){
if(modoTrabajo == modoAscendente) modoTrabajo = modoDescendente;
else modoTrabajo = modoAscendente;
letra = actualizaLetra(letra, modoTrabajo);
letra = actualizaLetra(letra, modoTrabajo);
}
}
}

/****************************************************************************************/
/***** F I N D E L P R O G R A M A *****/
/****************************************************************************************/
PROBLEMA 05:

Desarrollar un programa para el microcontrolador del módulo EK-TM4C123GXL que muestre la siguiente secuencia
de colores en el led RGB de manera cíclica: azul durante 300ms, cian durante 200ms, verde durante 500ms y apagado
durante 1segundo. Utilizar el temporizador SysTick. La frecuencia de reloj del sistema es de 16MHz.

SOLUCIÓN

Código del programa:

/****************************************************************************************/
/****************************************************************************************/
/***** PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ *****/
/***** FACULTAD DE CIENCIAS E INGENIERÍA *****/
/***** SISTEMAS DIGITALES *****/
/****************************************************************************************/
/***** Tema: Temporizador SysTick *****/
/***** Proyecto: SYSTICK_P05_Retardo *****/
/****************************************************************************************/
/***** Microcontrolador: TM4C123GH6PM *****/
/***** EvalBoard: Tiva C Series TM4C123G LaunchPad *****/
/***** Autor: Rolando Sánchez Ponce *****/
/***** Fecha: Octubre 2017 *****/
/***** Última revisión: Junio 2019 *****/
/****************************************************************************************/
/***** Enunciado: *****/
/***** Se quiere mostrar en el led RGB el color AZUL durante 300ms, luego el CIAN *****/
/***** durante 200ms, el VERDE durante 500ms y finalmente el led deberá permanecer *****/
/***** apagado durante 1s. Esto de manera cíclica. *****/
/***** Frecuencia de reloj del sistema 16MHz. *****/
/****************************************************************************************/
/****************************************************************************************/
#include <stdint.h>
#include "tm4c123gh6pm.h"
#include "TivaES.h"

/****************************************************************************************/
/***** F U N C I O N E S *****/
/****************************************************************************************/

/****************************************************************************************/
/***** ConfigSystickCarreraLibre() *****/
/****************************************************************************************/
/***** Configura el SysTick con el contador en carrera libre. *****/
/***** Frecuencia de reloj del sistema 16MHz *****/
/****************************************************************************************/
/***** ENTRADAS: Ninguna *****/
/***** SALIDA: Ninguna *****/
/****************************************************************************************/
void ConfigSysTickCarreraLibre(void){
NVIC_ST_CTRL_R &= ~NVIC_ST_CTRL_ENABLE;
NVIC_ST_RELOAD_R = (NVIC_ST_RELOAD_R&0xFF000000)|0x00FFFFFF;
NVIC_ST_CURRENT_R &= ~(0x00FFFFFF);
NVIC_ST_CTRL_R |= NVIC_ST_CTRL_CLK_SRC | NVIC_ST_CTRL_ENABLE;
}

/****************************************************************************************/
/***** retardo_ms() *****/
/****************************************************************************************/
/***** Lazo de espera que demora los milisegundos especificados en la entrada. *****/
/***** Debe configurarse el contador del Systick como carrera libre. *****/
/***** Frecuencia de reloj del sistema 16MHz *****/
/****************************************************************************************/
/***** ENTRADAS: *****/
/***** cantidad_ms: Cantidad de ms que dura el retardo. *****/
/***** Rango [0, 4294967295] = [0, 49.71 días] *****/
/***** SALIDA: Ninguna *****/
/****************************************************************************************/
void retardo_ms(uint32_t cantidad_ms){
uint32_t inicioContador, actualContador, diferenciaContador, i;
// Bucle que se repite cantidad_ms veces
for(i=0; i<cantidad_ms; i++){
inicioContador = NVIC_ST_CURRENT_R & 0x00FFFFFF;
// retardo de 1ms
do{
actualContador = NVIC_ST_CURRENT_R & 0x00FFFFFF;
diferenciaContador = (inicioContador-actualContador)&0x00FFFFFF;
}while(diferenciaContador<16000);
}
}

/****************************************************************************************/
/***** P R O G R A M A P R I N C I P A L *****/
/****************************************************************************************/
int main(void){
TivaES_Inicializa();
ConfigSysTickCarreraLibre();
while(1){
TivaES_LedColor(AZUL);
retardo_ms(300);
TivaES_LedColor(CIAN);
retardo_ms(200);
TivaES_LedColor(VERDE);
retardo_ms(500);
TivaES_LedColor(NEGRO);
retardo_ms(1000);
}
}

/****************************************************************************************/
/***** F I N D E L P R O G R A M A *****/
/****************************************************************************************/

Rolando Sánchez Ponce

Junio 2019