Circuito de grabación de un STM32F446RET6

➤ Objetivo

Programar un microcontrolador STM32F446RET6 o similar mediante el grabador ST-LINK de una tarjeta Nucleo. 

Es recomendable ver la entrada anterior del blog.

➤ Material necesario

- Una tarjeta Nucleo-F446RE.
- Un microcontrolador  STM32F446RET6.
- IDE: mikroC PRO for ARM (puede usarse otro).
- Otros componentes (LED, resistencia, condensador, tarjeta de adaptación).

➤ Circuito

➤Observaciones

- En el circuito anterior únicamente se detallan las conexiones básicas para poder realizar unas pruebas con el STM32F446RET6 de la manera más sencilla posible, sin los componentes electrónicos recomendados en el documento AN4488 Application note. Si se desea diseñar una tarjeta basada en este microncontrolador, es preciso seguir las indicaciones de este documento.

- El microcontrolador tiene un encapsulado LQFP64, por tal motivo es necesaria la utilización de una tarjeta adaptadora para las pruebas.

- El STM32F446RET6 se alimenta con el grabador ST-LINK de la tarjeta Nucleo, en concreto, con el pin 1 de JP1 (10) y el pin 3 del conector CN4 (12). Ver el esquema anterior. Aparte de todo esto, para simplificar, las pruebas se realizaron sin condensadores de desacoplo.

- Para poder grabar el microcontrolador, es necesario quitar los puentes de CN2 (tarjeta Nucleo).

- Según lo observado en las pruebas, el circuito también funciona si se desconecta lo siguiente:

• Todas las masas menos una (4).
• Todas las VDD menos una (8).
• La conexión entre VDD (8) y el pin 1 de CN4 (11).
• La conexión entre VCAP_1 y el condensador (2). 
• La conexión de VSSA/VREF- a masa (3). 

- No funciona sin la conexión entre VDDA/VREF+ y los +3,3 V.

- El programa no se ejecuta nada más grabarlo en el microcontrolador. Es preciso reiniciarlo; se puede hacer quitando y poniendo la alimentación o conectando el pin 7 del microntrolador (5) a masa durante un instante. Ver otra forma de hacerlo (*). 

- El microcontrolador puede funcionar sin un cristal externo.

➤Programa de prueba

- Aunque es posible grabar un programa vacío para comprobar el funcionamiento del grabador con el microcontrolador, es recomendable usar un programa sencillo, como el de parpadeo de un LED (1) para ver cómo se ejecuta el programa.

 - Para usar el programa de la imagen anterior, es necesario crear un proyecto con mikroC PRO for ARM.

- Antes de comenzar las pruebas con el microcontrolador, es buena idea probar el programa con una Nucleo. Éste produce un parpadeo del LED LD2 de la tarjeta.

- Debido a que el circuito explicado aquí no usa un cristal externo, en Project / Edit Project,  tiene que estar habilitado el oscilador interno (ver siguiente figura).

 

 

(*) Usando mikroC, otra forma de ejecutar el programa es clicando en Detect MCU, que en el cuadro de dialógo que aparece cuando se procede a la grabación del microcontrolador.

Apunte añadido el 4/5/18

Para que el programa del microcontrolador se ejecute automáticamente, sin necesidad de reinicio o de clicar en Detect MCU, en el momento de grabarlo o cada vez que se conecta la alimentación, se puede utilizar una resistencia de pulldown de 10k (o de otro valor adecuado), conectada al pin BOOT0. Es decir, la resistencia tiene que estar conectada entre VSS (GND) y BOOT0. 

El apartado 4 del documento AN4488 de STMicroelectronics está dedicado a los modos de arranque de los microcontroladores STM32F4xxxx.

 

Usando una tarjeta Nucleo como programador

➤ Objetivo

Grabar un programa en una tarjeta Nucleo empleando como grabador otra Nucleo.

➤ Material necesario

- Dos tarjetas Nucleo-F446RE.
- IDE: mikroC PRO for ARM (puede usarse otro).

➤ Conexiones

En ambas tarjetas es necesario quitar los puentes de CN2.

➤Observaciones

- La tarjeta denominada Nucleo I (ver tabla arriba) se conecta al ordenador y, en este caso, es manejada usando mikroC. Es la tarjeta que se usa como grabador.

- Nucleo II es la tarjeta que se desea grabar. Se alimenta mediante Nucleo I, en concreto desde el pin 1 de JP1, situado en la parte correspondiente a ST-LINK.  No se alimenta desde el pin 1 de CN4, dado que éste no sirve para alimentar, sino para que el grabador sepa que la tarjeta a grabar está alimentada.

- Visto de otra forma: aparte de la conexión de masa, la tarjeta Nucleo II se alimenta conectando el pin 1 de JP1 al pin IOREF. Esta tensión de alimentación llega al pin 1 de CN4 a través del pin 12 de CN7, puesto que está cortocircuitado con IOREF.

