Universidad Tecnológica de la Mixteca

Instituto de Electrónica y Mecatrónica

Procesamiento Digital de Señales

Guía de Programación de la tarjeta TM4C1294

José Antonio Moreno Espinosa

Acatlima, Huajuapan, Oax.

Marzo de 2019
Introducción

La materia de Procesamiento Digital de Señales (PDS) se imparte en las

carreras de Ingeniería en Electrónica, Ingeniería en Mecatronica e
Ingeniería en Física Aplicada de la Universidad Tecnológica de la Mixteca.
Es una materia que tiene fuertes fundamentos matemáticos pero que tiene
aplicación en una gran cantidad de dispositivos y procesos muy usados en
la actualidad.

El alumno que tiene un primer acercamiento al PDS se ve alentado al

experimentar el resultado de la aplicación de algoritmos en señales de su
interés, por ejemplo al ecualizar una señal de audio. Esta experimentación
requiere del uso de microprocesadores o microcontroladores, y si estos
tienen capacidades de realizar operaciones con punto flotante, los
experimentos se implementan más rápidamente y con señales de entrada
de mayor frecuencia.

Las tarjetas del tipo Arduino son muy populares en ambientes de

ingeniería y en otros campos como el diseño. Sin embargo, los modelos más
populares como la Arduino UNO está basada en un microcontrolador que
no permiten realizar PDS en tiempo real para señales a velocidades mas
allá de algunos cientos de Hz.

Las tarjetas basadas en microcontroladores con arquitectura ARM Cortex

M3 o M4 son de precios accesibles y permiten procesar señales con
frecuencia máxima de algunas decenas de kHz. Entre la gran variedad de
tarjetas de evaluación que existe en el mercado se pueden mencionar la
Arduino DUE, la STM32F4 Discovery y la TM4C1294 de la empresa Texas
Instruments.

Distintos fabricantes proporcionan ambientes de desarrollo integrados

(IDE) donde se puede implementar sistemas para las tarjetas mencionadas.
En este manual se describe rápidamente la manera de programar la tarjeta
TM4C1294 usando el IDE Code Composer Studio v. 6.2

En esta guía se presentan programas recopilados de varias fuentes de uso

libre, adaptados y probados. Se considera que los alumnos ya tienen
conocimientos de Lenguaje de programación C y programación de
microcontroladores obtenidos en los semestres previos, por lo que algunos
conceptos no se desarrollan en profundidad.

Texas Instruments Inc., la empresa fabricante de la tarjeta y el

microcontrolador en la que se basa (tm4c1294ncpdt), proporciona además
una serie de documentos que se usarán como referencia en esta guía, con la
finalidad de mantenerla compacta.
Todas las sugerencias y observaciones son bienvenidas, de forma personal
o al correo electrónico jamoreno@mixteco.utm.mx

Documentos de referencia.

Cuaderno de trabajo del taller de la Launchpad Conectada

Creating IoT Solutions with the Tiva® C Series Connected LaunchPad
Workshop Revision 1.04
En este documento se encuentra información acerca de las características
del procesador, la instalación del Code Composer Studio, la estructura de
los programas y ejemplos de programación.

Guía de Usuario de la Librería para Periféricos TivaWare

TivaWare™ Peripheral Driver Library User’s Guide
En este documento se encuentra la descripción de funciones que se
encuentran en la librería TivaWare y que facilitan el desarrollo de
aplicaciones donde se usan periféricos de dicho microcontrolador.

Hoja de datos del microcontrolador TM4C1294NCPDT

Tiva™ TM4C1294NCPDT Microcontroller DATA SHEET
En este documento se detalla como funciona el microcontrolador
TM4C1294NCPDT en el que se basa la tarjeta TM4C1294

Guia de usuario de la tarjeta CLP1294

Tiva™ C Series TM4C1294 Connected LaunchPad Evaluation Kit User's
Guide
En este documento se describe la estructura y la disposición de los
componentes en la tarjeta TM4C123G

Es recomendable que el alumno instale el Code Composer Studio y la

librería TivaWare y realice las configuraciones necesarias para que se
pueda acceder a las funciones de librería desde los programas escritos en
Lenguaje C en el Code Composer Studio, siguiendo las instrucciones que se
encuentran en el cuaderno de trabajo mencionado anteriormente.
El laboratorio 2 del taller de la tarjeta Tiva C es importante ya que
muestra la forma de configurar las variables de entorno y las rutas para las
librerías.
Estructura de los programas para la tarjeta Tiva C Launchpad

