Lecciones de Programación en TIGCC

La siguiente es parte de una serie de lecciones diseñadas para ayudarle a aprender cómo programar en C para las calculadoras TI-89, TI-89 Titanium, TI-92+ y Voyage 200 en el ambiente de desarrollo TIGCC.

Si lo desea, puede descargar el código fuente del programa, el archivo del proyecto, y los archivos binarios aquí.

El primer paso hacia la programación en C para las calculadoras TI-89, TI-89 Titanium, TI-92+ o Voyage 200 es instalar el ambiente de desarrollo que utilizaremos para crear y modificar los proyectos para las calculadoras. Este programa se llama TIGCC, o TI GCC, ya que es una versión modificada del mundialmente renombrado compilador GNU de C gcc para calculadoras TI-68k. Puede descargarlo de la página oficial del proyecto. Una vez que haya descargado el programa, descomprima el archivo tigcc.zip en su disco duro. Si necesita un programa para descomprimir estos archivos, le recomiendo WinRar de RARsoft. Cuando haya extractado el archivo, ejecute el programa setup.exe y sigua las instrucciones.

En la primera pantalla, simplemente haga clic en Siguiente. En la segunda pantalla, acepte la Licencia Pública General GNU. En la tercera pantalla, le recomiendo escoger la IDE [2] de TIGCC, y la "Archive Tool", pero no los Ejemplos TIGCC o el Compilador de Línea de Comandos (Command Line Compiler). En cuarto lugar, le sugiero seleccionar la compresión ExePack, pero no el ensamblador 68k. En la quinta pantalla, seleccione "No System Folder Usage". Puede instalarlo en cualquier lugar que desee. Para el resto de la instalación, sólo haga clic en Siguiente hasta que pueda seleccionar Finalizar. Entonces el programa será instalado. Si quiere ver algunas capturas de pantalla, puede hacer clic aquí.

Puede que haya visto o escuchado acerca de la SDK de TI para escribir software para la TI-89, TI-92+ y Voyage200. No es una mala opción, pero no es para el programador aficionado, ya que tiene demasiadas restricciones. Si necesita escribir software comercial, o aplicaciones Flash ROM, entonces debería considerar la SDK de TI. Pero no es para personas que quieran escribir juegos, o pequeñas y rápidas aplicaciones matemáticas para el colegio, o algún programa similar. Está orientado más hacia desarrollo comercial.

El siguiente paso en el proceso consiste en instalar nuestro ambiente de prueba. Aqui viene la primera, pero probablemente no la última advertencia de que los programas que haga usted mismo pueden bloquear su calculadora. Para evitar cualquier daño a su calculadora, y de paso hacerlo más fácil, usaremos una calculadora Virtual para realizar las pruebas de los programas. De esta forma, si usted bloquea la calculadora, simplemente le puede decir al programa que se reinicie. No es necesario retirar las baterías, ni secuencias de teclado de reseteo, ni cables de conección al PC. Lo realmente bueno es que puede ahorrar baterías al no ejecutar los programas en su calculadora real. Puede descargar Virtual TI de TIcalc.org.

Para instalar VTI, sencillamente descomprima el programa al directorio de su escogencia. VTI puede ser ejecutado desde cualquier lugar de su disco duro. Sin embargo, necesitamos algo más para que el VTI trabaje: una imagen ROM [3]. Una imagen ROM es una copia el software contenido en la calculadora que controla la forma en que esta opera. Esencialmente, el chip de la ROM es el programa de la calculadora, y la calculadora física es solo otro computador similar al que usted está utilizando en este momento. El computador que usted emplea, sin embargo, tiene un chip ROM diferente, que le dice que es un PC.

Hay dos formas de obtener una imagen ROM. Uno, copiarla directamente de su calculadora. Esta es el camino largo y no lo recomiendo. Toma cerca de 45 minutos, y realmente agota las baterías. En vista que la TI-89 y las TI-89+/Voyage 200 son calculadoras FlashROM, podemos cambiar lo que contienen sus chips ROM. La mayoría de estos no pueden ser modificados, pero los chips en las calculadoras para las cuales estamos programando son especiales. Como es posible modificarlos, Texas Instruments produce y hace públicas actualizaciones de sus programas para las calculadoras de forma gratuita desde su sitio web. De aquí es que obtendremos nuestra imagen ROM.