- Se podría conectar el pin 1 de JP1 directamente al pin 1 de CN4, pero no se sabría realmente si la tarjeta Nucleo II está alimentada. De todas formas, en las pruebas realizadas, la grabación funcionó igual prescindiendo de la conexión entre el pin 1 de CN4 y el pin 12 de CN7.

Parpadeo de un LED - PIC18F14K22-

➤ Programa

/* Mayo de 2017
 * Tarjeta: DM164130-9
 * Microcontrolador: PIC18F14K22
 * IDE: MPLAB X IDE v.3.60
 * Compilador: MPLAB XC8 Compiler v1.42
 Programa que produce el parpadeo cíclico del LED DS1 de la tarjeta DM164130-9
 (el LED está conectado al pin RC0 del microcontrolador).
 */

#include <xc.h>                               // Archivo de cabecera genérico
#define _XTAL_FREQ 16000000  // Frecuencia de reloj = 16 MHz
#pragma config FOSC = IRC         // Selecciona el oscilador RC interno

void main(void) {   
    OSCCON |= 0b01110000;          // Establece una frec. de reloj de 16 MHZ
    TRISCbits.TRISC0 = 0;             // Configura el pin RC0 como salida  
    
    while(1){
      __delay_ms(1000);                   // Retardo de 1 segundo
      LATCbits.LATC0 ^= 1;            // Conmuta el estado del LED
    }
}

➤ Circuito

No es necesario ningún componente externo a la tarjeta DM164130-9, dado que se utiliza un LED de ésta. En la siguiente imagen puede verse la tarjeta, alimentada a 5 V mediante una fuente y conectada al grabador PICkit 3. El programa se puede ejectutar tanto con el grabador conectado como desconectado.

➤ Observaciones

- En la entrada anterior del blog está explicado cómo grabar un programa en el microcontrolador.

- #include <xc.h> : xc.h es un archivo de cabecera genérico, el cual permite acceder a los registros del microcontrolador y el uso de macros.

- #define _XTAL_FREQ 16000000: es la frecuencia de reloj establecida mediante la orden OSCCON |= 0b01110000. Se necesita para utilizar la macro __delay_ms(). 

- #pragma config FOSC = IRC: selecciona el oscilador RC interno para generar la señal de reloj del microcontrolador. En realidad, con esta instrucción, se escribe '1000' en los bits 3-0 del registro CONFIG1H (ver siguiente figura). Los demás bits quedan con su valor por defecto. Esta orden permite que se pueda utilizar el microcontrolador sin conectarle un cristal externo.

- OSCCON |= 0b01110000: establece una frecuencia de reloj interna de 16 MHz. Esta instrucción escribe '111' en los bits 6-4 del registro OSCCON y deja los demás bits intactos.

- TRISCbits.TRISC0 = 0: el registro TRISC permite determinar los pines del puerto C del microcontrolador que van a funcionar como salidas y los que lo van a hacer como entradas. En este caso, se configura el pin RC0 como salida.

- LATCbits.LATC0 ^= 1:  para poner los diferentes pines del puerto C a '1' o a '0' hay que acceder al registro LATC. El programa utiliza el operador bit a bit XOR (bitwise XOR) para cambiar el estado del pin RC0 y dejar el estado de los demás pines intacto. Con esto se consigue encender y apagar el LED.    

 

Programación de microcontroladores PIC con MPLAB X IDE

Aunque todo lo detallado a continuación está pensado para el PIC18F14K22, el procedimiento descrito sirve también para otros tipos de microcontroladores PIC.

➤Material empleado

- Tarjeta: DM164130-9 (con un PIC18F14K22).
- Grabador: Pickit 3.
- IDE: MPLAB X IDE v.3.60.
- Compilador: MPLAB XC8 Compiler v1.42 (necesario para programar microcontroladores PIC de 8 bits).

También es preciso alimentar la tarjeta DM164130-9 a 5 V. En la foto aparece la fuente de alimentación empleada en las pruebas. 

➤ Procedimiento

Los siguentes puntos describen, de manera resumida, los pasos a seguir para grabar un programa en la tarjeta DM164130-9. Básicamente, es el procedimiento descrito en la hoja de instrucciones del programador Pickit 3. Los puntos 3.3 y 5 se explican con más detalle más abajo.

1. Instalar el último software. En este caso, fueron MPLAB IDE v3.60  y MPLAB XC8 Compiler v1.42, ambos son gratuitos y las versiones utilizadas son para Windows.

2. Configurar el puerto USB. Conectar el Pickit 3 al PC mediante un cable USB. El dispositivo usa un controlador USB estándar de Windows, por lo que éste se tiene que instalar automáticamente al conectar el dispositivo a un ordenador con este sistema operativo.

