A basic guide to show how to use interruptions on programs using a MSP430FR6989 microcontroller and the GCC tools on Linux.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

440 lines
18 KiB

2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
  1. # Guía de usuario MSP430 GCC Toolchain
  2. ------
  3. [^]: Para usuarios de Linux
  4. **Abstract**
  5. 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.
  6. ------
  7. ## Introducción
  8. El paquete GCC de código abierto es un depurador completo y una cadena de herramientas de compilación C/C++ de código abierto para la creación y depuración de aplicaciones integradas basadas en microcontroladores MSP430. Este compilador soporta todos los dispositivos MSP430 sin limitaciones de tamaño de código y se puede utilizar de forma independiente desde la línea de comandos o dentro de Code Composer Studio v6.0 o posterior [1].
  9. El paquete de instalación incluye lo siguiente:
  10. 1. Binarios GCC y GDB para Windows y Linux
  11. 2. Encabezado MSP430 y archivos de enlace
  12. 3. Código fuente
  13. 4. GBD Agent Configuration
  14. #### Instalación de MSP430 GCC como paquete independiente
  15. 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.
  16. Con el comando **cd** se puede entrar a alguna carpeta en específico como lo puede ser la carpeta de **Descargas**, Ejemplo:
  17. ```c
  18. $ cd Descargas
  19. ```
  20. Antes de continuar con el siguiente paso se debe dirigir a la pagina oficial de TI (Texas Instruments) y yendo directamente a la siguiente pagina [https://www.ti.com/tool/MSP430\-GCC\-OPENSOURCE]() en la pestaña de descargas seleccione la opción mas factible para su computadora en este caso **Mitto Systems GCC 64-bit Linux installer incl. support files**.
  21. Una vez descargada, se debe buscar en la carpeta de descargas el nombre del archivo.
  22. Ya una vez se tiene el nombre del archivo descargado, en la terminal de comando se debe colocar lo siguiente, lo cual nos permitirá instalar el programa, colocando sudo **chmod +x <installer>.run** y el comando **./<installer>**.
  23. ```c
  24. $ sudo chmod +x msp430-gcc-full-linux-X64-installer-9.3.1.2.run
  25. $ ./msp430-gcc-full-linux-X64-installer-9.3.1.2.run
  26. ```
  27. Lo cual abrirá la siguiente ventana:
  28. ![](/home/griscampos/Descargas/msp430Guia/1.jpeg)
  29. Seleccione el directorio de instalacion y de click en **Next** hasta finalizar .
  30. Como se muestra en la siguiente imagen.
  31. ![](/home/griscampos/Descargas/msp430Guia/2.jpeg)
  32. Crea una carpeta en donde colocaras el código.
  33. > Comando para crear carpetas desde la terminal , el comando **mkdir** + el nombre del nuevo archivo.
  34. > Comando para encontrar carpetas dentro de la carpeta en la que se encuentra **dir**.
  35. > Comando para entrar en carpeta **cd**.
  36. ```c
  37. $ mkdir Programa1
  38. $ dir
  39. $ cd Programa1
  40. ```
  41. Ya dentro de la carpeta en la que colocaras el código coloca el siguiente comando para colocar el código desde la terminal.
  42. <<<<<<< HEAD
  43. =======
  44. ```c
  45. $ main.c
  46. ```
  47. En el cual se copiara y pegara cualquier código a utilizar.
  48. Ejemplo de código para hacer parpadear un led:
  49. >>>>>>> parent of c6aec50 (Ordené y corregí algunas cosas del documento en general)
  50. ```c
  51. $ main.c
  52. ```
  53. En el cual se copiara y pegara cualquier código a utilizar.
  54. Ejemplo de código para hacer parpadear un led:
  55. ```c
  56. #include <msp430fr6989.h>
  57. void main(void)
  58. {
  59. WDTCTL = WDTPW | WDTHOLD; // stop watchdog timer
  60. PM5CTL0 = 0x0000; // disable high impedance mode
  61. P1DIR = 0x01; //set up bit 0 of P1 as output
  62. P1OUT = 0x00; //initialize bit 0 of P1 to 0
  63. for(;;){ //loop
  64. volatile unsigned int i;
  65. P1OUT ^= 0x01; //toggle bit 0 of P1
  66. //Delay
  67. for(i=40000; i>0;){
  68. i--;
  69. __no_operation();
  70. }
  71. }
  72. }
  73. ```
  74. #### Compilar un programa desde la termial de Linux
  75. <<<<<<< HEAD
  76. El programa se puede compilar manualmente desde la terminal indicando las rutas de instalación de las librerías, binarios y demás, o usando un método más sencillo implementando un archivo *Makefile* incluido en los ejemplos por defecto que el paquete contiene. En este documento se muestran los pasos a seguir empleando el segundo método comenzando con la creación de un nuevo proyecto; sin embargo, a continuación, se muestra un ejemplo de compilación manual desde la terminal.
  77. Ejemplo de compilación de un programa desde la terminal (primer método):
  78. ```c
  79. $ ./msp430-elf-gcc -I ~/msp430-gcc/include -L ~/msp430-gcc/include -T ~/msp430-gcc/include/msp430fr6989.ld -mmcu=msp430fr6989 -O2 -g ~/Documentos/Code/main.c -o ~/Documentos/Code/main.o
  80. ```
  81. Primero se debe dirigir a la dirección en donde se encuentra instalado el paquete *MSP430- GCC* y redireccionarse a la carpeta *bin*.
  82. Para compilar se coloca ./ seguido de la dirección *msp430-elf-gcc*.
  83. Y después coloca los parámetros correspondientes a -I, -L, -T, -g, -o, mmcu
  84. Donde:
  85. -I :Agrega el directorio a la lista de directorios para buscar archivos de encabezado.
  86. -L: Agrega rutas en las que ld buscara bibliotecas de archivo.
  87. -T: Dirección donde se encuentra las librerías del microcontrolador\\ especificando cual utilizaras
  88. -g: dirección donde se encuentra tu archivo .c
  89. -o: dirección donde se encuentra tu archivo .c con la diferencia que se cambia el .c por .o
  90. Mmcu: especifica el microcontrolador que utilizaras
  91. ## **Creación de un nuevo proyecto**
  92. ------
  93. ##### Pasos para la creación de un nuevo proyecto
  94. 1. Crear un directorio para el nuevo proyecto.
  95. 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**.
  96. 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.
  97. 4. Abrir el archivo **Makefile** que copió y cambiar el formato de estructura actual por el que se muestra en la Figura Estructura de archivo Makefile. 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á.
  98. 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.
  99. ```c
  100. OBJECTS=main.o
  101. GCC_DIR = /home/usuario/msp430-gcc/bin
  102. SUPPORT_FILE_DIRECTORY = /home/usuario/msp430-gcc/include
  103. DEVICE = msp430fr6989
  104. CC = $(GCC_DIR)/msp430-elf-gcc
  105. GDB = $(GCC_DIR)/msp430-elf-gdb
  106. CFLAGS = -I $(SUPPORT_FILE_DIRECTORY) -mmcu=$(DEVICE) -O2 -g
  107. LFLAGS = -L $(SUPPORT_FILE_DIRECTORY) -T $(DEVICE).ld
  108. all: ${OBJECTS}
  109. $(CC) $(CFLAGS) $(LFLAGS) $? -o $(DEVICE).out
  110. debug: all
  111. $(GDB) $(DEVICE).out
  112. ```
  113. #### Creación de un archivo .c
  114. Para crear un archivo .c dirijase en el directorio en el que lo desea crear y digite el siguiente comando **pico filename.c**. Por fines explicativos, como ejemplo, se creará un archivo .c llamado **Ejemplo** en la carpeta **Programa1**,como se muestra el comando antes mencionado adaptado al ejemplo.
  115. ```c
  116. $ pico ejemplo.c
  117. ```
  118. =======
  119. El programa se puede compilar manualmente desde la terminal indicando las rutas de instalación de las librerías, binarios y demás, o usando un método más sencillo implementando un archivo *Makefile* incluido en los ejemplos por defecto que el paquete contiene. En este documento se muestran los pasos a seguir empleando el segundo método comenzando con la creación de un nuevo proyecto; sin embargo, a continuación, se muestra un ejemplo de compilación manual desde la terminal.
  120. Ejemplo de compilación de un programa desde la terminal (primer método):
  121. ```c
  122. $ ./msp430-elf-gcc -I ~/msp430-gcc/include -L ~/msp430-gcc/include -T ~/msp430-gcc/include/msp430fr6989.ld -mmcu=msp430fr6989 -O2 -g ~/Documentos/Code/main.c -o ~/Documentos/Code/main.o
  123. ```
  124. Primero se debe dirigir a la dirección en donde se encuentra instalado el paquete *MSP430- GCC* y redireccionarse a la carpeta *bin*.
  125. Para compilar se coloca ./ seguido de la dirección *msp430-elf-gcc*.
  126. Y después coloca los parámetros correspondientes a -I, -L, -T, -g, -o, mmcu
  127. Donde:
  128. -I :Agrega el directorio a la lista de directorios para buscar archivos de encabezado.
  129. -L: Agrega rutas en las que ld buscara bibliotecas de archivo.
  130. -T: Dirección donde se encuentra las librerías del microcontrolador\\ especificando cual utilizaras
  131. -g: dirección donde se encuentra tu archivo .c
  132. -o: dirección donde se encuentra tu archivo .c con la diferencia que se cambia el .c por .o
  133. Mmcu: especifica el microcontrolador que utilizaras
  134. ## **Creación de un nuevo proyecto**
  135. ------
  136. ##### Pasos para la creación de un nuevo proyecto
  137. 1. Crear un directorio para el nuevo proyecto.
  138. 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**.
  139. 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.
  140. 4. Abrir el archivo **Makefile** que copió y cambiar el formato de estructura actual por el que se muestra en la Figura Estructura de archivo Makefile. 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á.
  141. 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.
  142. ```c
  143. OBJECTS=main.o
  144. GCC_DIR = /home/usuario/msp430-gcc/bin
  145. SUPPORT_FILE_DIRECTORY = /home/usuario/msp430-gcc/include
  146. DEVICE = msp430fr6989
  147. CC = $(GCC_DIR)/msp430-elf-gcc
  148. GDB = $(GCC_DIR)/msp430-elf-gdb
  149. CFLAGS = -I $(SUPPORT_FILE_DIRECTORY) -mmcu=$(DEVICE) -O2 -g
  150. LFLAGS = -L $(SUPPORT_FILE_DIRECTORY) -T $(DEVICE).ld
  151. all: ${OBJECTS}
  152. $(CC) $(CFLAGS) $(LFLAGS) $? -o $(DEVICE).out
  153. debug: all
  154. $(GDB) $(DEVICE).out
  155. ```
  156. #### Creación de un archivo .c
  157. Para crear un archivo .c dirijase en el directorio en el que lo desea crear y digite el siguiente comando **pico filename.c**. Por fines explicativos, como ejemplo, se creará un archivo .c llamado **Ejemplo** en la carpeta **Programa1**,como se muestra el comando antes mencionado adaptado al ejemplo.
  158. ```c
  159. $ pico ejemplo.c
  160. ```
  161. >>>>>>> parent of c6aec50 (Ordené y corregí algunas cosas del documento en general)
  162. Para crear un archivo .c dirijase en el directorio en el que lo desea crear y digite el siguiente comando **pico filename.c**. Por fines explicativos, como ejemplo, se creará un archivo .c llamado **Ejemplo** en la carpeta **Programa1**, en la Figura se muestra el comando antes mencionado adaptado al ejemplo.
  163. ```c
  164. #include <msp430fr6989.h>
  165. int main(void) {
  166. volatile int i;
  167. // stop watchdog timer
  168. WDTCTL = WDTPW | WDTHOLD;
  169. // set up bit 0 of P1 as output
  170. P1DIR = 0x01;
  171. // intialize bit 0 of P1 to 0
  172. P1OUT = 0x00;
  173. // loop forever
  174. for (;;) {
  175. // toggle bit 0 of P1
  176. P1OUT ^= 0x01;
  177. // delay for a while
  178. for (i = 0; i < 0x6000; i++);
  179. [ 26 líneas leídas ]
  180. ^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
  181. ^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
  182. ```
  183. ## **Debugging**
  184. #### **Uso del agente GDB **
  185. ###### Introducción
  186. El agente GDB es una herramienta para conectar el GDB con el hardware de destino para depurar su software. El GDB
  187. El agente utiliza la pila de depuración MSP430 para conectarse al hardware y proporciona una interfaz al GDB.
  188. En Windows, se proporciona una consola y una versión de aplicación GUI del agente GDB. Solo la aplicación de consola es compatible con Linux.
  189. #### Iniciando GDB Agent
  190. ###### Línea de comando
  191. Abra una terminal de comando y dirijase al directorio de instalación, una vez que lo haga, ejecute lo siguiente:
  192. ```c
  193. $ ./bin/gdb\_agent\_console msp430.dat
  194. ```
  195. La aplicación de consola abre un puerto TCP/IP en el equipo local. Muestra el número de puerto en la consola. Por defecto, este número de puerto es 55000.
  196. [^]: Es importante que deje abierta esta consola hasta terminar de depurar el programa (debugging) para poder conectar el GDB con el GDB Agent.
  197. ```c
  198. $ ./bin/gdb\_agent\_console msp430.dat
  199. CPU Name Port
  200. -------- ----
  201. msp430 :55000
  202. Starting all cores
  203. CPU Name Status
  204. -------- ------
  205. msp430 Waiting for client
  206. ```
  207. #### Debugging con GDB
  208. ##### Ejecutar un programa en el debugger
  209. 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.
  210. 2. Escriba el comando **make debug**. Este comando inicia el GDB y espera que se introduzcan comandos, esto es indicado por el puntero **(gdb)**.
  211. ```c
  212. $ make debug
  213. /home/usuario/msp430-gcc/bin/msp430-elf-gcc -I /home/usuario/msp430-gcc/include -mmcu=msp430fr6989 -O2 -g -L /home/usuario/msp430-gcc/include -T msp430fr6989.ld Ejemplo.o -o msp430fr6989.out
  214. /home/usuario/msp430-gcc/bin/msp430-elf-gdb msp430fr6989.out
  215. GNU gdb (Mitto Systems Limited - msp430-gcc 9.3.1.11) 9.1
  216. Copyright (C) 2020 Free Software Foundation, Inc.
  217. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
  218. This is free software: you are free to change and redistribute it.
  219. There is NO WARRANTY, to the extent permitted by law.
  220. Type "show copying" and "show warranty" for details.
  221. This GDB was configured as "--host=x86_64-pc-linux-gnu --target=msp430-elf".
  222. Type "show configuration" for configuration details.
  223. For bug reporting instructions, please see:
  224. <http://www.gnu.org/software/gdb/bugs/>.
  225. Find the GDB manual and other documentation resources online at:
  226. <http://www.gnu.org/software/gdb/documentation/>.
  227. For help, type "help".
  228. Type "apropos word" to search for commands related to "word"...
  229. Reading symbols from msp430fr6989.out...
  230. (gdb)
  231. ```
  232. 3. Conecte el dispositivo.
  233. 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.
  234. ```c
  235. Reading symbols from msp430fr6989.out...
  236. (gdb) target remote :55000
  237. Remote debugging using :55000
  238. 0x00004402 in __crt0_start ()
  239. (gdb)
  240. ```
  241. Consola del GDB Agent:
  242. ```c
  243. $ ./bin/gdb\_agent\_console msp430.dat
  244. CPU Name Port
  245. -------- ----
  246. msp430 :55000
  247. Starting all cores
  248. CPU Name Status
  249. -------- ------
  250. msp430 Waiting for client
  251. msp430 Client connected...Connecting to Target
  252. Found USB FET at ttyACM0
  253. Target connected...Starting server
  254. ```
  255. 5. Escriba **load** y presione enter para cargar el programa binario al dispositivo MSP430 que esté usando.
  256. ```c
  257. (gdb) load
  258. Loading section .upper.data, size 0x2 lma 0x4400
  259. Loading section .text, size 0x3c lma 0x4402
  260. Loading section __reset_vector, size 0x2 lma 0xfffe
  261. Start address 0x00004402, load size 64
  262. Transfer rate: 71 bytes/sec, 21 bytes/write.
  263. (gdb)
  264. ```
  265. 6. Escriba el comando **continue** para correr el programa o en su defecto escriba **step** para compilar elprograma por partes.
  266. ```c
  267. (gdb) continue
  268. Continuing.
  269. ```
  270. 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.
  271. ```c
  272. ^C
  273. Program stopped.
  274. main () at Ejemplo.c:15
  275. 15 i--;
  276. (gdb) q
  277. A debugging session is active.
  278. Inferior 1 [Remote target] will be detached.
  279. Quit anyway? (y or n) y
  280. Detaching from program: /home/usuario/Escritorio/msp430_programs/Programa1/msp430fr6989.out, Remote target
  281. Ending remote debugging.
  282. [Inferior 1 (Remote target) detached]
  283. ```
  284. ### **Solución de problemas**
  285. [^]: En este apartado se muestran las posibles soluciones a los problemas más comunes.
  286. **Error Make debug*
  287. ```c
  288. $ make debug
  289. Make: *** There is no rule to build the 'debug' target. Tall
  290. ```
  291. Instala make para solucionar el problema mediante el comando :
  292. ```c
  293. sudo apt-get install make
  294. ```
  295. ------
  296. **Error 127 makefile debug*
  297. ```c
  298. /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
  299. make: *** [Makefile: debug] Error 127
  300. ```
  301. Instala la libreria libncursesw.so.5 para solucionar el problema mediante el comando :
  302. ```c
  303. sudo apt-get install libncursesw.so.5
  304. ```
  305. <<<<<<< HEAD
  306. ### **Referencia**
  307. <<<<<<< HEAD
  308. [1] Texas Instruments. Msp430-gcc-opensource gcc-open source compiler for msp microcontrollers, 2017.
  309. =======
  310. ------
  311. >>>>>>> ae78620e48dc821fc33b729ff6f00058750ec868
  312. =======
  313. >>>>>>> parent of c6aec50 (Ordené y corregí algunas cosas del documento en general)