This manual aims to describe the setup and basic operations of the MSP430 GCC toolchain to know how to use the open-source GCC compiler for microcontrollers to build an example for an MSP430 target device using the command terminal of Linux. It will also be shown how to debug software with the GDB Agent and the GNU Debugger tools so that the program that was built can be uploaded to the target device successfully.
[^]:This user guide was approved in the following distributions of Linux: **Ubuntu 22.04LTS** and **Debian 11** using a **MSP430FR6989** microcontroller.
------
[TOC]
@ -32,13 +33,13 @@ El paquete GCC de código abierto es un depurador completo y una cadena de herra
El primer paso es bastante sencillo, consiste en abrir la terminal de comando y direccionarse a la carpeta en donde se guardará el archivo que contenga el programa a ejecutar.
Con el comando **cd** se puede entrar a alguna carpeta en específico como lo puede ser la carpeta de **Descargas**, Ejemplo:
```c
```bash
$ cd Descargas
```
Antes de continuar con el siguiente paso se debe dirigir a la página oficial de TI (Texas Instruments) yendo directamente a la siguiente página [https://www.ti.com/tool/MSP430\-GCC\-OPENSOURCE](). En la pestaña de *descargas* se debe seleccionar la opción más factible para su computadora en este caso **Mitto Systems GCC 64-bit Linux installer incl. support files**. Una vez descargada, en la carpeta de descargas se debe buscar el nombre del archivo y posteriormente, en la terminal de comando se debe colocar lo siguiente: "**sudo chmod +x <installer>.run** y el comando **./<installer>**", lo cual permitirá instalar el programa. A continuación se muestra un ejemplo, donde **msp430-gcc-full-linux-X64-installer-9.3.1.2.run**, es el nombre del archivo que se descargó (installer).
@ -59,7 +60,7 @@ Se debe crear una carpeta en donde se colocará el código y los archivos necesa
> Comando para encontrar carpetas dentro de la carpeta en la que se encuentra **dir**.
> Comando para entrar en carpeta **cd**.
```c
```bash
$ mkdir Programa1
$ dir
$ cd Programa1
@ -94,8 +95,9 @@ void main(void)
Para crear un archivo **.c** se debe posicionar en el directorio en el que lo desea crear y se debe digitar el comando **pico filename.c**. Por fines explicativos, como ejemplo, se creará un archivo **.c** llamado **Ejemplo** en la carpeta **Programa1** (previamente creada). Una vez que se ejecuta el comando mencionado, se abrirá una ventana en la que se deberá copiar el códiogo del programa que se quiere subir a la tarjeta. En nuestro caso se copió el código mencionado anteriormente.
Comando para editar/crear el archivo **.c**.
[^]: Este ejemplo fue realizado con el editor de texto pico, pero se puede utilizar cualquier otro editor de su preferencia.
```c
```bash
$ pico Ejemplo.c
```
@ -123,13 +125,9 @@ void main(void)
}
[ 26 líneas leídas ]
^G Ayuda ^O Guardar ^W Buscar ^K Cortar ^T Ejecutar ^C Ubicación M-U Deshacer M-A Poner marca M-] A llave M-Q Anterior ^B Atrás ^◂ Palabr ant
^X Salir ^R Leer fich. ^\ Reemplazar ^U Pegar ^J Justificar ^/ Ir a línea M-E Rehacer M-6 Copiar ^Q Buscar atrás M-W Siguiente ^F Adelante ^▸ Palabra Siguiente
```
Una vez copiado el código, se teclea `Ctrl + X` para salir, posteriormente se guarda el archivo tecleando **S** y por último se teclea **Enter** para regresar a la terminal de comandos.
Una vez copiado el código, se teclea `Ctrl + X` para salir, posteriormente se guarda el archivo tecleando `S` y por último se teclea `Enter` para regresar a la terminal de comandos.
#### Compilación de un programa desde la termial de Linux
@ -161,8 +159,8 @@ Donde:
1. Crear un directorio para el nuevo proyecto.
2. Insertar el archivo .c que contiene el programa que se subirá a la tarjeta. Para crear un archivo .c vea el apartado **Creación de un archivo .c**.
3. Dentro de la carpeta que se instaló (msp430-gcc), hay un directorio llamado **examples** que contiene ejemplos predeterminados. Copiar uno de los archivos **Makefile** de los proyectos de ejemplo dentro del directorio de su nuevo proyecto, en este caso, dentro de la carpeta **Programa1**.
4. Abrir el archivo **Makefile** que copió y cambiar el formato de estructura actual por el que se muestra a continuación. En la variable **OBJECTS** se debe colocar el nombre del programa que se va a subir (archivo .c) respetando la terminación **.o**. En la variable **DEVICE** se debe colocar el nombre del microcontrolador que se usará.
3. Dentro de la carpeta que se instaló (msp430-gcc), hay un directorio llamado **examples** que contiene ejemplos predeterminados. Copiar uno de los archivos `Makefile` de los proyectos de ejemplo dentro del directorio de su nuevo proyecto, en este caso, dentro de la carpeta **Programa1**.
4. Abrir el archivo `Makefile` que copió y cambiar el formato de estructura actual por el que se muestra a continuación. En la variable **OBJECTS** se debe colocar el nombre del programa que se va a subir (archivo .c) respetando la terminación **.o**. En la variable **DEVICE** se debe colocar el nombre del microcontrolador que se usará.
5. Colocar las rutas de instalación correpondientes para las variables **GCC\_DIR** y **SUPPORT\_FILE\_DIRECTORY**. Las direcciones para las variables son **../../../bin** y **../../../include** respectivamente como se muestra en el siguiente ejemplo.
Estructura de archivo Makefile:
@ -203,7 +201,7 @@ En Windows, se proporciona una consola y una versión de aplicación GUI del age
Abra una terminal de comando y dirijase al directorio de instalación, una vez hecho, ejecute lo siguiente:
```c
```bash
$ ./bin/gdb\_agent\_console msp430.dat
```
@ -227,11 +225,11 @@ msp430 Waiting for client
##### Ejecutar un programa en el debugger
1. Abra otra terminal de comando y dirijase a la ruta donde se encuentra el directorio con el archivo **.c** y el **Makefile** del programa que quiere cargar a la tarjeta.
1. Abra otra terminal de comando y dirijase a la ruta donde se encuentra el directorio con el archivo **.c** y el `Makefile` del programa que quiere cargar a la tarjeta.
2. Escriba el comando **make debug**. Este comando inicia el GDB y espera que se introduzcan comandos, esto es indicado por el puntero **(gdb)**.
4. Escriba el comando **target remote :55000** y presione enter para conectar el GDB con el GDB Agent que se encuentra en la otra terminal de comando que se dejó abierta. En la otra terminal se podrá observar en la consola del GDB Agent que se conectó un dispositivo/cliente.
```c
```bash
Reading symbols from msp430fr6989.out...
(gdb) target remote :55000
Remote debugging using :55000
@ -285,7 +283,7 @@ msp430 Waiting for client
5. Escriba **load** y presione enter para cargar el programa binario al dispositivo MSP430 que esté usando.
```c
```bash
(gdb) load
Loading section .upper.data, size 0x2 lma 0x4400
Loading section .text, size 0x3c lma 0x4402
@ -297,14 +295,14 @@ msp430 Waiting for client
6. Escriba el comando **continue** para correr el programa o en su defecto escriba **step** para compilar el programa paso por paso.
```c
```bash
(gdb) continue
Continuing.
```
7. Para parar la ejecución teclee **Ctrl + C** (^C), y para salir del GDB escriba **q**, presione enter y posteriormente escriba **y** y presione enter.
7. Para parar la ejecución teclee `Ctrl + C` (^C), y para salir del GDB escriba `q`, presione enter y posteriormente escriba `y` y presione enter.
```c
```bash
^C
Program stopped.
main () at Ejemplo.c:15
@ -326,14 +324,14 @@ msp430 Waiting for client
**Error Make debug*
```c
```bash
$ make debug
Make: *** There is no rule to build the 'debug' target. Tall
```
Instalar make para solucionar el problema mediante el comando :
```c
```bash
sudo apt-get install make
```
@ -341,14 +339,14 @@ sudo apt-get install make
**Error 127 makefile debug*
```c
```bash
/home/usuario/msp430-gcc/bin/msp430-elf-gdb:error while loading shared libraries: libncursesw.so.5: cannot open shared object file: No such file or directory
make: *** [Makefile: debug] Error 127
```
Instalar la libreria *libncursesw.so.5* para solucionar el problema, en caso de que continúe el problema, instalar *libncursesw5-dev* mediante el comando :
