ambiente KEIL cómo código que se ejecuta en la memoria RAM
Fecha de publicación: 08/26/2016
Fuente: ST comunidad
Etiquetas: KEIL Nucleo el STM32
Compartir:
Prefacio
encuentra con frecuencia alguien usando KEIL necesidad de parte o la totalidad del código de programa en los problemas de RAM cuando se ejecutan, ahora es resumida en este artículo. Por el STM32 F411 Nucleo un ejemplo de un método para introducir un programa que se ejecuta en la RAM de manera que varios.
Empezamos a ToggleLED funciones de ejecución de Flash empiezan a parpadear. Aquí está la función ToggleLED y su situación llamada. En mientras que la función principal del (1) al llamar ToggleLED.
void ToggleLED (void)
{HAL_GPIO_TogglePin (GPIOA, GPIO_PIN_5); / * Insertar un 100ms retrasan * /
HAL_Delay (100);
}int main (void)
{...... / * ## - 3- Toggle PA05 IO en un bucle infinito ###### * /
while (1) {ToggleLED (); }
}
enlazador de configuración se muestra a continuación entorno de compilación:
la dirección inicial de inflamación: 0x08000000
la dirección de inicio RAM: 0x20000000
El compilador puede ver en el archivo de mapa, ToggleLED y que las llamadas a la dirección HAL_GPIO_TogglePin y función HAL_Delay en FLASH.
LED le dará la vuelta en la ejecución del programa SRAM
método: por la sección de código brazo #pragma = sección "RAMCODE" y el brazo #pragma. Ejemplo 1 código de referencia.
De esta manera, una pluralidad de funciones se puede colocar de forma simultánea en la sección designada. Los métodos específicos son los siguientes:
1. Modificar los archivos .sct, la sección de Uso RAMCODE llamada, el área de ejecución de RW_IRAM1, rango de dirección 0x20000000 0x20020000 ~.
LR_IROM1 0x08000000 0x00080000 {; región de carga size_region
ER_IROM1 0x08000000 0x00080000 {; dirección de carga = dirección de la ejecución
* .o (RESET + Primera)
* (InRoot $$ secciones)
.Cualquier (+ RO)
} RW_IRAM1 0x20000000 0x00020000 {; Los datos RW
* .o (RAMCODE)
.Cualquier (+ RW + ZI)
}
}
2. El uso de los archivos modificados anteriores en el proyecto .sct
3. #pragma código sección de brazo = comenzando "RAMCODE", sección de brazo #pragma hasta el final. Usted tendrá que poner toda la sección funciones RAMCODE está incluido. tiempo de compilación, el compilador automáticamente estas funciones en las áreas donde comenzó 0x20000000 RAMCODE.
brazo #pragma código sección = "RAMCODE"
void ToggleLED (void)
{HAL_GPIO_TogglePin (GPIOA, GPIO_PIN_5); / * Insertar un 100ms retrasan * /
HAL_Delay (100);
}HAL_GPIO_TogglePin vacío (GPIO_TypeDef * GPIOx, uint16_t GPIO_Pin)
{/ * Comprobar los parámetros * /
assert_param (IS_GPIO_PIN (GPIO_Pin));
GPIOx-> ODR ^ = GPIO_Pin;
}uint32_t HAL_GetTick (void)
{garrapata retorno;
}void HAL_Delay (__ IO uint32_t Delay)
{uint32_t tickstart = 0;
tickstart = HAL_GetTick ();
while ((HAL_GetTick () - tickstart) <Delay)
{
}
}
sección de brazo #pragma
4. En el archivo de mapa, se puede ver estas cuatro funciones se han colocado en la SRAM.
Método dos: por __attribute __ ((sección ( "nombre ")))
por __attribute __ ((en (dirección) )) forma variable en la posición especificada en el KEIL.
Por __attribute __ ((sección ( "nombre "))) o una variable de manera función en la ubicación especificada.
Veamos cómo el programa en SRAM ejecutado de esta manera.
1. Del mismo modo, tenemos que modificar los archivos .sct, personalizada llamada sección RAMCODE, y en la página enlazador de las opciones del proyecto, seleccionar el archivo .sct definido. (Véase la etapa 2 del método)
LR_IROM1 0x08000000 0x00080000 {; región de carga size_region ER_IROM1 0x08000000 0x00080000 {; dirección de carga = dirección de la ejecución
* .o (RESET + Primera)
* (InRoot $$ secciones)
.Cualquier (+ RO)
}
RW_IRAM1 0x20000000 0x00020000 {; Los datos RW
* .o (RAMCODE)
.Cualquier (+ RW + ZI)
}
}
2. Antes de la función de las necesidades de memoria RAM que se fijará, en la declaración de función en la sección RAMCODE con __attribute __ ((sección ( "RAMCODE"))). Tenga en cuenta que esta función llamadas a todas las funciones han puesto en la sección RAMCODE.
__attribute __ ((sección ( "RAMCODE")))
void ToggleLED (void)
{HAL_GPIO_TogglePin (GPIOA, GPIO_PIN_5); / * Insertar un 100ms retrasan * /
HAL_Delay (100);
}__attribute __ ((sección ( "RAMCODE")))
vacío HAL_GPIO_TogglePin (GPIO_TypeDef * GPIOx, uint16_t GPIO_Pin)
{/ * Comprobar los parámetros * /
assert_param (IS_GPIO_PIN (GPIO_Pin));
GPIOx-> ODR ^ = GPIO_Pin;
}__attribute __ ((sección ( "RAMCODE")))
__weak uint32_t HAL_GetTick (void)
{return uwTick; }__attribute __ ((sección ( "RAMCODE")))
__weak void HAL_Delay (__ IO uint32_t Delay)
{uint32_t tickstart = 0;
tickstart = HAL_GetTick ();
while ((HAL_GetTick () - tickstart) <Delay)
{}
}
3. Como se puede ver en el archivo de mapa compilado, ToggleLED y todas las funciones que llama haber sido el de la memoria RAM.
Método II puede sustituir un método, lo que significa que si usted tiene un método y un segundo método para hacer la misma descripción de la aplicación de la función regional. El trabajo final es el segundo método. Se ilustra por el código mencionados arriba.
Modificar el archivo .sct. La SRAM se divide en dos zonas ejecución RW_IRAM1 y RW_IRAM2. Sección RAMCODE1, RAMCODE2 se encuentra al principio, dos regiones 64KB y el inicio de 0x20010000 0x20000000.
LR_IROM1 0x08000000 0x00080000 {; región de carga size_region ER_IROM1 0x08000000 0x00080000 {; dirección de carga = dirección de la ejecución
* .o (RESET + Primera)
* (InRoot $$ secciones)
.Cualquier (+ RO)
}RW_IRAM1 0x20000000 0x00010000 {; Los datos RW
* .o (RAMCODE1)
.Cualquier (+ RW + ZI)
}0x20010000 0x00010000 {RW_IRAM2
* .o (RAMCODE2)}
}
2. En el código, HAL_GetTick fue puesto # alcance de Pragma se declara en la sección RAMCODE1, al mismo tiempo con __attribute __ ((sección ( "RAMCODE2"))) para ser colocado en la sección RAMCODE2.
#pragma código sección de brazo = "RAMCODE1"
void ToggleLED (void)
{HAL_GPIO_TogglePin (GPIOA, GPIO_PIN_5);
/ * Insertar un 100ms retrasan * /
HAL_Delay (100); }HAL_GPIO_TogglePin vacío (GPIO_TypeDef * GPIOx, uint16_t GPIO_Pin)
{/ * Comprobar los parámetros * /
assert_param (IS_GPIO_PIN (GPIO_Pin));
GPIOx-> ODR ^ = GPIO_Pin;
}__attribute __ ((sección ( "RAMCODE2")))
uint32_t HAL_GetTick (void)
{garrapata retorno; }void HAL_Delay (__ IO uint32_t Delay)
{uint32_t tickstart = 0;
tickstart = HAL_GetTick ();
while ((HAL_GetTick () - tickstart) <Delay) {}
}
sección de brazo #pragma
3. Después de la compilación, echamos un vistazo al archivo de mapa HAL_GetTick que se colocó en la sección.
Se puede ver en el mapa, la última HAL_GetTick sido colocado en la sección RAMCODE2.
** cómo llevar a cabo todo el programa en SRAM
métodos descritos previamente uno o más programas en la dirección especificada ejecutado. Si necesita poner más procedimientos dirección especificada, también podemos hacer frente a estas necesidades en el conjunto designado en uno o varios archivos de C, entonces estos archivos generados archivos de C colocados en el archivo de destino .sct a la dirección especificada.
A continuación, vamos a tratar de ejecutar el programa completo en la SRAM. Tras el procedimiento de restablecimiento se inicia a partir FLASH, SRAM entonces realizar todos los procedimientos. La siguiente es los pasos específicos.
1. La tabla de vectores de interrupción y el manejador de interrupciones en la SRAM en
un nuevo archivo de startup_stm32f411xe_ram.s, en la posición de partida 0x20000000 (modificado archivo .sct). Tenga en cuenta que esta es una nueva, en lugar de directamente en el archivo original en la SRAM, ¿por qué? Se puede pensar. Definido en startup_stm32f411xe_ram.s en nueva sección llamada la RESET_ram (hay otros cambios, por favor refiérase a los códigos de control). Esta posición RESET_ram en sección SRAM comenzando en el .sct superior más tarde (ver paso 3).
Vector Tabla asignada a la dirección 0 en el reinicio del
AREA RESET_ram, DATOS, READONLY
EXPORTACIÓN __Vectors_ram
EXPORTACIÓN __Vectors_End_ram
EXPORTACIÓN __Vectors_Size_ram
__Vectors_ram DCD 0; Encima de la pila
DCD 0; Restablecer Handler
DCD NMI_Handler; NMI Handler
......
2. En la tabla de vectores de interrupción se establece en la dirección de desplazamiento SystemInit 0x20000000. Habilitar VECT_TAB_SRAM.
#ifdef VECT_TAB_SRAM
SCB-> VTOR = SRAM_BASE | VECT_TAB_OFFSET; / * Vector tabla de reubicación en la SRAM interna * /
#else SCB-> VTOR = FLASH_BASE | VECT_TAB_OFFSET; / * Vector tabla de reubicación en flash interna * /
#endif
3. Modificar los archivos .sct, todos los archivos de objetos que se necesitan son SRAM puesto región de la ejecución en tiempo de ejecución. Aquí tabla de vectores de interrupción tienen el mismo dos, uno al comienzo de la ubicación 0x08000000, 0x20000000 una posición en la salida.
LR_IROM1 0x08000000 0x00080000 {; región de carga size_region
ER_IROM1 0x08000000 0x00080000 {; dirección de carga = dirección de la ejecución
* .o (RESET + Primera)
* (InRoot $$ secciones)
.Cualquier (+ RO)
}
RW_IRAM1 0x20000000 0x00020000 {; Los datos RW
* .o (RESET_ram, + Primeras)
startup_stm32f411xe_ram.o (+ RO)
main.o (+ RO + RW)
stm32f4xx_it.o (+ RO + RW)
stm32f4xx_hal.o (+ RO + RW)
stm32f4xx_hal_gpio.o (+ RO + RW)
stm32f4xx_hal_rcc.o (+ RO + RW)
stm32f4xx_hal_cortex.o (+ RO + RW)
.any (+ RW + ZI)
}
}
4. Después de la compilación se ha completado, se puede ver en el archivo de mapa o de seguimiento de la depuración resultados. Después del restablecimiento del sistema, la función principal desde el principio, todos los programas se ejecutan en la memoria RAM.
Además, si el programa es útil para el fondo de las bibliotecas brazo puede ser añadido * * armlib (+ RO) en el archivo .sct a ser utilizados en todas las bibliotecas en la SRAM.
