De nos jours, de plus en plus d'appareils intégrés prennent en charge les mises à jour automatiques à distance sans avoir besoin de téléchargeurs, ce qui rend la maintenance des appareils très pratique. Pour activer les mises à jour à distance d'un appareil, nous devons écrire un code de programme qui prend en charge le processus de mise à jour. Ce programme est communément appelé BootLoader.
En substance, le code du programme de l'appareil est divisé en deux parties : le BootLoader et l'APP. Le BootLoader est chargé de mettre à jour l'APP et de lancer son exécution. L'APP, quant à elle, est chargée de mettre en œuvre les fonctions opérationnelles de l'appareil, hébergeant essentiellement les fonctionnalités principales de l'appareil.
Pour les microcontrôleurs de la série Cortex-M, certaines configurations sont nécessaires pour assurer une transition sécurisée du BootLoader vers l'APP. Cet article prend comme exemple les microcontrôleurs STM32 pour décrire les étapes de configuration clés nécessaires à la mise en œuvre d'une transition réussie du BootLoader vers l'APP.
BootLoader Aller à l'application
Étape 1 : partition Flash
Au cours de la phase de programmation et de conception, il est important de partitionner la mémoire Flash en fonction des exigences spécifiques de l'application. Cela implique de déterminer où le BootLoader et l'APP seront stockés, ainsi que l'espace alloué à chacun. Cet emplacement de stockage a une incidence directe sur l'exécution et les transitions du programme.
L'une des stratégies de mise à niveau les plus simples consiste à disposer d'un BootLoader et d'une APP. Le BootLoader gère les transitions et facilite les mises à niveau de l'APP. Cet article utilise cette stratégie de mise à niveau comme exemple d'explication.
Pour les microcontrôleurs STM32, l'adresse mappée pour le démarrage du programme est 0x8000000.
Le BootLoader peut être stocké à l'adresse 0x8000000, et l'espace alloué peut être ajusté en fonction de la taille Flash spécifique de la puce, par exemple 0x10000 ou 64 Ko.
L'adresse de stockage de l'application est placée après le BootLoader, plus précisément à l'adresse 0x8010000. L'espace restant dans la mémoire Flash peut être alloué à l'application.
Étape 2 : Configuration du projet BootLoader
La configuration du projet BootLoader comprend plusieurs étapes. En prenant MDK comme exemple, le programme BootLoader est stocké dans la mémoire FLASH à l'adresse 0x8000000 avec une taille de 0x10000.
Lors de la transition vers l'application à l'aide du code du programme, tenez compte des points suivants :
- Vérifiez la validité de l'adresse supérieure de la pile, c'est-à-dire si l'adresse de départ de l'APP est valide.
if(((*(__IO uint32_t *)APP_FLASH_ADDR) & 0x2FFE0000) == 0x20000000)
- Désactivez toutes les interruptions afin d'éviter toute perturbation pendant la transition qui pourrait entraîner des exceptions.
- Obtenir l'adresse de départ du programme APP, qui est stockée comme deuxième mot (adresse de départ + 4, données stockées dans la mémoire Flash).
- Initialisez le pointeur de pile (le premier mot de la zone de code utilisateur contient l'adresse supérieure de la pile).
- Convertissez l'adresse de départ de l'APP en un type de pointeur de fonction et effectuez la transition.
Le code spécifique pour la transition est le suivant :
/* Define type */
typedef void (*pFunction)(void);
/* APP flash address */
#define APP_FLASH_ADDR (0x8010000)
void jump_to_app(void)
{
uint32_t JumpAddress;
pFunction Jump_To_Application;
/* Check if the stack top address is valid */
if(((*(__IO uint32_t *)APP_FLASH_ADDR) & 0x2FFE0000) == 0x20000000)
{
/* Disable all interrupts to prevent disturbances during transition */
__disable_irq();
/* The second word in the user code area is the program's start address (reset address) */
JumpAddress = *(__IO uint32_t *) (APP_FLASH_ADDR + 4);
/* Initialize the user application's Stack Pointer */
__set_MSP(*(__IO uint32_t *) APP_FLASH_ADDR);
/* Type conversion */
Jump_To_Application = (pFunction) JumpAddress;
/* Transition to the APP */
Jump_To_Application();
}
}
Étape 3 : Configuration du projet APP
De même, le projet APP nécessite certaines configurations. En prenant MDK comme exemple, le programme APP est stocké dans la mémoire FLASH à l'adresse 0x8010000 avec une taille de 0x30000.
La configuration du programme APP comprend les étapes suivantes :
- Déplacez la table de vecteurs Flash interne dans l'APP en modifiant SCB->VTOR.
- Une fois que l'APP a démarré, il est essentiel d'activer les interruptions dans la fonction d'initialisation afin de garantir le bon déroulement de l'exécution du programme. Si cela n'est pas fait, des anomalies peuvent survenir dans le programme.
Normalement, dans le fichier de démarrage, la fonction SystemInit() est appelée. Cette fonction configure les informations d'interface de la mémoire Flash.
SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET
Modifiez la valeur de la définition de macro VECT_TAB_OFFSET à 0x10000.
Une fois le programme APP démarré, il est essentiel d'activer les interruptions globales. Vous pouvez placer le code suivant dans la section d'initialisation :
/* Enable interrupts */
__enable_irq();
APP Aller au BootLoader
Pendant le fonctionnement de l'appareil, l'application est en cours d'exécution et traite les fonctions commerciales. Si vous souhaitez mettre à niveau l'application, vous devez passer de l'application au BootLoader. Alors, comment faire passer l'application au BootLoader ? Il existe deux méthodes :
- Mode matériel, arrêt de l'appareil, redémarrage ou bouton de réinitialisation
- Mode logiciel : réinitialisation du microcontrôleur via le contrôle logiciel
En mode logiciel, des commandes de contrôle peuvent être ajoutées au code de l'application, et lorsque l'application reçoit la commande de passage (ou la commande de mise à niveau), le microcontrôleur est réinitialisé. Le code suivant permet de réinitialiser le microcontrôleur :
/* reset chip */
HAL_NVIC_SystemReset();