Si usted va a trabajar en una TI-89, puede descargar la imagen de la TI-89 de http://education.ti.com/us/product/tech/89/apps/appslist.html. Para la TI-89 Titanium, la imagen se descarga de http://education.ti.com/educationportal/sites/LATINOAMERICA/productDetail/lat_ti89ti.html?bid=8. La versión para la TI-92+ está disponible en http://education.ti.com/us/product/tech/92p/apps/apps.html, y la de la Voyage200 desde http://education.ti.com/educationportal/sites/LATINOAMERICA/productDetail/lat_v200.html?bid=8. Estas descargas pueden demorar cierto tiempo.

Ahora que tiene el VTI descomprimido en una carpeta, y la imagen ROM, finalizaremos la configuración de VTI. Copie el archivo de la imagen ROM que descargó de Texas Instruments en la misma carpeta en que descomprimió Virtual TI. Ahora puede ejecutar el programa vti.exe. Cuando inicie por primera vez el programa, presione el botón Siguiente. Luego escoja la ROM de la lista y haga clic en Siguinte de nuevo. Finalmente, haga clic en Finalizar. VTI está ahora configurado y listo para usarse.

El botón izquierdo del ratón le permite mover la ventana de VTI alrededor de la pantalla. El botón derecho activa el menú de VTI. Puede seleccionar muchas opciones de este menú. Nos adentraremos en el uso de algunas de las opciones del menú después. Por ahora, volvamos nuestra atención de vuelta a la IDE de desarrollo de TIGCC.

El ambiente de desarrollo de TIGCC es un gran programa. Es utilizado para crear y modificar los proyectos para las calculadoras TI-89, TI-92+/Voyage200 que desarrollemos. Para iniciar el programa, vaya al menú Inicio, bajo Programas - TIGCC SDK - TIGCC IDE.

Cuando el programa inicia por primera vez, mostrará una ventana en blanco en la mitad derecha de la pantalla, y una herramienta de selección de archivos del proyecto al lado izquierdo. En la parte de arriba está la barra de menús y los controles de la barra de herramientas. Para comenzar un nuevo proyecto de TIGCC, escogeremos Project (Proyecto) del menú File (Archivo) bajo el submenú New (Nuevo). Para crear un programa utilizable, sin embargo, necesitaremos crear al menos un archivo más, el primer archivo fuente. Para esto, seleccione el menú File de nuevo, luego el submenú New, y finalmente, la opción C Source File (Archivo Fuente de C). Cuando selecciona esto, un asistente se abrirá permitiéndole escoger las opciones de su proyecto. Para la mayoría de proyectos, seleccionaremos las mismas opciones.

Cuando haya finalizado, TIGCC producirá algo similar a lo siguiente. Excepto por la fecha y la hora, debería verse idéntico. De todas formas, las versiones más recientes pueden cambiar este código ligeramente.

// C Source File
// Created 4/19/2005; 4:27:07 PM

// Delete or comment out the items you do not need.
#define COMMENT_STRING         "Place your comment here."
#define COMMENT_PROGRAM_NAME   "Place your program name here."
#define COMMENT_VERSION_STRING "Place your version string here."
#define COMMENT_VERSION_NUMBER 0,0,0,0 /* major, minor, revision, subrevision */
#define COMMENT_BW_ICON \
	{0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000}
#define COMMENT_GRAY_ICON \
	{0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000}, \
	{0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000, \
	 0b0000000000000000}

#include <tigcclib.h>

// Main Function
void _main(void)
{
	// Place your code here.
}

Antes de hacer cualquier otra cosa, usted probablemente le de un nombre a su archivo fuente en C. Notará al lado izquierdo de la ventana de TIGCC que el archivo aparece como "New File". Haga clic con el botón derecho del mouse en este nuevo archivo y seleccione Rename (Renombrar) del menú emergente. Puede escoger cualquier nombre para este archivo, pero es mejor mantenerlo simple y con sentido. Estaremos creando un nuevo proyecto dentro de poco, así que no importa cómo llame a este archivo, ya que desaparecerá muy pronto.

