C++ clock_nanosleep函数代码示例

/*
 * Sends the stored DMX state to its associated DMX port.  If fewer than
 * frame_period microseconds have elapsed since the start of the last frame,
 * then this function will delay until that time, unless status->period_mode is
 * nonzero, in which case calls to send_state will be ignored until the
 * specified frame period has elapsed.  This function should be called at least
 * once per second.  Returns zero on success, nonzero on error.
 */
int send_state(dmx_state *status)
{
	struct timespec this_time;

	if(status == NULL) {
		fprintf(stderr, "NULL status parameter");
		return -1;
	}

	// Mark before break + rate control
	fsync(status->fd); // fsync on a tty probably doesn't do anything...
	if(status->period_mode) {
		// Skip frame rate control mode
		clock_gettime(CLOCK_MONOTONIC, &this_time);
		if(compare_timespec(&this_time, status->next_time) < 0) {
			return 0;
		}
	} else {
		// Sleep rate control mode
		while(clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, status->next_time, NULL) == -1 && errno==EINTR) {
			// Repeatedly do nothing as long as clock_nanosleep() gets
			// interrupted (this space intentionally left blank)
		}
	}
	clock_gettime(CLOCK_MONOTONIC, status->next_time);
	status->next_time->tv_nsec += status->frame_period * 1000;
	if(status->next_time->tv_nsec >= 1000000000) {
		status->next_time->tv_nsec -= 1000000000;
		status->next_time->tv_sec += 1;
	}

	// Break
	if(ioctl(status->fd, TIOCSBRK, 0)) {
		perror("Error setting break");
		return -1;
	}
	usleep(status->break_time);
	if(ioctl(status->fd, TIOCCBRK, 0)) {
		perror("Error clearing break");
		return -1;
	}

	// Mark after break
	usleep(status->mark_time);

	// Data
	if(write(status->fd, &status->start_code, 1) < 0) {
		perror("Error sending start code");
		return -1;
	}
	if(write(status->fd, status->dmx_values, status->channels_to_send) < 0) {
		perror("Error sending dmx data");
		return -1;
	}

	return 0;
}

void
RTClock::sleepNext ()
{
  timeradd (&last_, &interval_, &last_);
  struct timespec req = timespecFromTimeval (last_);
  req.tv_sec = last_.tv_sec;
  req.tv_nsec = 1000 * last_.tv_usec;
  clock_nanosleep (CLOCK_REALTIME, TIMER_ABSTIME, &req, NULL);
}

void *blink5Hz(void *bla)
{
	struct timespec request;
	request.tv_nsec = 200000000;
	request.tv_sec = request.tv_nsec / 1000000000;

	while(!SHUTDOWN)
	{
		while(count % 2 == 0)
		{
			GPIO_write(LED_PATH, LED_ON);
			clock_nanosleep(CLOCK_REALTIME, SLEEP_FLAG, &request, NULL);
			GPIO_write(LED_PATH, LED_OFF);
		 	clock_nanosleep(CLOCK_REALTIME, SLEEP_FLAG, &request, NULL);
		}
		clock_nanosleep(CLOCK_REALTIME, SLEEP_FLAG, &request, NULL);
	}
	return;
}

int sleepFor( int32_t seconds,int32_t nanoseconds)
{
   struct timespec sSleepTime,sRemainder;
   int returnVal;
   sSleepTime.tv_sec = seconds;
   sSleepTime.tv_nsec = nanoseconds;
//   printf("target sec: %d, target nsec: %d\n",seconds,nanoseconds);
   returnVal = clock_nanosleep(CLOCK_REALTIME,0,&sSleepTime,&sRemainder);
   return returnVal;
}

void* periodicPrint() {
	while(1) {
		printf("hei\n");
		struct timespec next;
		clock_gettime(CLOCK_REALTIME, &next);
	
		timespec_add_us(&next, 500000);
		clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &next, NULL);
	}
}

/*****************************************************************************
 * msleep
 *****************************************************************************/
void msleep( mtime_t delay )
{
    struct timespec ts;
    ts.tv_sec = delay / 1000000;
    ts.tv_nsec = (delay % 1000000) * 1000;

#if defined( HAVE_CLOCK_NANOSLEEP )
    int val;
    while ( ( val = clock_nanosleep( CLOCK_MONOTONIC, 0, &ts, &ts ) ) == EINTR );
    if( val == EINVAL )
    {
        ts.tv_sec = delay / 1000000;
        ts.tv_nsec = (delay % 1000000) * 1000;
        while ( clock_nanosleep( CLOCK_REALTIME, 0, &ts, &ts ) == EINTR );
    }
#else
    while ( nanosleep( &ts, &ts ) && errno == EINTR );
#endif
}

void Timer::sync(Timer &t)
{
#if _POSIX_TIMERS > 0 && defined(HAVE_CLOCK_NANOSLEEP) && defined(POSIX_TIMERS)
    clock_nanosleep(_posix_clocking, TIMER_ABSTIME, &t.timer, NULL);
#elif defined(_MSWINDOWS_)
    SleepEx(t.get(), FALSE);
#else
    usleep(t.get());
#endif
}

