Autor Tema: Bootloader SD card encriptado, para ARM STM32  (Leído 29325 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 3520
    • Pinballsp
Bootloader SD card encriptado, para ARM STM32
« en: 21 de Febrero de 2015, 18:23:57 »


Voy a intentar pegar el salto a ARM con STM32, para mis próximos diseños comerciales. Lo primero que necesito, igual que hice con PIC32, es disponer de un bootloader encriptado, imprescindible para poder facilitar actualizaciones del producto, con archivos colgados en internet.

Me decanto, igual que hice con PIC32, por usar tarjetas micro SD, porque tienen una doble función, actualización del firmware y uso como almacenamiento FAT32 con tarjetas de hasta 32GB.

Con PIC32 partí de los fuentes de la nota aplicativa AN1388, tuve que incluir las rutinas de desencriptación XTEA, y desarrollar un programa en el PC con Visual Studio, para encriptar los HEX.

El programa para el PC, me sirve, no lo tengo que volver a hacer, ahora me toca hacer el programa para el STM32, he buscado a ver si encontraba algo prefabricado, aunque fuera un bootloader simple sin encriptar, y no he encontrado NADA. Parece que como los STM32 incluyen por hardware un bootloader, nadie se ha preocupado de desarrollarlo por software, el problema es que ese bootloader no está encriptado, por lo que su utilidad es NULA. Alguien podrá pensar que un bootloader por hardware es útil, ya que te ahorra el programador, el problema es que si vas a hacer tus propios programas, seguro que necesitarás hacer DEBUG, y usando un bootloader eso será imposible, asi que al final, si o si, necesitas un programador que además permita hacer DEBUG, en los PIC puede ser el Pickit 3 y en los ARM STM32 el STLink V2, que en la Discovery ya va integrado.

Así que me toca empezar casi de cero, a construir el programa para el STM32. Como la filosofía de un bootloader ya me la conozco bastante bien, de cuando lo hice para los PIC32, voy a tiro hecho en cuanto a saber que rutinas/librerías concretas necesito, y estas son las siguientes:

1.- Lectura/escritura de tarjetas SD
2.- Desbloqueo de flash
3.- Bloqueo de flash
4.- Saltar a aplicación de usuario
5.- Borrado de memoria flash
6.- Escritura de memoria flash
7.- Rutinas de desencriptación XTEA (ya las tengo hechas para PIC32, me valen sin cambios)


Y estos son los enlaces que he localizado por internet, con la información que necesito para las rutinas/librerias:

1.- Bootloader USB para SMT32F4xx
2.- STM32 Escritura/Borrado de Flash (parte-1)  (aplicar el traductor de Chrome)
3.- STM32 Escritura/Borrado de Flash (parte-2)  (aplicar el traductor de Chrome)
4.- Bootloader SD Card para STM32F107
5.- Rutinas en C, Escritura/Borrado de Flash
6.- Rutinas Periféricos en C para STM32F4xx
7.- Librería FATFS tarjetas SD
8.- Tarjetas SD, FAT STM32F4 (parte 1)
9.- Tarjetas SD, FAT STM32F4 (parte 2)
10.- Almacenamiento de datos en Flash


El entorno de desarrollo va a ser Eclipse con el compilador de C++ GCC, todo gratuito, tal como lo documenté en este post, hace tiempo:
http://www.todopic.com.ar/foros/index.php?topic=41267.0

El hardware de pruebas será una tarjeta Discovery con un microcontrolador ARM STM32F407




El borrado de la flash se debe de hacer por SECTORES completos, no se puede borrar solo una dirección, esto es igual que con los PIC, solo que aquí los sectores (páginas en PIC32) son de longitud variable, mientras que con los PIC32 todas las páginas son de 4K. Al igual que con los PIC, antes de escribir en la flash, hay que borrarla, y el borrado es por sectores completos. Esta es la tabla de sectores de la flash de un STM32F4:




Sobre el papel, y sin haberlo probado todavía, estas podrían ser la piezas del puzzle a encajar:

Gestión de tarjetas SD (lectura y escritura, en FAT32, con las librerías FATFS):
Código: [Seleccionar]
*  project example for FATFS
 */
#include "defines.h"
#include "stm32f4xx.h"
#include "tm_stm32f4_delay.h"
#include "tm_stm32f4_disco.h"
#include "tm_stm32f4_fatfs.h"
#include <stdio.h>
#include <string.h>
 
int main(void) {
    //Fatfs object
    FATFS FatFs;
    //File object
    FIL fil;
    //Free and total space
    uint32_t total, free;
    
    //Initialize system
    SystemInit();
    //Initialize delays
    TM_DELAY_Init();
    //Initialize LEDs
    TM_DISCO_LedInit();
 
    //Mount drive
    if (f_mount(&FatFs, "", 1) == FR_OK) {
        //Mounted OK, turn on RED LED
        TM_DISCO_LedOn(LED_RED);
        
        //Try to open file
        if (f_open(&fil, "1stfile.txt", FA_OPEN_ALWAYS | FA_READ | FA_WRITE) == FR_OK) {
            //File opened, turn off RED and turn on GREEN led
            TM_DISCO_LedOn(LED_GREEN);
            TM_DISCO_LedOff(LED_RED);
            
            //If we put more than 0 characters (everything OK)
            if (f_puts("First string in my file\n", &fil) > 0) {
                if (TM_FATFS_DriveSize(&total, &free) == FR_OK) {
                    //Data for drive size are valid
                }
                
                //Turn on both leds
                TM_DISCO_LedOn(LED_GREEN | LED_RED);
            }
            
            //Close file, don't forget this!
            f_close(&fil);
        }
        
        //Unmount drive, don't forget this!
        f_mount(0, "", 1);
    }
    
    while (1) {
 
    }
}



Desbloqueo de flash:
Código: [Seleccionar]
void FLASH_Unlock(void)
{
  if((FLASH->CR & FLASH_CR_LOCK) != RESET)
  {
    /* Authorize the FLASH Registers access */
    FLASH->KEYR = FLASH_KEY1;
    FLASH->KEYR = FLASH_KEY2;
  }  
}



Bloqueo de Flash:
Código: [Seleccionar]
void FLASH_Lock(void)
{
  /* Set the LOCK Bit to lock the FLASH Registers access */
  FLASH->CR |= FLASH_CR_LOCK;
}



Borrado de flash (1 sector):
Código: [Seleccionar]
FLASH_Status FLASH_EraseSector(uint32_t FLASH_Sector, uint8_t VoltageRange)
{
  uint32_t tmp_psize = 0x0;
  FLASH_Status status = FLASH_COMPLETE;

  /* Check the parameters */
  assert_param(IS_FLASH_SECTOR(FLASH_Sector));
  assert_param(IS_VOLTAGERANGE(VoltageRange));
  
  if(VoltageRange == VoltageRange_1)
  {
     tmp_psize = FLASH_PSIZE_BYTE;
  }
  else if(VoltageRange == VoltageRange_2)
  {
    tmp_psize = FLASH_PSIZE_HALF_WORD;
  }
  else if(VoltageRange == VoltageRange_3)
  {
    tmp_psize = FLASH_PSIZE_WORD;
  }
  else
  {
    tmp_psize = FLASH_PSIZE_DOUBLE_WORD;
  }
  /* Wait for last operation to be completed */
  status = FLASH_WaitForLastOperation();
  
  if(status == FLASH_COMPLETE)
  {
    /* if the previous operation is completed, proceed to erase the sector */
    FLASH->CR &= CR_PSIZE_MASK;
    FLASH->CR |= tmp_psize;
    FLASH->CR &= SECTOR_MASK;
    FLASH->CR |= FLASH_CR_SER | FLASH_Sector;
    FLASH->CR |= FLASH_CR_STRT;
    
    /* Wait for last operation to be completed */
    status = FLASH_WaitForLastOperation();
    
    /* if the erase operation is completed, disable the SER Bit */
    FLASH->CR &= (~FLASH_CR_SER);
    FLASH->CR &= SECTOR_MASK;
  }
  /* Return the Erase Status */
  return status;
}



Borrado de flash (completa)
Código: [Seleccionar]
FLASH_Status FLASH_EraseAllSectors(uint8_t VoltageRange)
{
  uint32_t tmp_psize = 0x0;
  FLASH_Status status = FLASH_COMPLETE;
  
  /* Wait for last operation to be completed */
  status = FLASH_WaitForLastOperation();
  assert_param(IS_VOLTAGERANGE(VoltageRange));
  
  if(VoltageRange == VoltageRange_1)
  {
     tmp_psize = FLASH_PSIZE_BYTE;
  }
  else if(VoltageRange == VoltageRange_2)
  {
    tmp_psize = FLASH_PSIZE_HALF_WORD;
  }
  else if(VoltageRange == VoltageRange_3)
  {
    tmp_psize = FLASH_PSIZE_WORD;
  }
  else
  {
    tmp_psize = FLASH_PSIZE_DOUBLE_WORD;
  }  
  if(status == FLASH_COMPLETE)
  {
    /* if the previous operation is completed, proceed to erase all sectors */
     FLASH->CR &= CR_PSIZE_MASK;
     FLASH->CR |= tmp_psize;
     FLASH->CR |= FLASH_CR_MER;
     FLASH->CR |= FLASH_CR_STRT;
    
    /* Wait for last operation to be completed */
    status = FLASH_WaitForLastOperation();

    /* if the erase operation is completed, disable the MER Bit */
    FLASH->CR &= (~FLASH_CR_MER);

  }  
  /* Return the Erase Status */
  return status;
}



Escritura en flash (32 bit)
Código: [Seleccionar]
FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data)
{
  FLASH_Status status = FLASH_COMPLETE;

  /* Check the parameters */
  assert_param(IS_FLASH_ADDRESS(Address));

  /* Wait for last operation to be completed */
  status = FLASH_WaitForLastOperation();
  
  if(status == FLASH_COMPLETE)
  {
    /* if the previous operation is completed, proceed to program the new data */
    FLASH->CR &= CR_PSIZE_MASK;
    FLASH->CR |= FLASH_PSIZE_WORD;
    FLASH->CR |= FLASH_CR_PG;
  
    *(__IO uint32_t*)Address = Data;
        
    /* Wait for last operation to be completed */
    status = FLASH_WaitForLastOperation();

    /* if the program operation is completed, disable the PG Bit */
    FLASH->CR &= (~FLASH_CR_PG);
  }
  /* Return the Program Status */
  return status;
}