Está bien, comencemos a programar en TIGCC. Seleccione File - New - Project de la barra de menú en la parte de arriba. Si el programa le pregunta si desea guardar los cambios del proyecto anterior, diga que no. Luego seleccione File - New - C Source File de nuevo. Siga el mismo procedimiento que llevó a cabo en el último paso. Nombre al archivo fuente "hola". No agregue ninguna extensión de archivo; TIGCC se ocupará de esto por nosotros.

Será mejor guardar el proyecto ahora. Escoja el nombre cuidadosamente, porque el nombre del proyecto será el mismo nombre del programa en la calculadora y es difícil cambiarlo después que usted ha guardado el proyecto por primera vez. Escoja File - Save Project As (Guardar Proyecto Como) del menú. Se mostrará el directorio de proyectos de TIGCC. Puede guardar el proyecto allí, o en cualquier lugar que usted elija. Le recomiendo crear un subdirectorio llamado leccion1 para este proyecto. De esta forma, puede mantener todos los archivos fuente de diferentes proyectos separados y organizados. Así, serán más fáciles de manejar cuando tengamos proyectos grandes. Guarde el proyecto con el nombre "hola" también, sin incluir las comillas, obviamente.

Ahora podemos comenzar a modificar el código fuente para lograr que haga algo. Cambie el código del programa de forma que se vea como lo que sigue.

// C Source File
// Created 5/2/2002; 9:38:49 PM
// Updated 8/22/2002; 10:14 PM
// Updated 4/19/2005; 04:38 PM

#include <tigcclib.h>

// Main Function
void _main(void)
{
	const char *cadena = "¡Hola, Mundo!";
	
	// borra la pantalla
	ClrScr();

	// imprime la cadena de caracteres en la esquina superior izquierda de la pantalla
	DrawStr(0,0,cadena,A_NORMAL);
	
	// espera que el usuario presione una tecla antes de salir del programa
	ngetchx();
}

No se preocupe por las fechas y horas que aparecen arriba (pues no coincidirán con las mías), y no intente entender todavía el programa. Será explicado dentro de un rato. Los cambios importantes están marcados en rojo oscuro. Asegúrese de digitar los cambios exactamente igual que en el ejemplo, la ortografía y las mayúsculas y minúsculas son muy importantes.

Tome nota de que borramos todas las líneas en la parte superior que TIGCC creó para nosotros automáticamente. No las usaremos por ahora. Solamente asegúrese de no borrar la línea #include <tigcclib.h>.

Ahora realizaremos los pasos necesarios para crear el programa que será ejecutado en la calculadora. Este proceso se conoce como compilación y enlazamiento. Un programa llamado el compilador toma el código fuente en C que tenemos y lo pasa a otro formato que llamamos código objeto. Este código objeto es esencialmente el programa que correrá en la calculadora. Pero antes que podamos utilizar el código objeto en la calculadora, debemos agregarle algunas cosas de forma que la calculadora entienda como usarlo. Esto lo hace un programa llamado el enlazador (linker). Este programa enlaza el código objeto junto con las instrucciones necesarias para que la calculadora interprete el programa. Cuando se haya finalizado este proceso, tendremos tres archivos: un archivo hola.89z, otro hola.9xz y por último uno llamado hola.v2z. Estos son los archivos de programa para la TI-89 (normal o Titanium), la TI-92+ y la Voyage200, respectivamente.

Para crear el programa, guarde el proyecto hola utilizando la opción File - Save All (Guardar Todo). Ahora seleccione del menú Project (Proyecto) la opción Build (Construir o Generar). Para probar el programa, necesitaremos iniciar Virtual TI. Una vez hecho esto, regrese a TIGCC y haga clic en el botón verde con un ícono de ejecutar (Play) en la barra de herramientas. Este comando transferirá el programa al VTI y lo ejecutará [4]. Debería poder ver los resultados inmediatamente. El programa debe verse de forma similar a lo siguiente:

Hay un par de secciones de un programa escrito en C que deben estar presentes en todo proyecto que usted haga en TIGCC. Estas secciones son:

1. La sección "include" o de sentencias para el preprocesador al comienzo.
2. El método _main().

La sección "include" o de sentencias para el preprocesador consta de las líneas que comienzan con #include. Estas le indican al compilador que agregue ciertas características al programa. La mayoría de las sentencias de este tipo que utilizaremos son definiciones de llamadas a la ROM para el TIOS[5], lo cual hará sus programas muy compatibles. La sintaxis para estas directivas es #include <archivo a incluir>, o #include "archivo a incluir", dependiendo de si es un archivo para incluir global o local. Los archivos globales son los incluidos con TIGCC para funciones de llamadas a la ROM y otras definiciones. Los archivos locales son los que usted mismo escribe para incluirlos en sus programas. Todavía no tenemos ningún ejemplo de archivos de inclusión locales, pero veremos algunos en una lección futura.

La otra sección es el método _main, que es donde el programa inicia. Los programas pueden tener más de un método, así que la calculadora necesita saber donde iniciar la ejecución del programa. Este punto de inicio lo indica el método _main. Así, cualquier código que usted tenga en el método _main, será el primero en ser ejecutado por el programa.

El método _main es donde el programa comienza su trabajo. Toda la ejecución del programa comienza en el método _main. Este método usualmente tiene otros métodos que le ayudan a hacer su trabajo, a los que llamaremos métodos de apoyo. Como un punto de referencia, aunque los métodos y las funciones son muy similares, la palabra método está asociada más frecuentemente con la programación orientada a objetos que con la programación basada en funciones, mientras que la palabra función es más utilizada con el segundo enfoque, pero en estas lecciones, emplearemos ambos términos indistintamente.

El método _main() tiene sólo 4 líneas para hacer su trabajo. Después de todo, es un programa muy simple. Examinemos las 4 líneas con más detalle, para que usted pueda tener una mejor idea de lo que hacen.

const char *cadena = "Hola, Mundo!";

La primera línea del programa es usada para declarar una variable. Todas las variables en C deben ser declaradas al comienzo de una función. Todas las variables en C tienen asociado un tipo, un nombre y un valor. En este caso, el tipo de la variable es const char *, el nombre es cadena y el valor es "¡Hola, Mundo!".

El tipo de variable puede ser separado en diferentes segmentos, la palabra const es la abreviación de constante que significa inmutable o no modificable. La palabra char es la abreviatura de carácter (character en inglés), que significa que la variable contiene caracteres. Finalmente, el asterisco (*) significa que es un puntero a algún lugar de memoria. Cubriremos en detalle el tema de los punteros más adelante. Por ahora es suficiente saber que una cadena de caracteres no puede ser almacenada en una sola variable, así que la almacenaremos en algún lugar de la memoria de la calculadora, y usaremos un puntero constante a caracter para acceder a esta cadena. El enlazador determinará la posición en memoria de esta cadena y nos retornará el puntero a nuestra variable llamada cadena.

// borra la pantalla
ClrScr();

Las siguientes líneas son utilizadas para borrar la pantalla de la calculadora. ClrScr() es una función usada por el programa de la calculadora (TIOS) ya almacenada en la FlashROM. Tenemos acceso a miles de estas funciones para ayudarnos a escribir programas. Esta es la primera de esas funciones que emplearemos. La línea de encima es un comentario. Los comentarios pueden ser utilizados para informarle a la gente como trabaja un programa. Intentaré emplear comentarios libremente de forma que el programa sea fácil de seguir. Le sugiero hacer lo mismo. Incluso si nadie más lee sus programas, usted podría tener que regresar un día y habrá olvidado lo que hizo. Aquí es donde los comentarios vienen muy bien.

// imprime la cadena de caracteres en la esquina superior izquierda de la pantalla
DrawStr(0,0,cadena,A_NORMAL);

