01.Tutorial Ccs Tiva

Diseño de Sistemas Empotrados

Grado en Ingeniería de Tecnologías de Telecomunicación

Tutorial 1Introducción a Code Composer Studio

CURSO ACADÉMICO 2013/2014

V1.9

Dpto. Tecnología Electrónica

Universidad de Málaga

Tutorial 1 – Introducción a Code Composer Studio (v1.9) Curso 2013/2014

ÍNDICE

IntroducciónIntroducción.......................................................................................................................................................................................................................................................................... 11Tutorial 1: Introducción a Code Composer StudioTutorial 1: Introducción a Code Composer Studio......................................................................................................................................................22

1. Espacio de Trabajo. Generación de Proyectos.......................................................................................2Editar y salvar un fichero de código..................................................................................................................................................4Añadir y eliminar ficheros de un proyecto.........................................................................................................................................5Opciones de construcción del proyecto............................................................................................................................................6Cambiar el nombre de un proyecto...................................................................................................................................................8Opciones de Proyecto: Uso de funciones de librería (APIs)............................................................................................................8Construcción del código y transferencia a la placa........................................................................................................................11

2. Aspectos básicos de depuración..........................................................................................................14Ejecución – Suspensión – Paso a Paso – Reanudación................................................................................................................14Puntos de Ruptura..........................................................................................................................................................................14Visualización de Registros, Variables, Expresiones y Memoria.....................................................................................................15Fin de la depuración........................................................................................................................................................................17

Apéndice I: Problemas más frecuentesApéndice I: Problemas más frecuentes..................................................................................................................................................................................1919Apéndice II: Instalación básica CCSv5.5Apéndice II: Instalación básica CCSv5.5..............................................................................................................................................................................2020Apéndice III: Mejorando la PortabilidadApéndice III: Mejorando la Portabilidad..................................................................................................................................................................................2121ReferenciasReferencias...................................................................................................................................................................................................................................................................... 2525

2

Diseño de Sistemas Empotrados – Grado en Ingeniería de Tecnologías de Telecomunicación

INTRODUCCIÓN

Este documento describe los conceptos básicos necesarios para comenzar a utilizar el sistema de

desarrollo disponible en la asignatura Diseño de Sistemas Empotrados. Dicho sistema se basa en

el manejo de la plataforma de desarrollo EK-TM4C123GXL (TIVA Launchpad), de Texas

Instruments, y el entorno de desarrollo y depuración Code Composer Studio v5 (CCSv5)1.

Las plataformas de desarrollo proporcionan algunos elementos útiles para implementar pequeños

sistemas y aplicaciones basadas en las familia de microcontroladores Cortex-M TM4C123G2.

Estas placas integran un sistema de depuración on-chip (ICDI, In-Circuit Debugger Interface) que

permite su conexión a un PC mediante un cable de conexión USB-miniUSB. Las características

básicas de esta placa así como su utilización para el desarrollo de aplicaciones se describen en el

documento TIVA C Series TM4C123 Launchpad Evaluation Board User's Guide, disponible en la

página de la asignatura del Campus Virtual.

La aplicación Code Composer Studio constituye un entorno integrado que proporciona una

toolchain completa (Editor, Ensamblador/Compilador, Linkador, y Depurador) para el desarrollo

SW de aplicaciones. Con esta aplicación se puede desarrollar código tanto en ensamblador como

en C para la familia de microcontroladores Cortex-M, así como transferirlo a cualquier placa de

desarrollo compatible, para su posterior ejecución y/o depuración. De esta forma, la aplicación

Code Composer Studio permite controlar por completo el ciclo de desarrollo de cualquier sistema

basado en la familia de microcontroladores Cortex-M. La documentación del entorno es accesible

on-line a través de las opciones de Ayuda en el propio menú principal de la aplicación.

La aplicación Code Composer Studio se ejecuta, en un SO Windows, desde el menú [Todos los

Programas – Texas Instrument – Code Composer Studio 5.5.0 – Code Composer Studio 5.5.0 ] o

mediante el icono de acceso rápido . La placa Stellaris Launchpad se alimenta a partir del

puerto USB del PC con el cable USB-miniUSB.

Para poder realizar este tutorial, deberás descargar de la página WEB de la asignatura, el

proyecto de ejemplo Tutorial1, así como la librería Stellarisware. Crea una carpeta/usuario

SistemasEmpotrados y ve colocando y descomprimiendo allí, todos estos ficheros.

En este tutorial se introduce el ciclo completo de utilización de la herramienta Code Composer

Studio para crear un espacio de trabajo, editar, compilar, linkar, transferir y depurar el programa

de una aplicación sencilla o proyecto, programado en C, al microcontrolador TM4C123G

presenta en la placa Stellaris Launchpad.

1 En este tutorial se empleará la versión 5.5 Windows. Otras versiones pueden incluir pequeñas diferencias.2 A casi todos los efectos ambas placas/micros son EQUIVALENTES, siendo TIVA una versión renovada de STE-

LLARIS.

