我正在设置POSIX计时器以给定的速率调用函数。我设置了一个信号处理程序并初始化计时器等...一切正常。但是,根据我读过的所有文档,当我在信号处理程序中时,我应该永远不会收到来自计时器的信号(它应该被自动阻止)。为了更进一步,我甚至设置了sigaction的sa_mask来阻止所有信号......我仍然可以多次调用信号处理程序......
设置处理程序:
// establish the signal handler
sigset_t blockMask;
struct sigaction sigact;
sigfillset(&blockMask);
//sigemptyset(&blockMask);
sigact.sa_flags = SA_SIGINFO;
sigact.sa_sigaction = callbackIn;
sigact.sa_mask = blockMask;
if( sigaction(ElmoSynchronizer::NEXT_RT_SIGNAL_NUMBER, &sigact, NULL) == -1 )
{
return CanStatus( CanStatus::SYSTEM_ERROR, __FUNCTION__, "Couldn't establish signal handler for timer" );
}
// create the timer
struct sigevent sev;
sev.sigev_notify = SIGEV_SIGNAL;
sev.sigev_signo = ElmoSynchronizer::NEXT_RT_SIGNAL_NUMBER;
sev.sigev_value.sival_ptr = this;
if( timer_create(CLOCK_REALTIME, &sev, timerIn) == -1 )
{
return CanStatus( CanStatus::SYSTEM_ERROR, __FUNCTION__, "Couldn't create POSIX timer for timer" );
}
// start the timer
struct itimerspec timerSpec;
timerSpec.it_value = firstExecTime;
timerSpec.it_interval = ElmoSynchronizer::getTimespecFromDouble(1.0/rate_hz);
if( timer_settime(*timerIn, TIMER_ABSTIME, &timerSpec, NULL) == -1 )
{
return CanStatus( CanStatus::SYSTEM_ERROR, __FUNCTION__, "Couldn't start timer for timer" );
}
回调(是的,我知道printfs在信号处理程序中很糟糕):
void ElmoSynchronizer::rootPvtCallback(int sig, siginfo_t *si, void *uc)
{
// get a pointer to the ElmoSynchronizer calling this
ElmoSynchronizer *elmoSync = (ElmoSynchronizer*)si->si_value.sival_ptr;
struct timespec startTime;
clock_gettime(CLOCK_REALTIME, &startTime);
uint32_t expectedTime_us = elmoSync->getMasterClockTimeFromTimespec_us(elmoSync->m_pvtSupplyStartTime) + ((elmoSync->m_updateIteration * elmoSync->m_elmoUpdatePeriod_ms) * 1000);
uint32_t actualTime_us = elmoSync->getMasterClockTimeFromTimespec_us(startTime);
uint32_t currIter = elmoSync->m_updateIteration+1;
printf("---> PVT update - iteration %u @ %u\n", currIter, elmoSync->getMasterClockTimeFromTimespec_us(startTime));
fflush(stdout);
// iterate through all of our callbacks and call them!
for( unsigned int i = 0; i < elmoSync->m_elmos.size(); i++ )
{
// get the position/velocity pair
posVelPair_t pv = elmoSync->m_elmos[i].callback(elmoSync->m_elmos[i].elmo);
// now add the point to the elmo
elmoSync->m_elmos[i].elmo->addPvtPoints( pv.position_cnts, pv.velocity_cps, elmoSync->m_elmoUpdatePeriod_ms );
}
elmoSync->m_updateIteration++;
if( elmoSync->m_updateIteration == 250 )
{
usleep(elmoSync->m_elmoUpdatePeriod_ms*4000);
}
// make sure we executed fast enough
struct timespec endTime;
clock_gettime(CLOCK_REALTIME, &endTime);
double totalCallbackTime_s = getSecondsFromTimespec(ElmoSynchronizer::ts_subtract(endTime, startTime));
if( totalCallbackTime_s > (elmoSync->m_elmoUpdatePeriod_ms * 1.0E-3) )
{
//ROS_WARN("PVT update - Callback execution took longer than update period! %lfs actual / %lfs period", totalCallbackTime_s, (elmoSync->m_elmoUpdatePeriod_ms * 1.0E-3));
//overflowedRootPvtCallbackPeriod = true;
}
printf("<--- PVT update - iteration %u @ %u\n", currIter, elmoSync->getMasterClockTimeFromTimespec_us(endTime));
fflush(stdout);
/*
printf("PVT update - iteration: %u actual: %u expected: %u diff: %u cbTime: %u\n",
elmoSync->m_updateIteration, actualTime_us, expectedTime_us, actualTime_us-expectedTime_us, (uint32_t)(totalCallbackTime_s * 1.0E6));
fflush(stdout);
*/
}
输出:
---> PVT update - iteration 248 @ 13315103
<--- PVT update - iteration 248 @ 13315219
---> PVT update - iteration 249 @ 13346107
<--- PVT update - iteration 249 @ 13346199
---> PVT update - iteration 250 @ 13377104 // two entrances
---> PVT update - iteration 251 @ 13408109 // second entrance
<--- PVT update - iteration 251 @ 13408197
---> PVT update - iteration 252 @ 13439109
<--- PVT update - iteration 252 @ 13439254
---> PVT update - iteration 253 @ 13470120
<--- PVT update - iteration 253 @ 13470216
---> PVT update - iteration 254 @ 13501122
<--- PVT update - iteration 254 @ 13501213
<--- PVT update - iteration 250 @ 13501317 // exit for iteration 250
---> PVT update - iteration 255 @ 13532078
<--- PVT update - iteration 255 @ 13532170
---> PVT update - iteration 256 @ 13563109
<--- PVT update - iteration 256 @ 13563242
答案 0 :(得分:1)
不是设置周期性定时器,而是在信号处理程序结束时再次拍摄。
创建计时器时执行此操作
// start the timer
//struct itimerspec timerSpec;
this->timerSpec_.it_value = firstExecTime;
this->timerSpec_.it_interval = 0; //one-shot
if( timer_settime(*timerIn, TIMER_ABSTIME, &this->timerSpec_, NULL) == -1 )
{
return CanStatus( CanStatus::SYSTEM_ERROR, __FUNCTION__, "Couldn't start timer for timer" );
}
// from now we will shoot the timer with this value
this->timerSpec_.it_value = ElmoSynchronizer::getTimespecFromDouble(1.0/rate_hz);
// store *timerIn in also in ElmoSynchronizer
this->timerId_ = *timerIn;
然后追加ElmoSynchronizer::rootPvtCallback
函数的最后一个
//shoot our the timer again
if( timer_settime(elmoSync->timerId_, 0, &elmoSync->timerSpec_, NULL) == -1 )
{
return CanStatus( CanStatus::SYSTEM_ERROR, __FUNCTION__, "Couldn't restart timer" );
}
顺便说一句,我会使用线程和信号量来完成所有事情,因此同步器可以简单地检查PVT更新过程是否在定义的持续时间内结束。 POSIX提供它们并且比计时器更难实现。
答案 1 :(得分:1)
当我需要调试信号处理程序时,我创建了一个数组来调试信息(而不是使用printf)。收集大量信号处理程序调用的数据,然后转储数组的内容以查看发生的情况。
您可能会看到输出的顺序不同。