Este comando que sigue es usado para imprimir la cadena de caracteres en pantalla. Es otra de las funciones contenidas en la FlashROM. DrawStr es la abreviatura de draw string (dibujar cadena). La función toma cuatro argumentos. Los argumentos son trozos de información que envíamos a la función para ayudarla a llevar a cabo su trabajo. En este caso, necesitamos decirle a la función DrawStr qué es lo que va a imprimir, dónde imprimirlo y cómo lo queremos impreso. 0,0 son las coordenadas donde la cadena será mostrada. En este caso 0,0 se refiere a la esquina superior izquierda de la pantalla. La esquina inferior derecha para la TI-89 es 159,99, y para una TI-92+ o Voyage200 está en 239,127. Esto se debe a que hay 160 pixeles horizontales en la TI-89, 240 para la TI-92+/Voyage200, y 100 pixeles verticales en la TI-89, 128 en la TI-92+/Voyage200. De esta forma, 0-159/239 y 0-99/127 son los rangos de posiciones posibles. La cadena a desplegar es suministrada con la variable "cadena", y A_NORMAL hace referencia a una impresión simple, pixeles orcuros sobre fondo claro. Hay otras opciones que usted puede entregarle a DrawStr para hacer que imprima en diferentes modos, pero A_NORMAL bastará por ahora.

// espera que el usuario presione una tecla antes de salir del programa
ngetchx();

Este último comando es utilizado para obtener entradas desde el teclado. En este ejemplo, lo usamos para esperar a que el usuario presione una tecla antes de salir del programa. Si no detuviéramos el programa antes de salir de él, imprimiría la cadena y regresaría a la pantalla principal de la calculadora tan rápido, que no podríamos ver qué sucedió. Así que para pequeños programas como este, detendremos el programa al final para poder ver los resultados. Así, una vez que el programa ha desplegado la cadena de caracteres, esperará hasta que el usuario presione una tecla antes de salir.

Espero que haya aprendido algo en esta lección. Sé que es bastante básica, pero introduce los conceptos básicos de programación en el entorno de TIGCC y de prueba de programas usando VTI. La siguiente lección no será tan "mickey mouse", así que espero que esté preparado. Estas lecciones introductorias son básicamente clones de mis antiguas lecciones de ensamblador, pero aprenderemos técnicas más complejas en C, porque C es más divertido, y mucho más fácil de usar.

Juegue un poco con el código fuente. Lea la documentación de TIGCC. Hay mucha información en la documentación de TIGCC. Envíele saludos a Zeljko Juric. ¡Es una deidad en la comunidad TI!¡Nunca lo olvide! Hay información allí sobre todas las funciones de TIGCC, muchos ejemplos y una guía de referencia de C decente que le ayudará bastante al comienzo, y probablemente después también. Así que échele un vistazo.

[1]: El emulador Virtual TI se considera actualmente obsoleto, por lo cual se recomienda utilizar TI Emu, que puede ser descargado desde aquí.
[2]: IDE (Integrated Development Enviroment). Se conoce como IDE a las interfaces gráficas que incluyen muchas herramientas de desarrollo de software, con numerosas herramientas y opciones como un editor de código, acceso rápido a funciones y segmentos de código utilizados con frecuencia, y a las tareas de compilación, enlazamiento, etc.
[3]: El emulador TI-Emu puede trabajar con imágenes ROM, pero no son requeridas; puede ser utilizado con las actualizaciones del sistema operativo de la calculadora, descargables de la página de Texas Instruments.
[4]: Si está utilizando Ti-Emu, deberá enviar manualmente al emulador el archivo de programa generado correspondiente a la calculadora que está utilizando, y ejecutarlo desde el emulador, digitando el nombre del programa, seguido de dos paréntesis. Por ejemplo, en este caso sería "hola()" sin las comillas.
[5]: TIOS es una abreviatura utilizada para designar el sistema operativo incorporado con las calculadoras de Texas Instruments. En el caso de las calculadoras 68k (TI-89, Ti-92+ y Voyage 200) este sistema operativo se llama Advance Mathematics Software (AMS) e incorpora muchísimas funciones de uso interno en su funcionamiento, la mayoría de las cuales pueden ser utilizadas en TIGCC.

Lección 1: Un Ejemplo Clásico "Hola Mundo"
¿Preguntas o Comentarios? Contácteme.