1


TUTORIAL 1: INTRODUCCIÓN A CODE COMPOSER STUDIO

1. Espacio de Trabajo. Generación de Proyectos.

1.1 Inicia la aplicación “Code Composer Studio”. Si es la primera vez que la ejecutas tras su

instalación, te pedirá que elijas una “opción de licencia”: elige la opción FREE LICENSE3. La

aplicación te preguntará cual es el espacio de trabajo que deseas abrir. La primera vez que

uses la aplicación deberás crear un directorio, el cual utilizarás para el desarrollo de la

asignatura. Se recomienda elegir un nombre significativo (por ejemplo, workspaceLM4F120 o

workspace_Stellaris). En este espacio de trabajo se deberán crear todos los proyectos

necesarios para el desarrollo de las diferentes aplicaciones; será el que deberás seleccionar

cada vez que abras el programa.

Recuerda que esta máquina puede ser usada por otros compañeros y podría ser un

problema, si seleccionases el espacio de trabajo de otro grupo. Por este mismo motivo, NUNCA

debes activar la opción “Use this as the default and do not ask again”, ya que entonces no te

volvería a preguntar nunca mas el espacio de trabajo a utilizar4, y probablemente acabaríais

trabajando varios grupos sobre un mismo espacio de trabajo!!

1.2 Cierra la ventana TI Resource Explorer, con un click en la X de la pestaña. Aunque desde esta

ventana puedes hacer algunas de las cosas que necesitamos, la mayoría están orientadas al

micro MSP430, por lo que no nos interesan demasiado.

1.3 Para crear un nuevo proyecto selecciona, en la barra de menú, la opción [Project – New CCS

Project]. En la ventana que aparece, indica:

3 Si se elige otro tipo de licencia por error, se puede volver a elegir con la opcion “Help- CodeComposerStudio Li-censing Information – Upgrade – Launch License Setup”.

4 En caso de seleccionarla por error, se puede quitar la selección dentro del programa en una opción de configuracióndel entorno.

Figura 1: Selección del espacio de trabajo

2


◦ un nombre para el proyecto en la opción [Project name:], por ejemplo Tutorial1.

◦ Deja marcada la opción [Use Default location]; de esta forma tu proyecto se creará

dentro de la carpeta de tu espacio de trabajo, en una carpeta con el mismo nombre

que el proyecto.

◦ En la sección de elección de dispositivo, [Device], deja la opción ARM para [Family:];

para seleccionar la variante te será mas sencillo escribir un filtro con la subfamilia del

micro de la Launchpad, la TIVA; selecciona el micro TIVA TM4C123GH6PM en la lista

desplegable que obtendrás pinchando en el lado derecho (es el modelo que tiene la

placa). En la sección de conexión, [Connection:], pincha en el desplegable y busca la

opción Stellaris In-Circuit Debug Interface.

◦ No cambies el resto de opciones ([Advanced Settings], [Project templates and

examples:]).

◦ Finalmente pulsa el botón [Finish], en la esquina inferior derecha. Aparecerá un nuevo

proyecto en la ventana Project Explorer, y un nuevo fichero main.c, en la ventana de

Edición.

Si por error cierras la ventana de proyectos, Project Explorer,(por ejemplo, pulsando la X de la

pestaña), puedes volver a abrirla con la opción de menú, [View – Project Explorer]. Esto

mismo es válido para cualquier otra ventana del entorno de desarrollo.

3

Figura 2: Generación y configuración de un nuevo proyecto


Si seleccionas la opción Empty Project en Project templates and examples, se creará la

misma estructura de proyecto, pero sin fichero main.c. En ese caso, y para crear un fichero de

código selecciona [File – New – Source File] e indica el nombre del fichero a crear (por

ejemplo, “main.c”).

Editar y salvar un fichero de código

1.4 Elimina el “esqueleto” de código que aparece en el fichero main.c, y copia en su lugar el que

puedes ver a continuación:

Código fuente del proyecto “Tutorial1”:

// Version TIVA. Enciende de los LEDs rojo (PF1), verde (PF2) y azul (PF3) de forma con-secutiva y continua,

// en intervalos de 1 segundo#include <stdint.h>#include <stdbool.h>#include "inc/hw_types.h" // Necesario para funciones API en driverlib#include "inc/hw_memmap.h" // Etiquetas de registros del micro, perifericos, ...#include "driverlib/sysctl.h" // Definicion de funciones y etiquetas de control del sis-

tema (SysCtl)#include "driverlib/gpio.h" // Definicion de funciones y etiquetas de puerto (GPIO-

Pin...)