Un ejemplo completo de borrado/escritura de Flash en un STM32F1xx
Código: [Seleccionar]
#include "stm32f10x.h"

#define FLASH_KEY1      ((uint32_t)0x45670123)
#define FLASH_KEY2      ((uint32_t)0xCDEF89AB)
#define Page_127        0x0801FC00

uint16_t i;

int main()
{
  //FLASH_Unlock
  FLASH->KEYR = FLASH_KEY1;
  FLASH->KEYR = FLASH_KEY2;

  //FLASH_Erase Page
  while((FLASH->SR&FLASH_SR_BSY));
  FLASH->CR |= FLASH_CR_PER; //Page Erase Set
  FLASH->AR = Page_127; //Page Address
  FLASH->CR |= FLASH_CR_STRT; //Start Page Erase
  while((FLASH->SR&FLASH_SR_BSY));
  FLASH->CR &= ~FLASH_CR_PER; //Page Erase Clear

  //FLASH_Program HalfWord
  FLASH->CR |= FLASH_CR_PG;
  for(i=0; i<1024; i+=2)
  {
    while((FLASH->SR&FLASH_SR_BSY));
    *(__IO uint16_t*)(Page_127 + i) = i;
  }
  FLASH->CR &= ~FLASH_CR_PG;

  FLASH->CR |= FLASH_CR_LOCK;

  while(1);
}
}



