Programando microcontrolador ARM: 7 - Nuevo entorno de desarrollo Open System Workbench for STM32 (Eclipse) (stm32f103c8)


Para facilitar el acceso al desarrollo y programación de microcontroladores STM32 vamos a cambiar a un entorno de desarrollo multiplataforma, de esta manera cualquier usuario, tanto Windows, Mac y Linux, podrá acceder a la información publicada en este blog.

El entorno que vamos a utilizar es System Workbench for STM32, este IDE está basado en Eclipse y contiene todo lo necesario para poder programar nuestros microcontroladores. Además de nuestro BluePill basado en STM32F103 vamos a poder programas toda la gama de microcontroladores STM32, aunque hay que tener en cuenta debemos configurar los proyectos específicamente para cada microcontrolador.

DESCARGA E INSTALACIÓN

Para poder descargar el entorno de desarrollo necesitamos registrarnos en la web de OpenSTM32, http://www.openstm32.org/HomePage.

Una vez registrados tendremos pleno acceso a la web y por tanto a las descargas. Seleccionaremos en el menú de la izquierda System Workbench for STM32.

Entonces nos aparecerá todo lo necesario para descargar el entorno. Además disponemos de una guía detallada para instalar correctamente el IDE para cada plataforma.

CREAR Y CONFIGURAR PROYECTO

Para configurar nuestro proyecto debemos empezar por crear un nuevo proyecto. Para crear un nuevo proyecto debemos ir a  File ->  New -> C Project. De esta manera nos aparecerá la primera ventana de configuración del proyecto.

En esta ventana (1) vamos a seleccionar un proyecto de tipo Executable y Ac6 STM32 MCY Project y con el toolchain Ac6 STM32 MCU GCC.

A continuación nos aparecerá la ventana (2) que nos permite seleccionar configuraciones, indicaremos que usaremos ambas configuraciones, Debug y Release.




La siguiente ventana nos va a solicitar indicar el microcontrolador que vamos a querer usar, en nuestro caso vamos a seleccionar  STM32F103C8Tx.

Primero debemos seleccionar la pestaña de Mcu, esta pestaña nos permite buscar directamente por modelos de microcontroladores STM32. Boards nos permite encontrar las diferentes placas que existen en el mercado con STM32.

Podemos usar varios filtros como escribir directamente el nombre del microcontrolador o filtrar por serie. De ambas maneras podemos lograr encontrar en microcontrolador que estamos usando.

A continuación es muy importante darle al botón de Next y no a finalizar. Si finalizamos en este paso no podremos terminar de configurar adecuadamente.


El siguiente paso nos permite configurar las bibliotecas necesarias para poder programar el microcontrolador.

Debemos seleccionar la opción de Standard Peripherial Library  (StdPeriph). Esta biblioteca es el fichero de tipo header stm32f10x.h, el cual contiene numerosos métodos definiciones de variables útiles a la hora de programar. 

Por último en caso de que no tengamos descargada la biblioteca nos aparecerá el botón de Download target firmaware en verde, una vez descargado el propio proyecto encintará los ficheros necesarios. 
Por lo general esta acción solo se realiza una vez por cada tipo de microcontrolador concretos que fuéramos a programar. Una vez realizado este paso, no necesitaríamos conexión a Internet para poder crear un proyecto nuevo.

Ahora el proyecto aparecerá en el Project Explorer, generalmente situado a la izquierda. Dentro del proyecto podemos encontrar la carpeta src y dentro el fichero main.c.

Configuración de Run y Debug

Para poder cargar nuestro código debemos realizar unas últimas configuraciones, en este caso tratan la manera en al que el código se carga en el microcontrolador.

Primero vamos a crear los ficheros necesarios para poder configurar estas opciones. Para crearlos simplemente pulsamos en el icono de Run o Debug.



Ahora si podemos acceder a la configuración de para cargar le código. Para acceder a estas configuraciones  debemos desplegar el menú de Debug o Run, cualquiera de ellos no van a llevar al mismo dialogo.


Podemos crear diferentes configuraciones para un proyecto y podremos ver todas las configuraciones de los proyectos. Podemos darle el nombre que queramos a cada configuración. Esto no es útil en caso de cargar el proyecto para diferentes microcontroladores que dispongan de configuraciones diferentes o vayamos a usar diferentes métodos de carga.


A continuación debemos acceder a la pestaña debugger. En ella debemos realizar varios cambios, primero debemos desplegar la opciones del generador, para ello presionamos en Show generator options. Al abrir esta opción debemos modificar el Reset Mode y seleccionar Software system Reset.
A continuación debemos marcar la opción de Shareable ST-Link. Como se puede ver al accionar esta opción automáticamente podemos ver si tenemos la placa o el microcontrolador conectado y comprobar si las conexiones son correctas.



Una vez que tengamos nuestra placa conectada podemos usar el botón de refres y automáticamente aparecerá nuestra placa.
Además tenemos la posibilidad de cambiarle el nombre para poder identificarla con otras y también podemos hacer parpadear el LED del programador ST-Link, de esta manera es mas fácil identificarlos microcontroladores

Ahora nos desplazamos a la pestaña Startup, en ella simplemente debemos desmarcar las opciones de Reset and Delay y Halt.


En este punto ya podemos subir y probar nuestro código. Para ello primero debemos tener conectado nuestro Blue Pill STM32F103 a través del ST-LinkV2 que disponemos. Aconsejo iniciar el programa siempre en modo debug, de esta manera podemos controlar mejor lo que pasa al cargar el código y podremos visualizar errores o advertencias en caso de que los hubiera.

Al accionar el debug entramos en la vista debug, si todo está correcto no recibiremos ningún error y el código estará ya cargado. Es posible que tengamos que accionar el play que se encuentra arriba a la izquierda en verde para que el código corra en modo debug. Debemos tener en cuenta que el código se carga desde un principio en el microcontrolador.

Podemos probar un primer código muy sencillo:
_________________________________________________________________
#include "stm32f10x.h"
void delay(long cycles);
void GPIOC_Init(void);
void led_blink(void);

int main(void)
{
GPIOC_Init();

while(1){

led_blink();
delay(500);
}
}

/***************************************************
 * Initialize GPIOC and pin13 as PP y max speed V1
 ***************************************************/
void GPIOC_Init(void)
{
RCC->APB2ENR |= RCC_APB2ENR_IOPCEN; //iniciamos el reloj para los pines del puerto C
GPIOC->CRH |= GPIO_CRH_MODE13; // en el pin 13 ponemos CNF 00 (General purpose push-pull)
   // y tambien Output mode, max speed 50MHz
}

/*******************************************
 * Blink led_blink macro
 *******************************************/
void led_blink(void){

//clear pin set to 0
GPIO_ResetBits(GPIOC, GPIO_Pin_13);
//reset 0010 0000 0000 0000 |set 0000 0000 0000 0000
delay(2000000);

       //set pin to 1
GPIO_SetBits(GPIOC, GPIO_Pin_13);
//reset 0000 0000 0000 0000 |set 0010 0000 0000 0000
delay(2000000);

}

/*******************************************
 * Delay
 *******************************************/
void delay (long cycles){
while (cycles > 0)
cycles--;
}
_________________________________________________________________

Cuando el código está en marcha tenemos varias vistas interesantes en el modo debug, aconsejo añadir algún breakpoints en el código y así podemos observar el valor de variables y registros de memoria en tiempo real.



Para cualquier duda escribir un comentario, si hay dudas iré modificando el tutorial para fortalecerlo con la información requerida.




0 comentarios:

Publicar un comentario