int main(void){

int LED = 2; // En binario es 00000..010, es decir, BIT1 a 1// Configura reloj del sistema a 50MHz (PLL a 200MHz/4=50MHz)SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);// Habilita Puerto F (LEDs)SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);// Comentar para producir error FaultISR// Configura pines PF1, PF2, y PF3 como salidas (control de LEDs)GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);while(1){

// Enciende el LED indicado en la variable; 1er parametro: puerto afectado// 2º parametro: bits afectados (mascara); 3er parametro: valor a volcar al puer-

to// solo se modificaran los bits indicados por la mascara)GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, LED);// Retardo para ver encendido el LED; parametro= "loops" (3 ciclos por "loop")SysCtlDelay(16666666); // t=16666666*3/40MHz= 1 seg (aprox)// Enciende el siguiente LED (el del bit que esta a continuacion)if (LED == 8) {LED = 2;} else {LED = LED*2;}

}}

Si al copiar el código, la indentación no es correcta, puedes corregirla seleccionando la línea

o líneas incorrectas, y pulsando Ctrl+I.

Tras copiar el código observarás que, a la izquierda de las 4 primeras líneas aparece un

interrogante. Esto indica un problema en el proyecto, en este caso relativo a que no se

pueden encontrar los ficheros indicados por las directivas #include. Veremos como

solucionar este problema más adelante.

4


1.5 Salva los cambios hechos al fichero main.c, con el botón Save, ,del menú principal. En tu

espacio de trabajo se habrá creado una carpeta con el nombre del proyecto, Tutorial1, que incluye

todos los ficheros que forman parte del mismo.

Añadir y eliminar ficheros de un proyecto

1.6 En la ventana Project Explorer, pulsa en la flecha que aparece a la izquierda del nombre del

proyecto para ver todos los archivos que necesitamos para construir su ejecutable. Para

eliminar ficheros de un proyecto, puedes seleccionar el fichero en cuestión y pulsar el botón

Supr de tu teclado; o bien escoger la opción [Edit – Delete] en el menú principal o en el

menu contextual que aparece al pulsar el boton derecho en el fichero. También lo eliminarás

borrándolo de la carpeta de tu proyecto. Prueba a borrar el fichero main.c, que se había

creado por defecto, de alguna de las maneras indicadas.

5Figura 4: Eliminar un fichero al proyecto

Figura 3: Edición del código fuente


1.7 En caso de que se necesite añadir un archivo fuente más, selecciona [Project – Add Files], y

buscar el fichero a añadir; selecciónalo, y pulsa Aceptar. Aparecerá una nueva ventana

donde te preguntará si deseas copiar el fichero a tu proyecto o enlazarlo. Si seleccionas la

primera opción, Copy Files, el fichero se copiará a la carpeta de tu proyecto y pasará a

formar parte del mismo; si eliges enlazarlo, se añadirá el fichero original. Prueba a añadir una

copia del fichero Tutorial1.c – suponemos que se ha borrado main.c –

O puedes simplemente copiar el fichero Tutorial1.c en la carpeta de tu proyecto; también se

añadirá a tu proyecto de esta manera.

Nota: Asegúrate de que tu proyecto incluye, además de tu fichero de programa, un fichero de

nombre xxx_startup_ccs.c. Este fichero es indispensable para el buen funcionamiento de tu

aplicación. Si no se ha generado al crear el proyecto, deberás añadirlo manualmente.

Opciones de construcción del proyecto

1.8 A continuación, deberás seleccionar las opciones de construcción de tu proyecto. Para ello,

asegúrate primero de que lo tienes seleccionado pulsando con el botón izquierdo, en la

ventana Project Explorer, encima de su nombre (le aparecerá el indicador [Active – Debug]).

Selecciona la opción del menú principal [Project – Properties]. Aparecerá una ventana de

configuración de propiedades del proyecto.

Figura 5: Añadir un fichero al proyecto

6


Figura 6: Opciones de construcción del proyecto

1.9 La configuración del proyecto implica gran cantidad de opciones; dejaremos la mayoría de

opciones por defecto e iremos indicando las que hay que cambiar a medida que las vayamos

necesitando. Se recomienda activar siempre la opción Debug – Stellaris FLASH Settings –

Reset target during program load to FLASH memory, para evitar que cambios en la

configuración de un programa no tengan efecto a menos que se haga un reset en la placa.

7

Figura 7: Opción de RESET en carga de programa


Cambiar el nombre de un proyecto

1.10 Para cambiar el nombre de un proyecto, selecciónalo en la ventana Project Explorer, y pulsa

F2, o pulsa el botón derecho en dicha ventana y selecciona la opción Rename. La carpeta del

proyecto también cambiará al nuevo nombre5. !IMPORTANTE! Al renombrar un proyecto

alguna de las opciones del proyecto se establecen en sus configuración por defecto, por lo

que hay que tener cuidado y asegurarse de que la configuración es la deseada (hay que

tener un cuidado especial con la opción indicada en el punto 1.9, ya que se desactiva)

Opciones de Proyecto: Uso de funciones de librería (APIs)

1.11 Para hacer uso de las funciones de librería proporcionadas por Stellarisware, es necesario

que el entorno sea capaz de reconocer y acceder a los ficheros de código de librería ya pre-

construidos, o añadir su código fuente a tu propio proyecto. Esto se puede configurar también

en las Opciones de Proyecto:

• Una primera posibilidad pasa por utilizar las librerías precompiladas y los ficheros de

cabecera proporcionados por Stellarisware.

a) Para ello, en primer lugar debes indicar correctamente la ruta de las cabeceras de

definición (ficheros .h) de las funciones de API utilizadas. Esto se indica con la

opción [Build – ARM Compiler – Include Options], añadiendo la nueva ruta en la

ventana [Add dir to #include search path] pulsando en Add, . Se debe

buscar, mediante el botón FileSystem, el directorio TivaWare, añadiendo

finalmente la ruta mediante el botón OK. Observa que la ruta indicada es la

carpeta de la que cuelgan los directorios /inc, y /driverlib, que son los que

contienen las cabeceras de definición de las funciones de API.

5 Esta opción puede ser interesante para crear varios proyectos distintos a partir del mismo proyecto de partida, me-diante la opción “Import CCS existing Eclipse Project” que veremos más adelante.

Figura 8: Añadir directorios de cabeceras de API

8


b) De forma similar tenemos que indicar el directorio donde se encuentran las librerías

que contienen el código ejecutable de las funciones de API. Esta opción se

encuentra en [Build – ARM Linker – File Search Path], en la opción superior,

[Include library file or command file as input], botón Add, . La librería a

localizar se llama driverlib.lib, y se encuentra, desde el directorio raíz TivaWare, en

driverlib/ccs/Debug/. Si nos olvidamos de incluir la librería, el proyecto se compilará

correctamente, pero en la fase de linkado aparecerán errores del tipo error#10234-D: unresolved symbols remain.

• La opción anterior tiene el inconveniente de que los proyectos resultantes no son portables

a otro ordenador (por ejemplo el de tu casa), a menos que los ordenadores sigan siempre

la misma estructura de directorios. Una alternativa que asegura la portabilidad pasa por

copiar el código de las funciones de API que se vayan a emplear a la carpeta del proyecto,

y compilar dichas funciones junto con tu código propio. Elimina las opciones de

construcción de proyecto añadidas en el punto anterior para probar esta segunda opción.

Para ello selecciona los elementos añadidos y usa el botón “Delete” .

a) Las funciones de API deberán seguir la misma estructura de directorios indicada en las

sentencias #include de tu programa (si por ejemplo, tu programa necesita las

funciones de API de GPIO, #include “driverlib/gpio.h”, deberás crear una

subcarpeta “driverlib” en tu carpeta de proyecto y copiar allí los ficheros gpio.c, gpio.h y

todos los que dependan de estos). Para simplificar puedes copiar las carpetas /inc y

/driverlib completas desde el directorio TivaWare a tu carpeta de proyecto; sin embargo

esto aumentará el tiempo de compilación de tu código y el tamaño final de tu proyecto!

En este ejemplo hemos preparado unas carpetas /inc y /driverlib incluyendo

unicamente los recursos necesarios, en el fichero comprimido Tutorial1.zip; copia estas

carpetas en lugar de las anteriores, para este proyecto en particular.

9

Figura 9: Añadir ficheros de librerias de API


b) Además, deberás añadir la ruta a estas carpetas tu propio proyecto en la

configuración [Build – ARM Compiler – Include Options] (ver paso “a)” de la opción

anterior), escogiendo la opción Workspace en este caso, y seleccionando la carpeta

de tu proyecto (Tutorial1). Aparecerá con la ruta "${workspace_loc:/${ProjName}}".

c) En la opción [Build – ARM Compiler – Advanced Options – Predefined Symbols],

incluir en la ventana Pre-define NAME (opción Add, ), un nuevo símbolo, ccs=”ccs”.

Esto es necesario para que el compilador entienda determinadas convenciones

propias de Code Composer Studio, que aparecen en el código de las carpetas que

acabas de añadir.

Figura 10: Inclusión de la carpeta de proyecto en la ruta de directorios

Figura 11: Símbolos predefinidos para compilación

10


d) Repite el paso c) para añadir un nuevo símbolo PART_TM4C123GH6PM. Este

símbolo permite identificar el modelo de procesador que estás empleando de manera

que se compilen únicamente las funcionalidades asociadas al mismo en el código de la

API.

e) Por último, y para que ciertas librerías de la API se puedan construir, es necesario

habilitar la opción [Build – ARM Compiler – Advanced Options – Language options

– Enable support for GCC extensions].

Como ventaja adicional de este segundo método, tendrás la posibilidad de depurar el código

de ejecución de las funciones de librería, algo que no podrás hacer con la primera opción.

En el Apéndice III de este documento indicamos un tercer método para conseguir construir

proyectos portables de menor tamaño, pero con peores capacidades de depuración. La

elección de uno u otro método dependerá de las necesidades del programador en cada

momento.

Construcción del código y transferencia a la placa

1.12 Asegúrate de que el proyecto Tutorial1 es el proyecto activo, seleccionándolo por su nombre

con el botón izquierdo en la ventana Project Explorer. Para construir el proyecto selecciona la