Saltar a aplicación de usuario
Código: [Seleccionar]
void jumpToUser (u32 usrAddr) {
  typedef void (*funcPtr)(void);

  u32 jumpAddr = *(vu32*) (usrAddr + 0x04); /* reset ptr in vector table */
  funcPtr usrMain = (funcPtr) jumpAddr;

  /* tear down all the dfu related setup */
  // disable usb interrupts, clear them, turn off usb, set the disc pin
  // todo pick exactly what we want to do here, now its just a conservative

#ifdef STM32F2
  nvicDisableInterrupts();
#else
  flashLock();
  usbDsbISR();
  nvicDisableInterrupts();
  usbDsbBus();
#endif

  systemReset(); // resets clocks and periphs, not core regs


  __MSR_MSP(*(vu32*) usrAddr);              /* set the users stack ptr */

  setPin(LED_BANK,LED);
  usrMain();                                /* go! */
}

« Última modificación: 22 de Febrero de 2015, 08:00:18 por planeta9999 »

Desconectado juaperser1

  • Colaborador
  • DsPIC30
  • *****
  • Mensajes: 2980
Re: Bootloader SD card encriptado, para ARM STM32
« Respuesta #1 en: 21 de Febrero de 2015, 23:55:01 »
Muy bueno amigo, ahora mismo estoy metido en un diseño hardware muy complejo con un stm32f439 y precisamente un bootloader encriptado es lo primero k va a llevar y ademas por microsd y para mas casualidades, yo también tengo el mio en pic pero por usb msd para pendrive, k es mas o menos lo mismo, y ahora voy a migrar mas seriamente a ARM, así k seguiré tu trabajo con atencion, por cierto estas teniendo problemas con encontrar informacion y librerias? Es la única pega k le pongo a st k podría tener mejor documentación.

Un saludo y buen trabajo tiene buena pinta

Desconectado Nocturno

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 18310
    • MicroPIC
Re: Bootloader SD card encriptado, para ARM STM32
« Respuesta #2 en: 22 de Febrero de 2015, 03:50:41 »
Me suscribo al hilo, muy interesante.

Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 3520
    • Pinballsp