En general, la estructura de los programas mostrados es la siguiente:

1. Establecer la frecuencia del reloj del sistema

2. Iniciar los distintos periféricos que se usan en el sistema, entre ellos los
puertos de Entrada/Salida
3. Lazo infinito donde se realizarán las tareas del sistema. Algunas o
todas estas tareas se pueden realizar en rutinas de atención a
interrupción
Terminales de la Tiva C Launchpad TM4C123G
Ejemplo 1

Encendido de dos Led de la tarjeta TM4C1294

En el primer ejemplo se muestra un programa que enciende

alternadamente un par de leds (D1 y D2) que se encuentra en la tarjeta. De
acuerdo a la guía del usuario de la tarjeta, las terminales que están
conectadas a los led son las que se muestran en la tabla 1.1
Led Terminal GPIO
D1 PN1
D2 PN0
Tabla 1.1 Terminales de los led D1 y D2 en la tarjeta TM4C1294

El programa usa las funciones que se incluyen en la librería TivaWare con

el propósito de facilitar la programación.

Establecemos el reloj del sistema mediante una función de la librería

TivaWare, SysCtlClockFreqSet. En la página 483 del manual de la librería
Tivaware (SPMU298D) se describe esta función. En la página 230 de la
hoja de datos del microcontrolador TM4C1294NCPDT Microcontroller DATA
SHEET, se explica con más detalle la manera en que se controla el reloj
dentro del microcontrolador.

Las terminales que controlan al led se encuentran en el puerto N, por lo

que se debe habilitar el reloj en ese puerto usando la función de TivaWare
SysCtlPeripheralEnable(página 501, SPMU298D) y además se deben
configurar como salidas las terminales PN[1:0] que son las que están
conectadas a los led, usando la función GPIOPinTypeGPIOOutput (página
268, SPMU298D) Para escribir en las terminales del GPIO usamos la
función GPIOPinWrite (página 280, SPMU298D). Como el encendido es de
manera alternad, se escribe un cero y un uno de tal manera de tener 01 y
10 en las terminales menos significativos del puerto N.
/*******************************************************************/
#include <stdint.h>

#include <stdbool.h>

#include "inc/hw_memmap.h"

#include "inc/hw_types.h"

#include "driverlib/sysctl.h"

#include "driverlib/gpio.h"

uint8_t ui8PinData=1;

int main(void)

SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL

| SYSCTL_CFG_VCO_480), 120000000);

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);

GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0|GPIO_PIN_1);

GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0|GPIO_PIN_1, 0x00);

while(1)

GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0 | GPIO_PIN_1, ui8PinData);

SysCtlDelay(2000000);

if(ui8PinData==4) {ui8PinData=1;} else {ui8PinData=ui8PinData*2;}

/*******************************************************************/
Ejemplo 2

Eco en el puerto serie de la tarjeta Tiva C Connected Launchpad manejado

mediante pooling

Es importante que el sistema que estemos programando tenga un

mecanismo de interacción con el usuario. Uno de los medios mas sencillos
es la comunicación por el puerto serie.

La comunicación serie se puede programar por pooling o por interrupción.

La técnica de pooling consiste en sensar el receptor para verificar si ha
llegado un caracter, siendo este un procesos que consume todo el tiempo del
procesador. Las interrupciones son el método más eficiente porque
solamente usa tiempo de procesamiento cuando hay una tarea a realizar.

En este programa se usa el puerto virtual que corresponde al Stellaris

Virtual Port, lo puede consultar y configurar en el Administrador de
Dispositivos de Windows.

Los parámetros para este ejemplo son 115,200 bps, sin paridad, 1 bit de parada y sin
handshake.

Para probar su funcionamiento puede usar un emulador de terminal como Coolterm u

otro similar.
#include <stdint.h>

#include <stdbool.h>

#include "inc/hw_memmap.h"

#include "inc/hw_types.h"

#include "driverlib/gpio.h"

#include "driverlib/pin_map.h"

#include "driverlib/sysctl.h"

#include "driverlib/uart.h"

uint32_t ui32SysClkFreq;

int main(void)

ui32SysClkFreq = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN |

SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000);

SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

GPIOPinConfigure(GPIO_PA0_U0RX);

GPIOPinConfigure(GPIO_PA1_U0TX);

GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

UARTConfigSetExpClk(UART0_BASE, ui32SysClkFreq, 115200,(UART_CONFIG_WLEN_8 |

UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));

