La tâche retardée ne revient jamais

Question

Une tâche créée à partir du shell (t2) instancie une nouvelle tâche (tTask1). La priorité de t2 est de 100 et la priorité de tTask1 est de 120 qui est plus que t2. t2 est en cours d'exécution jusqu'à ce que son premier état soit retardé et ne revienne plus jamais, de sorte que tTask1 reste en état de suspension et ne puisse pas reprendre à nouveau. Je n'ai pas pu trouver ce qui cause le problème. Voici mon code:

include "vxWorks.h" 
#include <iostream.h> 
#include "taskLib.h" 
#include "sysLib.h" 


VX_TASK(tTask1,20000); 
int tickCount = 0; 
int oldTickValue = 0; 

#define SCHEDULER_ERROR -1 
#define SCHEDULER_WORKING 0 


void subTask() 
{ 
    int i = 0; 
    for (i = 0; i < 3; i++) 
    { 
     std::cout << "sub Task " << i << std::endl; 
    } 
} 

bool isTickChanged() { 
    uint32_t newTickValue; 
    bool flag; 
    flag = false; 
    newTickValue = tickCount; 
    std::cout << "newTickValue = " << newTickValue << std::endl; 
    if (newTickValue != oldTickValue) 
    { 
     if (1U < (newTickValue - oldTickValue)) 
     { 
      std::cout << "scheduler error = " << newTickValue << std::endl; 
     } 
     else 
     { 
      std::cout << "scheduler is working = " << newTickValue << std::endl; 
     } 

     flag = true; 
     oldTickValue = newTickValue; 
    } 
    return flag; 
} 

void timerHandler() 
{ 
    ++tickCount; 
} 

void task1() 
{ 
    std::cout << "task 1 begin" << std::endl; 
    sysAuxClkEnable(); 
    sysAuxClkRateSet(10);    
    sysClkConnect(reinterpret_cast<FUNCPTR>(timerHandler), NULL); 
    std::cout << "Aux Clock Rate = " << sysAuxClkRateGet() << std::endl; 

    while(1) 
    { 
     if (isTickChanged()) 
     {    
      std::cout << "task 1 tick changed" << std::endl; 
      subTask(); 
      taskSuspend(0); 
     } 

    } 
} 

void sch(void) 
{ 
    int myTaskId; 
    myTaskId = VX_TASK_INSTANTIATE(tTask1, 120, VX_FP_TASK|VX_SUPERVISOR_MODE|VX_DEALLOC_STACK|VX_STDIO|VX_DEALLOC_EXC_STACK|VX_DEALLOC_TCB|VX_SPE_TASK, 20000, (FUNCPTR) task1, 0,0,0,0,0,0,0,0,0,0); 
    FOREVER { 
     taskResume(myTaskId); 
     taskDelay(10); 
    } 


} 

et de sortie comme ci-dessous:

-> sp sch 
Task spawned: id = 0x1897c00, name = t2 
value = 25787392 = 0x1897c00 
-> task 1 begin 
Aux Clock Rate = 10 
newTickValue = 0 
newTickValue = 0 
newTickValue = 0 
newTickValue = 0 
newTickValue = 0 
newTickValue = 0 
newTickValue = 0 
newTickValue = 0 
newTickValue = 1 
scheduler working = 1 
task 1 tick changed 
sub Task 0 
sub Task 1 
sub Task 2 

t2

attend dans l'état "retardé" et tTask1 attend dans l'état "suspendu".

Answer 1

Les fonctions liées au temporisateur du système d'exploitation, telles que taskDelay(), requièrent que le noyau reçoive une coche de temporisateur. Le noyau ne peut rien faire de temps s'il ne reçoit pas ces notifications de tick. Avec VxWorks, je crois que vous êtes censé appeler tickAnnounce() pour notifier le noyau d'une coche. Mais dans votre tâche1(), vous appelez sysClkConnect() et enregistrez votre routine timerHandler(). timerHandler() n'incrémente que le tickCount de votre application et n'informe pas le noyau de la coche. Donc, le noyau n'a aucun moyen de savoir qu'une coche s'est produite, il sera donc incapable de suivre l'heure et la fonction taskDelay() ne fonctionnera pas.

Je suppose que vous pourriez appeler tickAnnounce() de votre routine timerHandler() et cela pourrait résoudre le problème. Mais il me semble étrange que vous remplaciez le gestionnaire de tick système par quelque chose pour votre application. Votre application ne devrait-elle pas utiliser une autre minuterie, ou peut-être un service de minuterie logicielle fourni par le système d'exploitation, plutôt que de réutiliser l'horloge du système?