Re: Bootloader SD card encriptado, para ARM STM32
« Respuesta #3 en: 22 de Febrero de 2015, 13:23:20 »
por cierto estas teniendo problemas con encontrar informacion y librerias? Es la única pega k le pongo a st k podría tener mejor documentación.


Si, comparado con Microchip, se echa en falta más aplicaciones de ejemplo, algo como las antiguas Application Libraries de Microchip, ahora HArmony.

En ST tienes STM32CubeMx, un generador bastante cutre, que solo genera código fuente para EWARM, MDK o TruSTUDIO. Que mala visión de mercado tienen los de ST, no ser conscientes de que para superar a la competencia es importante ofrecer herramientas de trabajo GRATUITAS, no entiendo porque no facilitan las cosas para trabajar con Eclipse, Coocox o EmBlocks, y que puñetero cariño le han cogido a Keil, como si todos nos pudieramos gastar alegremente 4000 euros. Lo único que te dan son las CMSIS, con los archivos .H que definen los registros de los periféricos, pero no hay aplicaciones completas de ejemplo.

He estado mirando el tema de los IDE gratuitos, y he encontrado otro muy interesante, EmBlocks, basado en Codeblocks, con un aspecto muy similar a Visual Studio: http://www.emblocks.org/web/ Hay que probarlo, he leido algunas opiniones por internet, y bastante gente lo prefiere a Coocox. Me he instalado la última versión de Coocox y no está nada mal, aunque su generador de código CoSmart se ha quedado en nada, ni siquiera soporta los micros de ST.

Resumiendo, hay 3 entornos de desarrollo gratuitos, todos basados en el compilador de C/C++ GCC:

1.- Eclipse + GCC  Eclipse Versión LUNA actualizado a Enero de 2015  GCC Versión 4.9 a Diciembre de 2014
2.- Coocox + GCC (basado en Eclipse)   http://www.coocox.org/  Versión 1.7.8 actualizado a Febrero de 2015
3.- EmBlocks + GCC (basado en CodeBlocks)   http://www.emblocks.org/web/ Versión 2.30 actualizado a Octubre de 2014

Aunque Eclipse permite un control total, la verdad es que es complicado de configurar y mantener, mientras que los otros dos se instalan y a funcionar de inmediato, seleccionas el chip y el IDE te lo configura todo. Tanto Coocox como Emblocks están actualizados para soportar hasta los últimos STM32, que creo son los F439, y también soportan micros ARM de otros fabricantes. Además trabajando con Coocox, como está basado en Eclipse, el proyecto se puede traspasar sin problemas a Eclipse si fuera necesario.

Voy a probar los tres, con las últimas versiones, a ver por cual me decanto, de momento me atrae bastante EmBlocks, la mayoría de gente que ha probado Coocox y EmBlocks, opina que el segundo es mucho más rápido.

Como curiosidad, EmBlocks, también soporta los PIC32, aunque yo para los PIC prefiero MPLAB y MPLABX.
Y otra curiosidad, EmBlocks permite importar proyectos hechos en Coocox y MPLABX.

Un apunte más, parece que hay un PLugin para usar el generador de código STM32Cubemx en Eclipse, habrá que probarlo:
http://www.st.com/web/en/catalog/tools/PF257931


« Última modificación: 22 de Febrero de 2015, 14:06:11 por planeta9999 »

Desconectado juaperser1

  • Colaborador
  • DsPIC30
  • *****
  • Mensajes: 2980
Re: Bootloader SD card encriptado, para ARM STM32
« Respuesta #4 en: 22 de Febrero de 2015, 14:10:28 »
Cierto, es lo que me gusta de microchip, que tendrá todos sus defectos, pero facilita mucho el trabajo, los basados en ARM sin embargo veo que los entornos de desarrollo son caros y en la mayoría de los casos ni siquiera son propios, solo algunos como TI ofrece su "code composer estudio" o ccs, y una buena herramienta para generar código, al estilo harmony (pero de gratis nada, caro de narices), la mayoría, KEIL, IAR etc, los de ST han hecho muy bien su trabajo en el tema hardware ofreciendo placas de desarrollo y programadoras muy baratas, pero pfff... no se que es peor.

de todas maneras en los de microchip he ido apreciando que cada vez son mas limitados sus compiladores free, y hay algunas cosas que no puedes hacer con ellos, es mas los pic32mx1xx y 2xx de 16kb de memoria son practicamente inutiles ya que no cabe ningún programa, puedes cambiar estados de los pines y tal y no pongas mas de 8 funciones en tu código xk vas a tener problemas.

coocox es muy buena herramienta cuando salio me alegre mucho, pero hasta que soportáron los 439 paso bastante tiempo, lo que quiere decir que si quieres trabajar con lo ultimo de lo ultimo tendrás que esperar.
y también lo que comentas los pocos ejemplos que hay, para las discovery por ejemplo son para keil IAR etc pero de coocox o eclipse nada de nada.