UARTCharPut(UART0_BASE, 'E');

UARTCharPut(UART0_BASE, 'n');

UARTCharPut(UART0_BASE, 't');

UARTCharPut(UART0_BASE, 'e');

UARTCharPut(UART0_BASE, 'r');

UARTCharPut(UART0_BASE, ' ');

UARTCharPut(UART0_BASE, 'T');

UARTCharPut(UART0_BASE, 'e');

UARTCharPut(UART0_BASE, 'x');

UARTCharPut(UART0_BASE, 't');

UARTCharPut(UART0_BASE, ':');

UARTCharPut(UART0_BASE, ' ');

while (1)

{
if (UARTCharsAvail(UART0_BASE)) UARTCharPut(UART0_BASE,
UARTCharGet(UART0_BASE));

}
Ejemplo 3

Encendido de un par de leds de la tarjeta TM4C1294 en función del nivel

de una señal de entrada.

Para procesar una señal analógica de forma digital se requiere tomar

muestras de ella mediante un dispositivo conocido como Convertidor
Analógico a Digital, (Analog to Digital Converter, ADC). Entre las
características más importantes de un ADC para realizar un
procesamiento digital correcto de la señal analógica, están la resolución del
ADC dada en bits por muestra y la cual determina la precisión de la
conversión, el tiempo de conversión para determinar la velocidad máxima
de muestreo y el rango dinámico de la señal de entrada.

El microcontrolador TM4C1294NCPDT, el el cual está basado la tarjeta que

utilizamos tiene dos módulos ADC, cada uno con múltiples entradas que
pueden estar multiplexadas, 12 bits por muestra, hasta 2 Msps (millones
de muestras por segundo) y terminales para establecer el rango de
conversión. La descripción a detalle de estos módulos se encuentra en el
capítulo 15 (página 1053) de la hoja de datos del microcontrolador
TM4C1294NCPDT.

En este ejemplo se tendrá una señal proveniente de un divisor de voltaje

implementado con un potenciómetro que generará voltajes entre 0 y 3.3V.
Dependiendo del valor de la entrada será el número binario que se muestre
con dos bits (D2D1). En un ADC de 12 bits, el voltaje 0V que es el mínimo
está representado por 0 y el voltaje máximo, 3.3 V está representado por
4095. Si la entrada está en niveles entre 0 y 1023, se tiene 00, de 1024 a
2047 se tiene un número 01, de 2048 a 3071 se tiene 10 y de 3072 a 4095 se
tiene un 11.

Otras condiciones de operación del programa son:

 Se utiliza el módulo ADC0, en particular la entrada analógica 3

(GPIOE0)
 La variable FS determina la frecuencia de muestreo
 El inicio de la conversión es en base al timer 0
 El termino de la conversión genera una interrupción donde se realiza el
cálculo en base al valor leído.
 Después de configurar el sistema se tiene un ciclo ocioso ya que todo el
trabajo se realiza en la ISR del ADC
Debido a que se usan interrupciones, de debe modificar el archivo
tm4c1294ncpdt_startup_ccs.c. Primero de debe declarar la función como
externa

Después se coloca el nombre de la función en la linea que corresponde a la fuente de

la interrupción. En este caso la UART0

#include <stdint.h>

#include <stdbool.h>

#include "inc/tm4c1294ncpdt.h"

#include "inc/hw_memmap.h"

#include "inc/hw_types.h"

#include "driverlib/timer.h"

#include "driverlib/interrupt.h"

#include "driverlib/debug.h"

#include "driverlib/sysctl.h"

#include "driverlib/gpio.h"

#include "driverlib/adc.h"

#define FS 10000

uint32_t muestra;

uint32_t ui32Period;
uint32_t ui32SysClkFreq;

int main(void)

ui32SysClkFreq = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN

| SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000);

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);

GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_0);

GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_0);

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);

GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_1|GPIO_PIN_0);

SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);

TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);

ui32Period = 120000000/FS;

TimerLoadSet(TIMER0_BASE, TIMER_A, ui32Period - 1);

SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);

// Entrada analógica en AIN0 (PE3)

GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_0);

// Uso del secuenciador 3 (FIFO depth 1) para tomar solo una muestra
por disparo

ADCSequenceDisable(ADC0_BASE, 3); // Deshabilitado para programarlo

// Habilitación del timer que disparará el ADC

TimerControlTrigger(TIMER0_BASE, TIMER_A, 1);