/**
 * Sleep some amount of time.
 *
 * This service suspends the calling thread until the wakeup time specified by
 * @a rqtp, or a signal is delivered. The wakeup time is specified as a time
 * interval.
 *
 * If this service is interrupted by a signal and @a rmtp is not @a NULL, the
 * time remaining until the specified wakeup time is returned at the address @a
 * rmtp.
 *
 * The resolution of this service is one system clock tick.
 *
 * @param rqtp address of the wakeup time.
 *
 * @param rmtp address where the remaining time before wakeup will be stored if
 * the service is interrupted by a signal.
 *
 * @retval 0 on success;
 * @retval -1 with @a errno set if:
 * - EPERM, the caller context is invalid;
 * - EINVAL, the specified wakeup time is invalid;
 * - EINTR, this service was interrupted by a signal.
 *
 * @par Valid contexts:
 * - Xenomai kernel-space thread,
 * - Xenomai user-space thread (switches to primary mode).
 *
 * @see
 * <a href="http://www.opengroup.org/onlinepubs/000095399/functions/nanosleep.html">
 * Specification.</a>
 *
 */
int nanosleep(const struct timespec *rqtp, struct timespec *rmtp)
{
	int err = clock_nanosleep(CLOCK_REALTIME, 0, rqtp, rmtp);

	if (!err)
		return 0;

	thread_set_errno(err);
	return -1;
}

void compensated_timer(void)
{
	int ret, x;
	cycles_t t1, t2, error;

	x=0;
	while(1){
		before = get_cycles();
		ret = clock_nanosleep(CLOCK_MONOTONIC, TIMER_RELTIME, &carrier_ts, NULL);
		if(ret)
			DIE("clock_nanosleep");
		delta = get_cycles() - before;

again:
		/* 
		 * If we are pass our max tolerance there is nothing we can do
		 * other than compensating the time base backward
		 */
		if(delta > MONOTONIC_PULSE_CYCLE){
			carrier_ts.tv_nsec = carrier_ts.tv_nsec - 
				((delta - MONOTONIC_PULSE_CYCLE)/CPU_CYCLE_PER_NSEC);
			fprintf(stderr, "#%Lu\n",carrier_ts.tv_nsec);

			/* 
			 * Here this is a cut & paste from above to avoid clobbering the
			 * main loop with if / else
			 */
			before = get_cycles();
			ret = clock_nanosleep(CLOCK_MONOTONIC, TIMER_RELTIME, &carrier_ts, NULL);
			/* Reset the time base to original value */
			carrier_ts.tv_nsec = V_SYNC_NSEC_PERIOD;
			if(ret)
				DIE("clock_nanosleep");
			delta = get_cycles() - before;
			goto again;
		}
		calibrated_ldelay(MONOTONIC_PULSE_CYCLE - delta);
		
		fprintf(stderr," %Lu\n", (get_cycles() - before));
		if(!(x%100))
			fprintf(stderr, ".");
	}
}

// Adds "delay" nanoseconds to timespecs and sleeps until that time
static void sleep_until(struct timespec *ts, int delay)
{

    ts->tv_nsec += delay;
    if(ts->tv_nsec >= 1000*1000*1000) {
        ts->tv_nsec -= 1000*1000*1000;
        ts->tv_sec++;
    }
    clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, ts,  NULL);
}

int nanosleep_lat_test(int clockid, long long ns)
{
	struct timespec start, end, target;
	long long latency = 0;
	int i, count;

	target.tv_sec = ns/NSEC_PER_SEC;
	target.tv_nsec = ns%NSEC_PER_SEC;

	if (clock_gettime(clockid, &start))
		return UNSUPPORTED;
	if (clock_nanosleep(clockid, 0, &target, NULL))
		return UNSUPPORTED;

	count = 10;

	/* First check relative latency */
	clock_gettime(clockid, &start);
	for (i = 0; i < count; i++)
		clock_nanosleep(clockid, 0, &target, NULL);
	clock_gettime(clockid, &end);

	if (((timespec_sub(start, end)/count)-ns) > UNRESONABLE_LATENCY) {
		printf("Large rel latency: %lld ns :", (timespec_sub(start, end)/count)-ns);
		return -1;
	}

	/* Next check absolute latency */
	for (i = 0; i < count; i++) {
		clock_gettime(clockid, &start);
		target = timespec_add(start, ns);
		clock_nanosleep(clockid, TIMER_ABSTIME, &target, NULL);
		clock_gettime(clockid, &end);
		latency += timespec_sub(target, end);
	}

	if (latency/count > UNRESONABLE_LATENCY) {
		printf("Large abs latency: %lld ns :", latency/count);
		return -1;
	}

	return 0;
}