3. Crear un proyecto
3.1. Ejecutar MPLAB X IDE.
3.2. Cargar un proyecto ya hecho o crear uno nuevo.
3.3. Crear el proyecto basado en las configuraciones y opciones que elija el usuario (*).
3.4. Seleccionar Pickit 3 como programador.

4. Conectar a la tarjeta y alimentar
4.1. Conectar el Pickit 3 al PC mediante el cable USB, si no estuviera conectado ya.
4.2. Conectar el Pickit 3 a la tarjeta DM164130-9.
4.3. Alimentar la tarjeta DM164130-9. La tensión de alimentación tiene que ser adecuada para el funcionamiento del PIC18F14K22, por eso en las pruebas se usó una fuente de alimentación, con un canal de 5 V, conectada al conector P2 de la tarjeta (ver foto arriba).

5. Programar. Efectuando todos los pasos anteriores, MPLAB X IDE puede compilar el programa y, empleando el Pickit 3, puede grabarlo en el PIC de la tarjeta (**). 



---------------------------------------

(*) Para crear un proyecto nuevo hay que seguir los siguientes pasos:

a. Clicar en File / New Project. En la ventana que aparece, elegir la opción por defecto: Categories: Microchip Embedded y Projects: Standalone Project. Hay que clicar en el icono Next en esta ventana y en las siguientes.

b. Aparece otra ventana en la que se pueden ver, a la izquierda, todos los pasos a seguir. En este paso hay que seleccionar el microcontrolador, que es el PIC18F14K22.

c. En la ventana perteneciente al paso 3, Select Header se deja igual.

d. En la siguiente ventana se selecciona el dispositivo grabador: PICkit3. Si no se ha hecho anteriormente o al cambiar de microcontrolador, MPLAB IDE realiza una actualización de firmware automática para que el programador Pickit 3 pueda grabar el microcontrolador PIC18F14K22.

e. Después hay que elegir el compilador: MPLAB XC8 Compiler, debido a que el PIC18F14K22 es un microcontrolador de 8 bits.

f. En la última ventana hay que darle un nombre al proyecto y guardarlo en la carpeta que se desee.

g. Una vez hecho esto, desaparece la ventana de los pasos anteriores y en MPLAB X IDE se pueden ver unas pestañas con toda la información del proyecto.

---------------------------------------

(**) Para programar el microcontrolador de la tarjeta:


A. Con el Pickit 3 conectado  a la tarjeta DM164130-9, estando ésta alimentada, hay que visualizar el contenido de la pestaña Projects clicando en ella. 

B. Para crear un programa vacío  es necesario clicar en Source Files / New / main.c y guardar el archivo creado. Se puede dejar el nombre que figura por defecto, newmain, con extensión *.c.

C. Con lo anterior, el archivo newmain.c queda asociado al proyecto y ya se puede visualizar su código.

 
 
D. Si se deseara utilizar un archivo ya existente, también habría que activar la pesataña Projects y después clicar con el botón derecho del ratón sobre Source Files / Add Existem Item.


E. Una forma rápida de grabar el programa en la tarjeta es usando el icono seleccionado en la siguiente imagen y escogiendo la opción Make and Program Device Main Project.

F. Primero se produce la compilación del programa, la cual no puede presentar errores.

G. Después aparece una ventana de aviso, advirtiendo de que la alimentación del PIC que se va a grabar tiene que ser la correcta. En este caso, hay que darle a OK, dado que el PIC18F14K22 se está alimentando a 5 V.

H. Por último, aparece un mensaje que indica que la grabación del programa ha sido correcta. El programa se ejecuta en cuanto acaba la grabación del mismo, sin necesidad de desconectar el programador de la tarjeta. En este caso, dado que se emplea un programa vacío, no sucede nada en la tarjeta DM164130-9.

Conviene aclarar que para probar diferentes programas sencillos, no hace falta crear un proyecto para cada uno. Por comodidad, se puede usar siempre el mismo proyecto e ir cambiando el archivo principal del programa según convenga. Para ello hay que acceder al menú de la imagen siguiente, con el botón derecho del ratón sobre el nombre del programa, y escoger la opción Remove From Project cuando se quiera desvincular del proyecto un determinado archivo *.c.

Conversión A/D - ATtiny85-

➤ Programa

/* Abril de 2017
Microcontrolador: ATtiny85-20PU
IDE: Arduino 1.8.2
Grabador: Arduino UNO
Programa que lee la tensión del pin central de un potenciómetro y que
enciende un LED si la tensión leída es mayor o igual que 3,5 V.
*/

float tension;
float tension_umbral = 3.5;
int ret = 200;
#define lectura_pot1 analogRead(3)  // Lectura de tensión en la entrada
                                                           // analógica 3 del ATtiny85