el de EmBlocks no lo conocía, no olvides dar tu opinión cuando lo pruebes.

un saludo.


Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 3520
    • Pinballsp
Re: Bootloader SD card encriptado, para ARM STM32
« Respuesta #5 en: 22 de Febrero de 2015, 15:09:09 »


Este libro parece interesante para entrar en materia, incluso tiene algún capítulo dedicado a Coocox, está en papel y en PDF.  Editado a finales de 2013, 864 páginas, en Amazon lo ponen muy bien.  En un ratito, creo que podré ojear la versión en PDF.



« Última modificación: 22 de Febrero de 2015, 15:15:58 por planeta9999 »

Desconectado juaperser1

  • Colaborador
  • DsPIC30
  • *****
  • Mensajes: 2980
Re: Bootloader SD card encriptado, para ARM STM32
« Respuesta #6 en: 22 de Febrero de 2015, 15:24:05 »
desde luego el titulo promete, espero que sirva de ayuda.

Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 3520
    • Pinballsp
Re: Bootloader SD card encriptado, para ARM STM32
« Respuesta #7 en: 22 de Febrero de 2015, 15:28:24 »
Cierto, es lo que me gusta de microchip, que tendrá todos sus defectos, pero facilita mucho el trabajo, los basados en ARM sin embargo veo que los entornos de desarrollo son caros y en la mayoría de los casos ni siquiera son propios, solo algunos como TI ofrece su "code composer estudio" o ccs, y una buena herramienta para generar código, al estilo harmony (pero de gratis nada, caro de narices), la mayoría, KEIL, IAR etc, los de ST han hecho muy bien su trabajo en el tema hardware ofreciendo placas de desarrollo y programadoras muy baratas, pero pfff... no se que es peor.

de todas maneras en los de microchip he ido apreciando que cada vez son mas limitados sus compiladores free, y hay algunas cosas que no puedes hacer con ellos, es mas los pic32mx1xx y 2xx de 16kb de memoria son practicamente inutiles ya que no cabe ningún programa, puedes cambiar estados de los pines y tal y no pongas mas de 8 funciones en tu código xk vas a tener problemas.



Hay una alternativa de pago, bastante asequible, pero no se que calidad tendrán estos compiladores, me refiero a los de Mikroelektronica. Tienen compiladores tanto para PIC como para ARM, de C, Basic y Pascal, y muy baratitos en comparación con otros.

http://www.mikroe.com/mikroc/arm/

Yo hace años distribuí en España los productos de Mikroe, los entrenadores estaban muy bien, de los compiladores aunque vendí alguno de C, nunca los probé.





Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 3520
    • Pinballsp
Re: Bootloader SD card encriptado, para ARM STM32
« Respuesta #8 en: 23 de Febrero de 2015, 01:56:38 »


Añado más información interesante para hacer el bootloader.
Algo de esto leí hace tiempo, y hoy lo he confirmado, con otra información adicional que desconocía.

Los STM32, tienen una característica muy interesante, que no tienen los PIC32, y es que cada chip incluye de fábrica un Código de Identificación UNICO, de 96 bits, además de otros 3 identificadores, todos ellos grabados de fábrica, y solo se pueden leer, no se pueden modificar.

Estos 4 identificadores son los siguientes:

1.- Firma de dispositivo: 16 bit, identifica el tipo de chip.
    0x0413: STM32F405xx/07xx and STM32F415xx/17xx)
    0x0419: STM32F42xxx and STM32F43xxx
    0x0423: STM32F401xB/C
    0x0433: STM32F401xD/E
    0x0431: STM32F411xC/E

2.- Revisión de dispositivo:
    0x1000: Revision A
    0x1001: Revision Z
    0x1003: Revision Y
    0x1007: Revision 1
    0x2001: Revision 3

3.- Tamaño de flash: 16 bit, valor en Kb.
4.- Identificador de dispositivo único: 96 bit, se trata de un código programado de fábrica, único por chip.


En mi booloader para PIC32, grabo un código único por chip, para poder tracear en todo momento cada placa, así se pueden identificar posibles placas pirateadas, para bloquearlas con las siguientes actualizaciones de firmware. Ese código lo grabo en la flash en el momento de inicializar el bootloader en cada placa. En los STM32, ese código único por chip, ya viene grabado de fábrica en cada chip, así que eso que nos ahorramos. También se puede utilizar el código único, para crear actualizaciones personalizadas para un cliente, de manera que solo se pueda instalar en esa placa, limitar que firmware de producto se puede instalar en esa placa por nº de serie único, firma de dispositivo y revisión, etc...


