Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Bibliothèque de groupes de tâches

Présentation

FreeRTOS prend en charge la gestion des tâches grâce à la bibliothèque FreeRTOS Task Pool. La bibliothèque de pool de tâches vous permet de planifier les tâches en arrière-plan et autorise la planification et l'annulation sécurisées des tâches asynchrones. À l'aide du pool de tâches APIs, vous pouvez configurer les tâches de votre application afin d'optimiser le compromis entre performances et encombrement mémoire.

La bibliothèque de pools de tâches est construite sur deux structures de données principales : le pool de tâches et les tâches du pool de tâches.

Pool de tâches (IotTaskPool_t)

Le pool de tâches contient une file d'attente de répartition qui gère la file d'attente de tâches pour l'exécution, et gère les threads de travail qui exécutent les tâches.

Tâches du groupe de tâches (IotTaskPoolJob_t)

Les tâches du pool de tâches peuvent être exécutées en tant que tâches en arrière-plan, ou de tâches en arrière-plan limitées dans le temps. Les tâches d'arrière-plan sont démarrées dans l' First-In-First-Outordre et ne sont soumises à aucune contrainte de temps. Les tâches limitées dans le temps sont planifiées pour une exécution d'arrière-plan selon un minuteur.

Dépendances et exigences

Le pool de tâches possède les dépendances suivantes :

Fonctionnalités

À l'aide de la bibliothèque du pool de tâches APIs, vous pouvez effectuer les opérations suivantes :

Résolution des problèmes

Les fonctions des pools de tâches renvoient des codes d'erreur en tant que valeurs énumérées IotTaskPoolError_t. Pour plus d'informations sur chaque code d'erreur, consultez la documentation de référence pour le type de données IotTaskPoolError_t énuméré dans la Référence d'API du kit SDK C de pool de tâches.

Restrictions liées à l'utilisation

La bibliothèque de pools de tâches ne peut pas être utilisée à partir d'une routine de service d'interruption (ISR).

Nous déconseillons vivement les rappels utilisateur de groupes de tâches qui effectuent des opérations de blocage, en particulier les opérations de blocage indéfinies. Les opérations de blocage longue durée volent efficacement un thread de pool de tâches et créent un risque de blocage ou de manque.

Initialisation

Une application doit appeler IotTaskPool_CreateSystemTaskPool pour initialiser une instance d'un pool de tâches système, avant d'utiliser le pool de tâches. L'application a besoin de vérifier que le pool de tâches au niveau du système est initialisé assez tôt dans la séquence de démarrage, avant que toute bibliothèque utilise la tâche et avant que tout code d'application publie une tâche dans le pool de tâches. Peu après le démarrage, le système initialise le pool de tâches unique au niveau du système pour toutes les bibliothèques à partager. Après l'initialisation, le handle de pool de tâches peut être extrait en vue d'une utilisation avec l'API IOT_SYSTEM_TASKPOOL.

Référence d’API

Pour obtenir une référence d'API complète, consultez la Référence d'API du kit SDK C de pool de tâches.

Exemple d’utilisation

Supposons que vous deviez planifier une collecte récurrente de AWS IoT Device Defender métriques et que vous décidiez d'utiliser un minuteur pour planifier la collecte en appelant le MQTT à se connecter, à s'abonner et à publier APIs. Le code suivant définit une fonction de rappel pour accepter les AWS IoT Device Defender métriques via MQTT, avec un rappel de déconnexion qui se déconnecte de la connexion MQTT.

/* An example of a user context to pass to a callback through a task pool thread. */
typedef struct JobUserContext
{
    uint32_t counter;
} JobUserContext_t;
 
/* An example of a user callback to invoke through a task pool thread. */
static void ExecutionCb( IotTaskPool_t * pTaskPool, IotTaskPoolJob_t * pJob, void * context )
{
    ( void )pTaskPool;
    ( void )pJob;
    JobUserContext_t * pUserContext = ( JobUserContext_t * )context;
    pUserContext->counter++;
}
 
void TaskPoolExample( )
{
    JobUserContext_t userContext = { 0 };
    IotTaskPoolJob_t job;
    IotTaskPool_t * pTaskPool;
    IotTaskPoolError_t errorSchedule;
 
    /* Configure the task pool to hold at least two threads and three at the maximum. */
    /* Provide proper stack size and priority per the application needs. */
    const IotTaskPoolInfo_t tpInfo = { .minThreads = 2, .maxThreads = 3, .stackSize = 512, .priority = 0 };
 
    /* Create a task pool. */
    IotTaskPool_Create( &tpInfo, &pTaskPool );
 
    /* Statically allocate one job, then schedule it. */
    IotTaskPool_CreateJob( &ExecutionCb, &userContext, &job );   
    errorSchedule = IotTaskPool_Schedule( pTaskPool, &job, 0 );
 
    switch ( errorSchedule )
    {
    case IOT_TASKPOOL_SUCCESS:
        break;
    case IOT_TASKPOOL_BAD_PARAMETER:          // Invalid parameters, such as a NULL handle, can trigger this error.
    case IOT_TASKPOOL_ILLEGAL_OPERATION:      // Scheduling a job that was previously scheduled or destroyed could trigger this error.
    case IOT_TASKPOOL_NO_MEMORY:              // Scheduling a with flag #IOT_TASKPOOL_JOB_HIGH_PRIORITY could trigger this error.
    case IOT_TASKPOOL_SHUTDOWN_IN_PROGRESS:   // Scheduling a job after trying to destroy the task pool could trigger this error.
        // ASSERT
        break;
    default:
        // ASSERT*/
    }
 
    /* ................................. */
    /*  ... Perform other operations ... */
    /* ................................. */
 
    IotTaskPool_Destroy( pTaskPool );
}