int main()
{
	struct sigaction sa;
	pthread_t thread;
   sigemptyset(&sa.sa_mask);
   sa.sa_flags = 0;
   sa.sa_handler = sigintHandler;

	if (sigaction(SIGINT, &sa, NULL) == -1)
	{
		printf("MAIN: reserving sigaction failed!\n");
		return -1;
	}

	
	GPIO_export(SWITCH);
	GPIO_export(LED);
	GPIO_direction(SWITCH_DIRECTION_PATH,"in");
	GPIO_direction(LED_DIRECTION_PATH,"out");
	GPIO_write(LED_PATH, LED_OFF);

	if(pthread_create(&thread, NULL , blink5Hz , NULL))
	{
		printf("MAIN: error: Thread-creation failed!\n");
		return -1;
	}

	struct timespec request;
	request.tv_nsec = 50000000;
	request.tv_sec = request.tv_nsec / 1000000000;

	printf("Push the Button ..");fflush(stdout);
	while(!SHUTDOWN)
	{
		while(strcmp(GPIO_read(SWITCH_PATH),LOW) != 0)
			clock_nanosleep(CLOCK_REALTIME, SLEEP_FLAG, &request, NULL);

		while(strcmp(GPIO_read(SWITCH_PATH),HIGH) != 0)
			clock_nanosleep(CLOCK_REALTIME, SLEEP_FLAG, &request, NULL);
		
		count++;	
	}
}

void *timeout_helper(void *arg)
{
    struct to_info *tip;

    tip = (struct to_info *)arg;
    clock_nanosleep(CLOCK_REALTIME, 0, &tip->to_wait, NULL);
    (*tip->to_fn)(tip->to_arg);
    free(arg);
    return (0);
}

int main(){
   mqd_t mq;

   struct mq_attr attr;
	char QUEUE_NAME[] = "/test1";
	
	ssize_t bytes_read;
	int ret;

	struct timespec looptime;
	looptime.tv_sec = 1;
	looptime.tv_nsec = 0;
	
	testStruct msg;

   /* initialize the queue attributes */
   attr.mq_flags = 0;
   attr.mq_maxmsg = 1;
   attr.mq_msgsize = sizeof(testStruct);
   attr.mq_curmsgs = 0;

	//mq_unlink(QUEUE_NAME);
	
   /* create the message queue */
	mq = mq_open(QUEUE_NAME, O_WRONLY|O_NONBLOCK);
	
	int i;
	for(i = 0; i < 10; i++)
	{
		msg.a = i+1;
		msg.b = i+11;

   	ret = clock_nanosleep(CLOCK_REALTIME, NULL, &looptime, NULL);
		if(ret < 0)
		{
			printf("Problem with sleep\n");
		}

		/* send the message */
      bytes_read = mq_send(mq, (char *) &msg, 8, NULL);
		if(bytes_read < 0)
		{
			perror("");
			printf("error sending value to queue\n");
		}
		else
		{
			printf("sent: %d, %d\n",msg.a, msg.b);
		}
	}

	mq_close(mq);

	return 0;
};

static void run_leapsec(void)
{
	const struct timespec sleeptime = { 0, NSEC_PER_SEC / 2 };
	struct timespec now, leap, start;
	struct timex tx;

	clock_gettime(CLOCK_REALTIME, &now);
	start = now;
	tst_resm(TINFO, "test start at %s", strtime(&now));

	test_hrtimer_early_expiration();

	/* calculate the next leap second */
	now.tv_sec += 86400 - now.tv_sec % 86400;
	now.tv_nsec = 0;
	leap = now;
	tst_resm(TINFO, "scheduling leap second %s", strtime(&leap));

	/* start before the leap second */
	now.tv_sec -= SECONDS_BEFORE_LEAP;
	if (clock_settime(CLOCK_REALTIME, &now) < 0)
		tst_brkm(TBROK | TERRNO, cleanup, "clock_settime");
	tst_resm(TINFO, "setting time to        %s", strtime(&now));

	/* reset NTP time state */
	adjtimex_status(&tx, STA_PLL);
	adjtimex_status(&tx, 0);

	/* set the leap second insert flag */
	adjtimex_status(&tx, STA_INS);

	/* reliably sleep till after the leap second */
	while (tx.time.tv_sec < leap.tv_sec + SECONDS_AFTER_LEAP) {
		adjtimex_status(&tx, tx.status);
		clock_nanosleep(CLOCK_MONOTONIC, 0, &sleeptime, NULL);
	}

	test_hrtimer_early_expiration();

	adjtimex_status(&tx, STA_PLL);
	adjtimex_status(&tx, 0);

	/* recover from timer expiring state and restore time */
	clock_gettime(CLOCK_REALTIME, &now);
	start.tv_sec += now.tv_sec - (leap.tv_sec - SECONDS_BEFORE_LEAP);
	start.tv_nsec += now.tv_nsec;
	start.tv_sec += start.tv_nsec / NSEC_PER_SEC;
	start.tv_nsec = start.tv_nsec % NSEC_PER_SEC;
	tst_resm(TINFO, "restoring time to %s", strtime(&start));
	/* calls clock_was_set() in kernel to revert inconsistency */
	if (clock_settime(CLOCK_REALTIME, &start) < 0)
		tst_brkm(TBROK | TERRNO, cleanup, "clock_settime");

	test_hrtimer_early_expiration();
}