Ejemplo de código fuente para leer los 4 identificadores:
Código: [Seleccionar]
/**
 * Identification library for STM32F4
 *
 * This library allows you to read following things:
 * - Device's 96bit unique ID
 * - Device signature
 * - Revision
 * - Flash size
 *
 * Revisions possible:
 * - 0x1000: Revision A
 * - 0x1001: Revision Z
 * - 0x1003: Revision Y
 * - 0x1007: Revision 1
 * - 0x2001: Revision 3
 *
 * Device signatures:
 * - 0x0413: STM32F405xx/07xx and STM32F415xx/17xx)
 * - 0x0419: STM32F42xxx and STM32F43xxx
 * - 0x0423: STM32F401xB/C
 * - 0x0433: STM32F401xD/E
 * - 0x0431: STM32F411xC/E
 *
 * Flash size:
 * - Device has stored value of flash size in kB
 */
#ifndef TM_IDENTIFICATION_H
#define TM_IDENTIFICATION_H 100

/* C++ detection */
#ifdef __cplusplus
extern C {
#endif

/**
 * Library dependencies
 * - STM32F4xx
 */
/**
 * Includes
 */
#include "stm32f4xx.h"

/* Addresses in device */
#define ID_UNIQUE_ADDRESS 0x1FFF7A10
#define ID_FLASH_ADDRESS 0x1FFF7A22
#define ID_DBGMCU_IDCODE 0xE0042000

/**
 * With this "function" you are able to get signature of device.
 *
 * Possible returns:
 * - 0x0413: STM32F405xx/07xx and STM32F415xx/17xx)
 * - 0x0419: STM32F42xxx and STM32F43xxx
 * - 0x0423: STM32F401xB/C
 * - 0x0433: STM32F401xD/E
 * - 0x0431: STM32F411xC/E
 *
 * Returned data is in 16-bit mode, but only bits 11:0 are valid, bits 15:12 are always 0.
 * Defined as macro
 */
#define TM_ID_GetSignature() ((*(uint16_t *) (ID_DBGMCU_IDCODE)) & 0x0FFF)

/**
 * With this "function" you are able to get revision of device.
 *
 * Revisions possible:
 * - 0x1000: Revision A
 * - 0x1001: Revision Z
 * - 0x1003: Revision Y
 * - 0x1007: Revision 1
 * - 0x2001: Revision 3
 *
 * Returned data is in 16-bit mode.
 * Defined as macro
 */
#define TM_ID_GetRevision() (*(uint16_t *) (ID_DBGMCU_IDCODE + 2))

/**
 * With this "function" you are able to get flash size of device.
 *
 * Returned data is in 16-bit mode, returned value is flash size in kB (kilo bytes).
 * Defined as macro
 */
#define TM_ID_GetFlashSize() (*(uint16_t *) (ID_FLASH_ADDRESS))

/**
 * With this "function" you are able to get unique ID of device in 8-bit (byte) read mode.
 * Unique ID is 96bit long, but if you need just some parts of it, you can read them with 8bit function.
 *
 * Parameters:
 * - uint8_t x:
 * Value between 0 and 11, corresponding to byte you want to read from 96bits (12bytes)
 *
 * Returned data is 8-bit
 * Defined as macro
 */
#define TM_ID_GetUnique8(x) ((x >= 0 && x < 12) ? (*(uint8_t *) (ID_UNIQUE_ADDRESS + (x))) : 0)

/**
 * With this "function" you are able to get unique ID of device in 16-bit (byte) read mode.
 * Unique ID is 96bit long, but if you need just some parts of it, you can read them with 16bit function.
 *
 * Parameters:
 * - uint8_t x:
 * Value between 0 and 5, corresponding to 2-bytes you want to read from 96bits (12bytes)
 *
 * Returned data is 16-bit
 * Defined as macro
 */
#define TM_ID_GetUnique16(x) ((x >= 0 && x < 6) ? (*(uint16_t *) (ID_UNIQUE_ADDRESS + 2 * (x))) : 0)

/**
 * With this "function" you are able to get unique ID of device in 32-bit (byte) read mode.
 * Unique ID is 96bit long, but if you need just some parts of it, you can read them with 32bit function.
 *
 * Parameters:
 * - uint8_t x:
 * Value between 0 and 2, corresponding to 4-bytes you want to read from 96bits (12bytes)
 *
 * Returned data is 32-bit
 * Defined as macro
 */
#define TM_ID_GetUnique32(x) ((x >= 0 && x < 3) ? (*(uint32_t *) (ID_UNIQUE_ADDRESS + 4 * (x))) : 0)

/* C++ detection */
#ifdef __cplusplus
}
#endif

#endif