// Configuración del secuenciador

ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_TIMER, 0);

//

ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH3 | ADC_CTL_IE |

ADC_CTL_END);

ADCSequenceEnable(ADC0_BASE, 3);

ADCIntEnable(ADC0_BASE, 3);

IntEnable(INT_ADC0SS3); //habilitamos la interrupcion del secuenciador 3

 TimerEnable(TIMER0_BASE, TIMER_A);

IntMasterEnable();

while(1){}

return 0;

/**************************************************

* Rutina de atención a la interrupción del ADC

**************************************************/

void ADC0SS3IntHandler(void){

ADCIntClear(ADC0_BASE,3);

ADCSequenceDataGet(ADC0_BASE,3,&muestra);

muestra = muestra >> 10;

muestra &= 0x03;

GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1| GPIO_PIN_0, muestra);

********************************
Ejemplo 4
Generación de una señal senoidal usando un Convertidor Digital Analógico
MCP4922

El procesamiento digital de señales analógicas requiere el uso de un ADC

para obtener muestras (números) que representen a la señal de interés.
Después de realizar el procesamiento, es posible que se necesite generar
una señal analógica a partir de las muestras procesadas. Los Convertidores
Digital a Analógico (Digital to Analog Converter, DAC) son los dispositivos
que llevan a cabo esta tarea. En general tienen parámetros muy similares
a los ADC, reciben palabras de un tamaño determinado (en bits), tienen un
tiempo de conversión fijo y un rango dinámico para la señal de salida.

Existen tarjetas de evaluación de microcontroladores como el Arduino Due

o la STM32F4 Discovery que tienen integrados los DAC. Sin embargo, la
tarjeta TM4C1294 no cuenta con ellos. En algunas aplicaciones se pueden
usar las salidas PWM y un filtro pasa bajas para generar una señal
analógica. Otra opción es usar circuitos DAC como el MCP4922, el cual
tiene dos canales, se comunica por SPI y acepta velocidades de transmisión
hasta de 20 MHz y recibe entradas de 12 bits, igual que la resolución de los
ADC en la TM4C1294.

En este programa se toman 16 muestras de un periodo de la señal senoidal

con amplitud pico-pico 1 y offset de 0.5 para que todas las muestras sean
positivas. Para enviarlas al DAC se representan con enteros de 12 bits.

El envío de las muestras al DAC se realiza en un ciclo donde solo se espera

a que el DAC procese una muestra y se le envía la siguiente. Las muestras
se pueden enviar de manera temporizada usando para ello los timers del
microcontrolador.

La salida se observa en un osciloscopio. Como se puede observar, la salida

tiene una componente de constante de 1.65V y toda es positiva.
#include <stdint.h>

#include <stdbool.h>

#include "inc/hw_memmap.h"

#include "inc/hw_ssi.h"

#include "inc/hw_types.h"

#include "driverlib/ssi.h"

#include "driverlib/gpio.h"

#include "driverlib/pin_map.h"

#include "driverlib/sysctl.h"

uint32_t ui32SysClkFreq;

#define NUM_SSI_DATA 8

uint32_t muestras[16]={2048, 2832, 3496, 3940, 4095, 3940, 3496, 2832, 2048,
1264, 600, 156, 0, 156, 600, 1264};

void init_SSI0()

SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

GPIOPinConfigure(GPIO_PA2_SSI0CLK); // Habilita el pin

CLK

GPIOPinConfigure(GPIO_PA3_SSI0FSS); // Habilita el pin

SS

GPIOPinConfigure(GPIO_PA4_SSI0XDAT0); // Habilita el pin TX

// Habilita los pines para el módulo SSI

GPIOPinTypeSSI(GPIO_PORTA_BASE,GPIO_PIN_4|GPIO_PIN_3|GPIO_PIN_2);

// Habilita el módulo SSI0

SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);

// Configuración de SSI0

SSIConfigSetExpClk(SSI0_BASE, ui32SysClkFreq, SSI_FRF_MOTO_MODE_0,

SSI_MODE_MASTER, 20000000, 16);
 SSIEnable(SSI0_BASE); // Habilita SSI0

int main(void)

uint8_t ind = 0;

ui32SysClkFreq = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN

| SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000);

init_SSI0();

while(1)

SSIDataPut(SSI0_BASE, (0x3000 | muestras[ind]) & 0x3FFF);

while(SSIBusy(SSI0_BASE))

ind++;

ind %= 16;