🛠 Exploiter les deux cœurs et la FIFO inter-cœurs

Objectifs

Le RP2350 embarque deux cœurs Arm Cortex-M33 (ou deux cœurs RISC-V Hazard3 au choix, architecture sélectionnée au boot). Ce tutoriel fait tourner un producteur sur le cœur 0 et un consommateur sur le cœur 1, reliés par la FIFO matérielle 32 places du SDK, puis par la mémoire partagée. C'est la différence majeure avec une carte mono-cœur.

Matériel

• 1 × Raspberry Pi Pico 2
• Pico SDK ≥ 2.0.0, compilé avec -DPICO_BOARD=pico2
• Terminal série sur UART0 (GP0/GP1) pour la sortie

Code complet

/* multicore_fifo.c — coeur 0 produit, coeur 1 consomme via hardware/fifo */
#include "pico/stdlib.h"
#include "pico/multicore.h"
#include <stdio.h>

#define LED_PIN 25

void coeur1(void) {                /* execute sur le deuxieme M33 */
    gpio_init(LED_PIN); gpio_set_dir(LED_PIN, GPIO_OUT);
    uint32_t somme = 0, n = 0;
    while (true) {
        uint32_t v = multicore_fifo_pop_blocking;  /* attend une donnee */
        somme += v; n++;
        if (n == 100) {
            gpio_put(LED_PIN, !gpio_get(LED_PIN));
            multicore_fifo_push_blocking(somme);     /* rapporte la somme */
            somme = 0; n = 0;
        }
    }
}

int main(void) {
    stdio_init_all;
    multicore_launch_core1(coeur1);   /* démarre le coeur 1 */
    uint32_t tick = 0;
    while (true) {
        multicore_fifo_push_blocking(++tick);        /* 1..N */
        if (multicore_fifo_rvalid) {               /* rapport pret ? */
            printf("somme des 100 derniers = %u\n",
                   multicore_fifo_pop_blocking);
        }
        sleep_ms(1);
    }
}

Vérification attendue

La LED pulse toutes les 100 valeurs et le terminal affiche les sommes croissantes (100·n + 5000 par fenêtre). Mettez un point d'arrêt ou une boucle occupée dans coeur1 : le cœur 0 continue de tourner — preuve que les deux M33 exécutent en parallèle réel.

Erreurs fréquentes

• multicore_fifo_pop_blocking des deux côtés sans synchronisation : perte de données, la FIFO n'a que 32 places et ne distingue pas les émetteurs.
• Utiliser des variables globales partagées sans __attribute__((aligned(4))) ni verrou : les accès octet par octet ne sont pas atomiques entre cœurs ; préférer spin_lock (hardware/sync.h).
• Oublier que le cœur 1 ne démarre pas tout seul : sans multicore_launch_core1, seule la fonction main s'exécute.
• Confondre avec l'architecture RISC-V : si le boot est en mode Hazard3, le SDK multicore ARM ne s'applique pas tel quel.
• printf depuis les deux cœurs simultanément : entrelacement illisible, centraliser l'I/O sur un cœur.