opción [Project – Build Project], . Aparecerán dos nuevas ventanas Console y Problems.

◦ En la ventana Console se muestran los mensajes generados durante el proceso de

construcción, indicando las operaciones intermedias realizadas por la toolchain, y el

resultado de las mismas. También se incluyen los mensajes de error del proceso.

◦ Por otro lado, la ventana Problems, muestra los problemas que se han encontrado

durante la construcción de la aplicación (si es que ha habido alguno).

11

Figura 12: Habilitación de soporte de extensiones gcc


1.13 Vamos a generar un error a propósito en el código. Por ejemplo, quita el “;” al final de la

primera instrucción del código, int LED = 2, y vuelve a construir el proyecto. En la

ventana Console aparecerá mensajes indicando que se han producido errores en el proceso

de construcción.

En la ventana Problems aparecen, detallados, todos los errores que se han detectado en el

proceso de compilación. Seleccionando un error en particular en esta ventana, se

seleccionará automáticamente la línea de código fuente donde se encuentra el error.

Además, en la ventana del proyecto aparecerán marcados con una X roja aquellos ficheros

donde se hayan detectado errores.

1.14 Corrige el error que hemos introducido en el punto anterior, y vuelve a construir el

ejecutable. A continuación, vamos a transferirlo a la placa para iniciar una sesión de

depuración. Para ello, conecta la placa TIVA Launchpad al ordenador, mediante el cable

USB-miniUSB, en el puerto USB de la placa rotulado como DEBUG. Así mismo, mueve el

interruptor PWR SELECT a la posición DEBUG.

* La primera vez que conectes la placa deberás esperar unos minutos a que se instalen sus

drivers

1.15 Selecciona la opción del menú principal [Run – Debug] , F11, o . Si la operación no se

realiza correctamente (por ejemplo, la placa no está bien conectada) se indicará mediante

una ventana con un mensaje de error. Si la carga del ejecutable es correcta, el sistema

entra en modo depuración y se produce un cambio del entorno de ventanas a una

Figura 13: Señalización de Errores en el proyecto

12


perspectiva6 de depuración (título de la ventana pasa a “CCS Debug”). En cualquier

momento se puede volver a la perspectiva de edición (titulo de ventana,CCS Edit), mediante

el icono de menú Open Perspective, ,o pulsando en el nombre de la perspectiva deseada

1.16 Para ejecutar el código, selecciona la opción [Run – Resume], F8, o pulsa en el icono .

En la ventana Debug aparecerá, debajo del nombre del proyecto, el nombre del driver de

depuración que estamos utilizando (Stellaris In-circuit Debugger Interface/Cortex_M4_0 ), y

el estado de funcionamiento de la placa (Running). Deberás observar que el LED RGB de la

placa empieza a cambiar alternando entre los colores rojo, azul, y verde.6 Una perspectiva reúne el conjunto de ventanas más adecuadas para la fase de desarrollo de la aplicación que se esté

realizando. CCS ofrece 2 perspectivas por defecto: CCS Edit, orientada a tareas de Edición y Configuración delproyecto; y CCS Debug, orientada a tareas de depuración y ejecución controlada. Es posible crear perspectivas deusuario que reúnan únicamente las ventanas decididas por el propio usuario.

13

Figura 14: Conexión Launchpad -- PC para depuración y carga de programas

Figura 15: Depuración y carga del código. Perspectiva de depuración


2. Aspectos básicos de depuración

Ejecución – Suspensión – Paso a Paso – Reanudación

2.1 Podemos detener, momentáneamente, la ejecución del programa, mediante la opción de

menú [Run – Suspend], Alt+F8, o pulsando el icono . El mensaje de la ventana Debug

cambiará a Suspended; y aparece la jerarquía de funciones a la que pertenece la

instrucción en curso en el momento de la suspensión. Si el código fuente que incluye la

instrucción está disponible, aparecerá en pantalla con el cursor detenido sobre la

instrucción7. y el programa se detendrá (el LED deja de parpadear en la placa).

2.2 Una vez te encuentres en una instrucción C del código main.c, presiona F6, o el icono ,

para ejecutar una sola instrucción completa (Step Over). Presiona varias veces F6, para ir

viendo como se ejecutan todas las instrucciones del programa (en un bucle infinito), y que

efectos tiene la ejecución sobre la placa. Puedes reanudar (F8) y detener la ejecución

(Alt+F8), tantas veces como quieras. Deja al programa suspendido por ahora.

2.3 Puedes reiniciar el código y ejecutarlo desde su primera instrucción con [Run – Restart], .

Puntos de Ruptura

2.4 Para añadir un punto de ruptura en una instrucción del código, selecciona la instrucción y haz

doble-click con el botón izquierdo en la columna azul, a la izquierda del número de la

instrucción. Aparecerá un símbolo . Prueba a poner un punto de ruptura en la línea 2, en

la instrucción GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,

LED);. Ahora presiona F8 (Resume), y el programa se detendrá en el punto de ruptura. Si