// LED 1
#define L1 0
#define Led1On  digitalWrite (L1,1)   // Encendido
#define Led1Off  digitalWrite (L1,0)  // Apagado

void setup(){
  pinMode (L1,OUTPUT);            
}

void loop(){     
  // Lectura de tensión del potenciómetro 1
  tension = ((float)lectura_pot1 / (float)1023) * 5;
  // Encendido y apagado del LED
  if (tension >= tension_umbral) Led1On;
    else Led1Off;
  delay(ret);      
}

➤ Circuito

➤ Observaciones

- En la entrada anterior del blog está explicado el procedimiento para grabar un programa en un ATtiny85.

- PB0 está en el pin 5 del microcontrolador.

- La entrada analógica 3, ADC3,  está en el pin 2 del microcontrolador.

- El circuito funciona con la señal de reloj interna del ATtiny85.

Parpadeo de un LED -ATtiny85-

➤ Programa

/* Abril de 2017
Microcontrolador: ATtiny85-20PU
IDE: Arduino 1.8.2
Grabador: Arduino UNO
Programa que produce el parpadeo cíclico de un LED conectado a un ATtiny85.
*/

void setup() {
   pinMode(0, OUTPUT);  // Configura PB0 como salida
}

void loop() {
  digitalWrite(0, HIGH);    // LED encendido
  delay(1000);                     // Espera un segundo
  digitalWrite(0, LOW);     // LED apagado
  delay(1000);
}

➤ Circuito

➤ Observaciones

- En la entrada anterior del blog está explicado el procedimiento para grabar un programa en un ATtiny85.

- Si en los pasos de configuración previos a la grabación del programa se escogiera una frecuencia de reloj incorrecta, la cadencia del parpadeo del LED sería distinta a la pretendida por el código del programa.

- PB0 está en el pin 5 del microcontrolador.

- El circuito funciona con la señal de reloj interna del ATtiny85.

Programación de microcontroladores ATtiny con Arduino

Los ATtiny son unos pequeños microcontroladores que se pueden programar usando una tarjeta Arduino como grabador.

El IDE de Arduino permite escribir programas para los ATtiny, empleando el mismo lenguaje que para las Arduino, aunque con un número de órdenes menor.

 

➤ Material empleado
Las pruebas de todo lo descrito más abajo se realizaron utilizando:

- Una Arduino UNO.
- Un microcontrolador ATtiny85-20PU.
- Un circuito de grabación del microcontrolador (puede ser implementado en una placa de pruebas).
- Arduino IDE 1.8.2. (para Windows).

➤ Procedimiento

1. Configurar Arduino IDE para poder programar microcontroladores ATtiny

1.1. Dentro de Arduino IDE, clicar en Archivo/Preferencias. Aparece una ventana en la que hay que añadir el siguiente enlace:
https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json

Para más información, ver este otro enlace.

1.2. Clicando en Herramientas / Placa / Gestor de tarjetas, se accede a una ventana en la que hay que seleccionar el controlador de los microcontroladores ATtiny e instalarlo (usar la última versión disponible).

 1.3. Una vez efectuada la instalación, accediendo a Herramientas / Placa, puede comprobarse que los microcontrolares ATtiny también aparecen en la lista.

2. Grabar un programa en un microcontrolador ATtiny85

2.1. En una Arduino, grabar el programa Ejemplos / 11.Arduino / ArduinoISP.

2.2. Escoger la opción Arduino as ISP en Herramientas / Programador.

2.3. Conectar a la Arduino el circuito de grabación del ATtiny.

  
En la siguiente imagen se puede ver el circuito de grabación implementado en un escudo de Arduino.  

2.4. En Herramientas hay que elegir la siguiente configuración:
- Placa: ATtiny.
- Procesador: ATtiny25/45/85.
- Clock: 1 MHz internal (*).
- Programador: Arduino as ISP (hecho en el paso 2.2).   

(*) Si el circuito integrado del ATtiny nunca ha sido usado, esta opción sería correcta. Mediante la quema del bootloader (Herramientas / Quemar Bootloader), se puede cambiar la frecuencia de reloj del microcontrolador, dependiendo de la que estuviera activada en  Herramientas / Clock justo antes de efectuar la operación.
 
Según la hoja de datos del componente, el ATtiny85-20PU puede trabajar con frecuencias de reloj de hasta 20 MHz.


2.5 El siguiente paso es cargar el programa que se desee en el ATtiny. Lo más fácil es grabar un programa vacío, como el de la figura anterior; aunque si se desea saber si la frecuencia de reloj escogida en Arduino IDE es la correcta, es preferible usar un programa de parpadeo de un LED.

Una vez grabado el programa, si no existe ningún error, tiene que aparecer un mensaje similar al de la figura siguiente.