« Última modificación: 23 de Febrero de 2015, 02:13:12 por planeta9999 »

Desconectado juaperser1

  • Colaborador
  • DsPIC30
  • *****
  • Mensajes: 2980
Re: Bootloader SD card encriptado, para ARM STM32
« Respuesta #9 en: 23 de Febrero de 2015, 06:06:22 »
Es muy util para identificar individualmente los dispositivos que fabricas, pero ten cuidado, es un arma de doble filo, esto también te obliga a tener una base de datos que sera bastante extensa si vendes mucho y un error en esa base de datos, puede que el bootloader se quede inservible para ese cliente.

pero como tu dices, esto es fantastico para que no te llegue un "chino", por llamarlo de alguna manera, te copie el hardware y meta tu código.

los pic si tienen, hasta donde llegan mis conocimientos como mínimo la revisión del dispositivo, lo que no se si es adcesible de alguna manera

buen trabajo amigo, estoy aprendiendo mucho gracias a ti.


Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 3520
    • Pinballsp
Re: Bootloader SD card encriptado, para ARM STM32
« Respuesta #10 en: 23 de Febrero de 2015, 09:50:16 »
Es muy util para identificar individualmente los dispositivos que fabricas, pero ten cuidado, es un arma de doble filo, esto también te obliga a tener una base de datos que sera bastante extensa si vendes mucho y un error en esa base de datos, puede que el bootloader se quede inservible para ese cliente.

La anulación de una placa pirateada es una de las utilidades, yo eso lo he visto aplicado en productos comerciales, y ha sido muy efectivo para tirar producto chino pirateado, en concreto interfaces de diagnosis para automoción, el fabricante crea una lista negra de números de serie, la mete en la siguiente actualización, y en cuanto la aplican las placas piratas, caen como chinches. Ten en cuenta que una lista negra no suele ser muy extensa, se trata de uno o varios números de serie, utilizados en cientos o miles de placas, todas con el mismo número de serie.

También se puede usar para personalizar un producto, para un cliente concreto que compre una mejora o encargue un diseño específico. En mi bootloader para PIC32 grabo otros dos códigos, uno por tipo de producto y otro por versión, para evitar que por error o deliberadamente se instalen ficheros de firmware de otro producto, o para evitar que se instalen versiones anteriores. Si el nº de serie de una placa está en la lista negra, puedo marcar una dirección en flash para impedir que vuelva a arrancar, o puedo incluso borrar el bootloader para dejar inservible la placa.

Citar
los pic si tienen, hasta donde llegan mis conocimientos como mínimo la revisión del dispositivo, lo que no se si es adcesible de alguna manera


No he utilizado nunca ese código, porque no permitiría bloquear una placa concreta, ni crear personalizaciones, pero bueno es saberlo, alguna utilidad se me ocurrirá.

Sobre los IDE, ayer estuve probando Coocox y EmBlocks, pude confirmar algo que ya comprobé hace tiempo, y descubrí algo nuevo. De momento todo está a favor de EmBlocks, y en contra de Coocox.

1.- Ya hace tiempo hubo una cosa que no me gustó nada de Coocox, y sigue igual, no lo han corregido, y eso que hay más gente quejándose de lo mismo en sus foros. Coocox NO permite IMPORTAR directorios o árboles de directorios con sus correspondiente archivos, al proyecto. Si quieres añadir un conjunto de directorios y subdirectiorios con sus archivos de librerías, fuentes en C y archivos H, tienes que crear A MANO los directorios y subdirectorios y subir a mano uno a uno cada archivo. Osea que NO existe algo como "Importar directorio" al proyecto, alucinante. Responde la gente de Coocox a estas quejas, diciendo que se puede usar el "Drag and Drop", pero eso no importa nada, simplemente crea un vínculo a los directorios, de manera que si cambias esos directorios, o mueves el proyecto a otro ordenador, te da error, por perder los vínculos a los directorios originales. Todo esto no ocurre con EmBlocks, Si que tiene una opción para IMPORTAR directorios completos con sus subdirectorios y archivos contenidos, así que punto a favor de Emblocks.

2.- La apertura de un proyecto en Coocox, es extremadamente LENTA, muy molesta, y eso aunque sea un mísero proyecto de los más simples, como un programa para endender y apagar un LED. También hay gente que ha reportado este problema en los foros de Coocox, parece que es debido a la lectura de la base de datos SQLite3 por parte de la DLL ICoodat.dll, cuando se abre un proyecto, dicén que lo resolverán, pero es un problema que ya anda coleando desde hace tiempo. Con EmBlocks no he notado este problema, los proyectos se abren con relativa rapidez.