ejecutas esa instrucción, pulsando F6, verás que produce un cambio de color en el LED.

2.5 Para borrar un punto de ruptura, selecciónalo con el puntero y pulsa dos veces el botón

izquierdo sobre él. Vuelve a colocarlo de nuevo, ya que lo necesitaremos en el siguiente

apartado.

7 Si se estaba ejecutando una llamada a una función de librería precompilada, aparecerá el mensaje “No source avai -lable”, pero dará la opción de ver las instrucciones en ensamblador mediante el botón View Disassembly. Si te ocu-rre esto pulsa F7 para ir a la siguiente instrucción de código fuente disponible.

Figura 16: Aplicación ejecutándose en modo depuración

14


Visualización de Registros, Variables, Expresiones y Memoria

2.6 A continuación indicaremos como visualizar el estado de los diferentes registros de

configuración del micro, así como del contenido de la memoria, y del estado y valores de las

variables y expresiones definidas en el programa.

2.7 Abre (si aún no está abierta) la ventana de visualización de registros, mediante el comando

de menú, [Window – Show View – Registers]. El microcontrolador posee cientos de

registros, por lo que la ventana de registros se organiza mostrando, en primer lugar, los

módulos y periféricos existentes. Busca, bajo la columna Name, el módulo del puerto F,

GPIO_PORTF; ayúdate de la barra de desplazamiento de la derecha si es necesario. Una

vez encontrado, selecciona el módulo, y abre sus registros pulsando en la flecha a la

izquierda del nombre. Observa como el contenido del registro GPIO_DATA, cambia cada vez

que el programa se detiene en el punto de ruptura que colocaste antes. También puedes

cambiar el contenido del registro pulsando en su valor, y escribiendo un valor nuevo8. Si

entre dos suspensiones de un programa se ha producido un cambio en el registro, esto se

verá reflejado por su campo valor con un fondo amarillo.

2.8 Abre ahora la ventana de visualización de memoria con la opción de menú, [View – Memory

Browser]. La ventana permanece vacía hasta que escribas en la caja una dirección de

memoria. Escribe, por ejemplo, la dirección 0x400253FC, y pulsa Enter o selecciona el botón

Go en la ventana. Aparecerá el rango de memoria a partir de esa dirección, indicando el

contenido de cada una de ellas. Puedes seleccionar el modo de visualización mediante el

menú desplegable justo encima de la ventana de visualización. Selecciona 8 Bit Binary.

8 Esto solo funcionará en determinados registros con los permisos adecuados.

15

Figura 17: Comandos Resume, Suspend, y Step Over. Puntos de ruptura


2.9 Escribe ahora la dirección 0x20000460, que se corresponde con la variable LED. En el

programa cambiamos esta variable y la volcamos al registro GPIO_DATA del puerto F. Los

bits 1, 2, y 3, del byte de este registro están conectados al LED RGB, para iluminar,

respectivamente, los colores verde, rojo, y azul. Puedes observar como cambia el bit (y el

color) activo, reanudando la ejecución hasta el punto de ruptura. Observa también como las

zonas de memoria cambiadas aparecen en rojo, en la ventana View Memory.

Figura 18: Ventana de visualización de Registros

Figura 19: Ventana de Visualización de memoria

16


2.10 Si quieres visualizar que ocurre en varias posiciones de memoria distintas, puedes abrir mas

pestañas de visualización de memoria mediante el botón New Tab. Cada pestaña

conservará el rango de direcciones indicado en la caja.

2.11 Abre la ventana de visualización de variables con la opción de menú [View – Variables].

Esta ventana permite ver el valor de las variables definidas por el usuario en el programa,

por ejemplo, la variable LED. Las variables se incluyen automáticamente, siempre que se

encuentren en el “alcance” de la función actual (por ejemplo, la variable LED no aparecerá si

al suspender el programa nos encontramos ejecutando una función de librería). Es posible

cambiar su valor de la misma manera que con los registros.

2.12 Por último, abre la ventana de visualización de expresiones con [View – Expresions]. Esta

ventana nos permite indicar explícitamente las variables o expresiones que queremos

visualizar. Para añadir una, se debe pulsar en Add new expression, y teclear su nombre.

2.10 Además, en cualquiera de las ventanas indicadas existe la posibilidad de ver los cambios en

el estado de variables, registros, y memoria, en tiempo de ejecución. Para ello, existe en

cada ventana un botón Continuos refresh ,que, cuando se selecciona, permite este

comportamiento. Elimina los puntos de ruptura del programa9, selección el refresco continuo

en alguna de las ventanas anteriores y observa como cambian los valores.

Fin de la depuración

2.11 Para finalizar la sesión de depuración, selecciona [Run – Terminate], Ctrl+F2, o pulsa en el

icono . Se volverá a la perpectiva CCS Edit.

9 Puedes eliminar TODOS los puntos de ruptura de una vez con [Run – Remove All Breakpoints]

17

Figura 20: Ventanas de Visualización de variables y expresiones


