_core1_entry() {;
getInstance();;
if (self._task) {;
_task();;
while (true) {;
tight_loop_contents();;

                    

            DualCore_Handler instance;
return instance;
return false;
return true;
return false;
return 0;
return false;
return _running;

                    

        // #pragma once
// // DualCore_Handler.h

// #include <Arduino.h>

// #if defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_RP2350)
// #include "pico/multicore.h"
// #endif

// /**
//  * @namespace crepp::system
//  * @brief Espace de noms système de la bibliothèque CREPP.
//  */
// namespace crepp::system {

// /**
//  * @class DualCore_Handler
//  * @brief Gestionnaire du fonctionnement multi-cœur.
//  *
//  * @details
//  * Cette classe fournit une interface simple pour exploiter
//  * le second cœur des microcontrôleurs RP2040 / RP2350.
//  *
//  * Fonctionnalités :
//  * - lancement d'une tâche sur le cœur 1,
//  * - communication inter-cœurs via FIFO matérielle,
//  * - abstraction portable (désactivée sur architectures mono-cœur).
//  *
//  * Implémentation basée sur le pattern Singleton.
//  */
// class DualCore_Handler {
// public:
//     /**
//      * @brief Type alias pour une tâche exécutée sur le cœur 1.
//      */
//     using CoreTask = void (*)();

//     /**
//      * @brief Accès à l'instance unique du gestionnaire DualCore.
//      *
//      * @return Référence vers l'instance unique.
//      */
//     static DualCore_Handler& getInstance() {
//         static DualCore_Handler instance;
//         return instance;
//     }

//     /**
//      * @brief Lance l'exécution d'une tâche sur le cœur 1.
//      *
//      * @details
//      * - Disponible uniquement sur RP2040 / RP2350.
//      * - Le cœur 1 exécute la fonction passée en paramètre
//      *   dans une boucle infinie sécurisée.
//      *
//      * @param task Fonction à exécuter sur le cœur 1.
//      * @return true si le cœur 1 a été lancé avec succès.
//      * @return false si déjà lancé, tâche invalide ou architecture non supportée.
//      */
//     bool start(CoreTask task) {
// #if defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_RP2350)
//         if (_running || task == nullptr) return false;

//         _task = task;
//         multicore_launch_core1(_core1_entry);
//         _running = true;
//         return true;
// #else
//         (void)task;
//         return false;
// #endif
//     }

//     /**
//      * @brief Envoie une valeur vers l'autre cœur via la FIFO.
//      *
//      * @param value Valeur 32 bits à transmettre.
//      */
//     inline void send(uint32_t value) {
// #if defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_RP2350)
//         multicore_fifo_push_blocking(value);
// #else
//         (void)value;
// #endif
//     }

//     /**
//      * @brief Lit une valeur depuis la FIFO inter-cœurs.
//      *
//      * @return Valeur reçue.
//      */
//     inline uint32_t read() {
// #if defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_RP2350)
//         return multicore_fifo_pop_blocking();
// #else
//         return 0;
// #endif
//     }

//     /**
//      * @brief Indique si une donnée est disponible dans la FIFO.
//      *
//      * @return true si une donnée est disponible.
//      * @return false sinon ou si non supporté.
//      */
//     inline bool available() const {
// #if defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_RP2350)
//         return multicore_fifo_rvalid();
// #else
//         return false;
// #endif
//     }

//     /**
//      * @brief Indique si le cœur 1 est en cours d'exécution.
//      *
//      * @return true si le cœur 1 est actif.
//      */
//     inline bool running() const { return _running; }

// private:
//     /**
//      * @brief Constructeur privé (Singleton).
//      */
//     DualCore_Handler() = default;

//     /**
//      * @brief Constructeur de copie supprimé.
//      */
//     DualCore_Handler(const DualCore_Handler&) = delete;

//     /**
//      * @brief Opérateur d'affectation supprimé.
//      */
//     DualCore_Handler& operator=(const DualCore_Handler&) = delete;

// #if defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_RP2350)
//     /**
//      * @brief Point d'entrée du cœur 1.
//      *
//      * @details
//      * Exécute la tâche utilisateur puis entre dans
//      * une boucle infinie sécurisée.
//      */
//     static void _core1_entry() {
//         auto& self = getInstance();
//         if (self._task) {
//             self._task();
//         }

//         // Sécurité : ne jamais sortir du cœur 1
//         while (true) {
//             tight_loop_contents();
//         }
//     }
// #endif

//     /**
//      * @brief Tâche exécutée sur le cœur 1.
//      */
//     CoreTask _task = nullptr;

//     /**
//      * @brief Indique si le cœur 1 est actif.
//      */
//     volatile bool _running = false;
// };

// } // namespace crepp::system