3.- EmBlocks permite añadir en TOOLS, botones personalizados para llamar a aplicaciones externas, interesante para por ejemplo, crear un botón que llamé al software para programar el chip, en el caso de los STM32 para llamar al programa STM32-STLINK Utility de ST. Esto se puede hacer también en Eclipse, como ya documenté, pero NO se puede hacer en Coocox. Coocox facilita un programa propio (CoFlash), inpendiente del IDE para programar los chips, pero para eso mejor usar el de ST. Otro punto a favor de EmBlocks.


Así que creo que me decantaré por EmBlocks, como ya comenté además permite importar proyectos de Coocox y MPLABX, y se trata de un IDE muy similar a Visual Studio, es casí un calco. Para los que hemos trabajado con VC++ nos resultará muy familiar.

En breve empezaré con las primeras pruebas, que serán crear las rutinas de lectura, modificación y escritura en tarjetas SD, luego las rutinas de borrado-escritura de flash, y finalmente encajarlo todo para que se lea y grabe el nuevo firmware. Veo que la filosofía del Link Scripter, es igual que con los PIC32, importante para compilar el firmware, creo que parte de las rutinas que usé para el PIC32, las podré usar para los STM32, cambiando solo las instrucciones concretas que borran y escriben en la Flash, me ahorrará bastante trabajo, es lo bueno que tiene el C, la portabilidad.


« Última modificación: 23 de Febrero de 2015, 14:06:06 por planeta9999 »

Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 3520
    • Pinballsp
Re: Bootloader SD card encriptado, para ARM STM32
« Respuesta #11 en: 23 de Febrero de 2015, 11:59:38 »


He localizado otro IDE más gratuito, se llama emIDE y al igual que EmBlocks, también está basado en CodeBlocks y GCC.
http://www.emide.org/index.html

Nació en Abril de 2013, y se actualizó por última vez en Mayo de 2014, con soporte para todos los STM32 hasta el F439. El asistente para crear proyectos nuevos, no es tan completo como el de EmBlocks.

Por las visitas a su foro, no parece que tenga mucha clientela, prefiero seguir con EmBlocks, aunque no hay que perder de vista a este IDE, si cumplen con las mejoras futuras que anuncian, como la posibilidad de importar proyectos de IAR/uvision o poder usar el compilador de KEIL.

Y sobre EmBlocks, he hecho un feliz descubrimiento, permite abrir proyectos creados con Keil uvision, que por suerte o por desgracia son la mayoría de los ejemplos que proporciona ST.
« Última modificación: 23 de Febrero de 2015, 12:27:42 por planeta9999 »

Desconectado juaperser1

  • Colaborador
  • DsPIC30
  • *****
  • Mensajes: 2980
Re: Bootloader SD card encriptado, para ARM STM32
« Respuesta #12 en: 23 de Febrero de 2015, 12:54:53 »
Citar
Y sobre EmBlocks, he hecho un feliz descubrimiento, permite abrir proyectos creados con Keil uvision, que por suerte o por desgracia son la mayoría de los ejemplos que proporciona ST.

ufff notición, entonces los de Emblocks han pasado por la derecha a los de coocox, ¿has probado a compilar? ¿parece muy bonito para ser cierto xd quizas se importa pero luego da muchos errores?

si la ultima actualización es de mayo de 2014 parece que el proyecto emIDE esta un poco olvidado.

lo que has comentado de anular las placas piratas me parece muy buena idea, piratear al pirata, lo tendré muy en cuenta.

Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 3520
    • Pinballsp
Re: Bootloader SD card encriptado, para ARM STM32
« Respuesta #13 en: 23 de Febrero de 2015, 20:32:46 »


Preparando el material para las primeras pruebas.


Tarjeta Discovery con un STM32F407, placa base de Waveshare y tarjetero micro SD.




El conjunto ensamblado:




Aprovecharé para probar unas cuantas de las tarjetas que venían con el kit, un par de decodificadores MP3, tarjeta USB a serie virtual, USB Host OTG, teclados directos y en matriz, display BCD y un amplificador de BF. Todas se pueden conectar a la placa de Waveshare, y de ahí a la Discovery.




Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 3520
    • Pinballsp
Re: Bootloader SD card encriptado, para ARM STM32
« Respuesta #14 en: 23 de Febrero de 2015, 20:44:32 »

ufff notición, entonces los de Emblocks han pasado por la derecha a los de coocox, ¿has probado a compilar? ¿parece muy bonito para ser cierto xd quizas se importa pero luego da muchos errores?


No he probado todavía a compilar proyectos de Keil en EmBlocks, no se como quedará la cosa. El problema es que Keil me parece que no usa GCC, entonces podrían haber algunas diferencias de nomenclatura en el C de ambos productos, aparte de configurar bien los path para que el compilador localice todos los archivos, hay que probarlo.





 

anything