2.12 Finalmente, puedes cerrar el proyecto pulsando el botón derecho sobre su nombre, en la

ventana Project Explorer y seleccionando Close Project en el menú contextual que aparece.

El icono de carpeta que acompaña al proyecto cambiará al de una carpeta cerrada, , y

ya no se podrá interactuar con el proyecto hasta abrirlo nuevamente.10

10 El proyecto se puede abrir nuevamente a través del menú contextual, con la opción Open Project.

Figura 21: Aplicación ejecutándose en modo depuración

18


APÉNDICE I: PROBLEMAS MÁS FRECUENTES

Pese a seguir las instrucciones indicadas en esta guía, es muy posible que surjan algunos

problemas o errores que pueden obstaculizar la realización del tutorial. A continuación se indican

los síntomas de algunos de los errores más comunes y sus posible soluciones:

No se encuentran los ficheros #include (“could not open source file...”).

No se han añadido correctamente las rutas (path) de los que cuelgan los directorios, en la

configuración del proyecto. Ver apartado 1.11. Ten en cuenta que si el parámetro #include es de

la forma #include “/directorio/fichero”, la ruta debe ser la carpeta que contenga a directorio.

Error connecting to the target: Frequency is out of range.

Indica que hay problemas de conexión con la placa Launchpad. Posibles soluciones:

• Asegurarse de que el cable USB/miniUSB está bien conectado en ambos extremos.

• Asegurarse de que el cable miniUSB está conectado a la placa a través del puerto USB

rotulado DEBUG. Así mismo, el interruptor PWR SELECT debe estar en la posición

DEBUG.

• Puede existir un problema de instalación de drivers. Consulta con los profesores o con la

guía de instalación de Code Composer Studio.

Desaparecen los iconos de ejecución/depuración de programas en la vista Debug.

Pulsa [View – Debug] en el menú principal.

Code Composer no te pregunta el directorio de trabajo (workspace) al arrancar. El entorno

comienza en un directorio de trabajo distinto al tuyo.

Cambia de espacio de trabajo con [File – Switch Workspace] y busca la carpeta de tu espacio

de trabajo.

Para evitar tener que hacer esto en cada arranque, y obligar a CCS a que pregunte de nuevo el

directorio de trabajo al arrancar, busca [Window – Preferences – General ➤ Startup and

Shutdown ➤ Workspaces] y activa la opción Prompt for workspace on startup.

19


APÉNDICE II: INSTALACIÓN BÁSICA CCSV5.5

Las siguientes instrucciones se refieren a la instalación de Code Composer Studiov5.5

sobre un sistema operativo Windows7 de 64bits. Cambios en las condiciones de instalación

pueden suponer la necesidad de pasos adicionales, o ligeros cambios en las instrucciones

indicadas.

1. Descarga el instalador de CCSv5.5 desde aquí11. Se recomienda escoger la opción “Web

Installer”. Nota: podrás encontrar también el instalador en la página WEB de la asignatura.

2. Ejecutar el fichero ccs_setup_5.5.0.00077.exe con privilegios de administrador.

3. Dejar el directorio de instalación por defecto. En la opción Setup Type, elegir la opción

Custom. En la siguiente ventana, soporte al procesador, elegir los procesadores con los

que se vaya a trabajar (en esta asignatura harán falta, al menos, los Stellaris Cortex-M

MCUs, los Amxx Cortex-A and ARM9).

4. En la selección de componentes puedes dejar las opciones por defecto, aunque las

opciones C6EZFlo, MSP430Ware, Grace, y SYS/BIOS v6, tampoco nos serán necesarias

para las asignatura. En la siguiente ventana, Emuladores, NO hace falta seleccionar los

Blackhawk Emulators, los Spectrum Digital Emulators, ni los XDS100.

5. Dejar que las instalación finalice.

6. A continuación, reinicia el sistema. La primera vez que arranques CCSv5, te pedirá que

elijas un tipo de Licencia. Debes elegir la “Free License”, ya que la Stellaris Launchpad no

tienen ningún tipo de limitación con esta licencia, al utilizar un depurador in-circuit.

11http://processors.wiki.ti.com/index.php/Download_CCS

20

http://software-dl.ti.com/dsps/forms/self_cert_export.html?prod_no=ccs_setup_5.2.1.00018.bin&ref_url=http://software-dl.ti.com/dsps/dsps_public_sw/sdo_ccstudio/CCSv5/CCS_5_2_1/

http://software-dl.ti.com/dsps/forms/self_cert_export.html?prod_no=ccs_setup_5.2.1.00018.bin&ref_url=http://software-dl.ti.com/dsps/dsps_public_sw/sdo_ccstudio/CCSv5/CCS_5_2_1/

http://processors.wiki.ti.com/index.php/Download_CCS


APÉNDICE III: MEJORANDO LA PORTABILIDAD

En un apartado de este tutorial hemos visto técnicas que nos permiten mejorar la

portabilidad de los proyectos con los que trabajamos, con las ventajas que esto supone. No

obstante, la técnica empleada, basada en copiar en cada nuevo proyecto los ficheros de librería

API necesarios, aumenta de manera excesiva el tamaño de los diferentes proyectos, algo que

sería deseable evitar. Hay que tener en cuenta que las librerías de API SON LAS MISMAS para

todos los proyectos por lo que debería bastar una única copia accesible a todos mediante

enlaces, e incluso sería posible utilizar librerías precompiladas, tal como vimos en la opción 1 del

apartado correspondiente. Para evitar los problemas derivados de la instalación de librerías y/o la

aplicacación CCSv5.5 en rutas diferentes en distintos ordenadores, nos podemos apoyar en un

mecanismo de definición de variables de ruta y de construcción de proyecto .

1. Vuelve a cargar el “Tutorial1” con el que hemos trabajado en esta guía. Elimina los

directorios “/inc” y “/driverlib” del proyecto. En las opciones de proyecto, elimina las rutas

añadidas en el punto 1.11 para poder encontrar los ficheros de API.

2. Crea un fichero “vars.ini” y guárdalo en el directorio de tu espacio de trabajo. Añade a

dicho fichero la línea:

TIVAWARE_INSTALL = <ruta-de-carpeta-TIVAWARE>

donde <ruta-de-carpeta-TIVAWARE> representa la ruta donde has instalado la carpeta

TIVAWARE en el PC (en el laboratorio estará en C:\Users\SE-

GTT\TIVA\TivaWare_C_Series-2.0.1.11577)

3. En el menú de CCSv5.5 selecciona [File – Import] y, dentro de la ventana, [Code

Composer Studio – Build Variables]; pulsa el botón “Next”, y busca el fichero “vars.ini”,

que has creado en el paso anterior. Seleccionalo y pulsa “Finish”.

4. Ahora vamos a indicar que la etiqueta TIVAWARE_INSTALL, representa la ruta de

búsqueda de los ficheros de cabecera de definición y de las librería de API precompilada,

creando unas variables de ruta y de construcción de proyectos, pero a nivel de espacio de

trabajo. Esto significar que, todos los proyectos nuevos que crees en este espacio de

trabajo tendrán acceso a esas variables.

5. Abre de nuevo las propiedades del proyecto, y selecciona [Resources – Linked

Resources]. Observa que debe aparecer una variable TIVAWARE_INSTALL, con la ruta

indicada en “vars.ini”.

6. Repite los pasos que hiciste en el punto 1.11 de este tutorial, en la propiedad ARM

Compiler, pero escribe el nombre ${TIVAWARE_INSTALL} en la opción “Include Options”.

7. Respecto al fichero de librería precompilado, vamos a añadir un enlace al mismo.

Selecciona el proyecto “Tutorial1” en la ventana de proyectos, y pulsa en [Project – Add

Files]. Navega hasta el fichero driverlib.lib, que se encuentra dentro de la carpeta

TIVAWare en “<TIVAWare>\driverlib\CCS\debug”, y seleccionalo. En la ventana que se

abre selecciona ahora la opción Link to Files, y cambia la ruta relativa desde

21


PROJECT_LOC a TIVAWARE_INSTALL. Prueba a compilar de nuevo el proyecto;

observarás que la compilación es MUCHO más rápida. Además, tu proyecto “pesará”

menos al no incluir los ficheros de librerías.

8. Los pasos 6 y 7 los tendrás que repetir para cada nuevo proyecto que generes. La ventaja

de este método es que, si te llevas el proyecto a otro ordenador, y en el mismo has

instalado TIVAWARE en otra ruta/disco duro, bastará con actualizar “vars.ini” en el nuevo

Figura 22: Añadiendo la variable de ruta de TIVAWARE al espacio de trabajo

Figura 23: Añadiendo un enlace a a librería precompilada

22


ordenador a la ruta correspondiente e importar dicho fichero una única vez en ese nuevo

ordenador. A partir de entonces los proyectos que utilices en ambos ordenadores serán

compatibles, aunque TIVAWARE esté instalado en distintas rutas en ambos.

9. La principal desventaja de este método es que no podrás acceder al código fuente de las

funciones de API, al utilizar versiones precompiladas. Esto significa que no podrás

consultar su definición, uso, y opciones desde dentro del entorno de programación,

teniendo que acudir a la documentación del fabricante.

23


REFERENCIAS

[1] Getting Started with the Stellaris EK-LM4F120XL LaunchPad Workshop WorkBook.

Septiembre 2012, revisado Diciembre 2012, Texas Instruments.

[2] Tutorial MSP430. Laboratorio de Diseño de Sistemas Digitales, Curso 2011/2012, Eduardo

Perez Rodriguez, DTE.

[3] Code Composer Studio IDE v5.x Wiki, en

h ttp://processors.wiki.ti.com/index.php/Category:Code_Composer_Studio_v5, Enero 2014, Texas

Instruments.

24

http://processors.wiki.ti.com/index.php/Category:Code_Composer_Studio_v5



Documents

01.Tutorial Ccs Tiva