自学教程：C++ stop_rt_timer函数代码示例

void cleanup_module(void){	char msg[] = "let's end the game";	int i;	for (i = 0; i < NTASKS; i++) {		end = i;		rt_msgsnd_nu(rmbx[i], 1, msg, sizeof(msg), 0);	}	end = NTASKS;	rt_msgsnd_nu(smbx, 1, msg, sizeof(msg), 0);	current->state = TASK_INTERRUPTIBLE;	schedule_timeout(HZ);	for (i = 0; i < NTASKS; i++) {		rt_msgctl(rmbx[i], IPC_RMID, NULL);		printk("TASK %d, LOOPS: %d./n", i, cnt[i]);	}	rt_msgctl(smbx, IPC_RMID, NULL);	stop_rt_timer();	rt_sem_delete(&barrier);	for (i = 0; i < NTASKS; i++) {		rt_task_delete(&mthread[i]);	}	rt_task_delete(&bthread);	rt_printk("MODULE ENDS./n");}

int main(void){                   	RT_TASK *maint;	MSG msg = { 0, 0 };	maint = rt_task_init(nam2num("MAIN"), 99, 0, 0);	bx = rt_tbx_init(nam2num("BX"), TBXSIZE, ORDER);	start_rt_timer(nano2count(TIMEBASE));	pthread_create(&pt1, NULL, Task1, NULL);	pthread_create(&pt2, NULL, Task2, NULL);	pthread_create(&pt3, NULL, Task3, NULL);	pthread_create(&pt4, NULL, Task4, NULL);	pthread_create(&pt5, NULL, Task5, NULL);	pthread_create(&pt6, NULL, Task6, NULL);	pthread_create(&pt7, NULL, Task7, NULL);	printf("/ntasks started/n");        pthread_join(pt1, NULL);        pthread_join(pt4, NULL);        pthread_join(pt7, NULL);	endall = 1;	rt_tbx_broadcast(bx, (char*)&msg, sizeof(msg));        pthread_join(pt2, NULL);        pthread_join(pt3, NULL);        pthread_join(pt5, NULL);        pthread_join(pt6, NULL);	rt_tbx_delete(bx);	rt_task_delete(maint);	stop_rt_timer();	printf("/n/nEND/n/n");	return 0;}

void rtcap_cleanup(void){    unsigned long flags;#if defined(CONFIG_RTAI_24) || defined(CONFIG_RTAI_30) || defined(CONFIG_RTAI_31)    if (start_timer)        stop_rt_timer();#endif    rtos_nrt_signal_delete(&cap_signal);    /* unregister capturing handlers */    rtos_spin_lock_irqsave(&rtcap_lock, flags);    rtcap_handler = NULL;    rtos_spin_unlock_irqrestore(&rtcap_lock, flags);    /* empty queue (should be already empty) */    rtcap_signal_handler();    cleanup_tap_devices();    rtskb_pool_release(&cap_pool);    printk("RTcap: unloaded/n");}

int main(void){  RT_TASK *task;  RTIME now;  int cnt=0;  // make main thread LXRT soft realtime  task = rt_task_init_schmod(nam2num("MYTASK"), 9, 0, 0, SCHED_FIFO, 0xF);  mlockall(MCL_CURRENT | MCL_FUTURE);  // start realtime timer and scheduler  //rt_set_oneshot_mode();  rt_set_periodic_mode();  start_rt_timer(0);  now = rt_get_time() + 10*PERIOD;  rt_task_make_periodic(task, now, PERIOD);  printf("Init mutex and cond./n");  mutex = rt_sem_init(nam2num("MUTEX"), 1);  if (mutex==0)    printf("Error init mutex/n");  cond = rt_cond_init(nam2num("CONDITION"));  if (cond==0)    printf("Error init cond/n");  thread0 = rt_thread_create(fun0, NULL, 10000);  //thread1 = rt_thread_create(fun1, NULL, 20000);  //rt_sleep(PERIOD);  while (cnt < THRESHOLD) {    rt_task_wait_period();    rt_printk("main: Hello World %d!/n",cnt);    rt_sem_wait(mutex); //now the mutex should have value 0    if (instance_cnt==0) {      rt_sem_signal(mutex); //now the mutex should have vaule 1      rt_printk("worker thread busy!/n");    } else {      instance_cnt++;      rt_cond_signal(cond);      rt_sem_signal(mutex); //now the mutex should have vaule 1      rt_printk("signaling worker thread to start!/n");    }    cnt++;  }  // wait for end of program  printf("TYPE <ENTER> TO TERMINATE/n");  getchar();  // cleanup  stop_rt_timer();  return 0;}

int main(int argc, char *argv[]){	int fifo, period, skip, average = 0;	RT_TASK *task;	RTIME expected;        if ((fifo = open("/dev/rtf0", O_WRONLY)) < 0) {                printf("Error opening FIFO0 in UCAL/n");                exit(1);        } 	if (!(task = rt_task_init_schmod(nam2num("UCAL"), 0, 0, 0, SCHED_FIFO, 0xF))) {		printf("Cannot init UCAL/n");		exit(1);	}	rt_set_oneshot_mode();	period = start_rt_timer(nano2count(atoi(argv[1])));	mlockall(MCL_CURRENT | MCL_FUTURE);	rt_make_hard_real_time();	expected = rt_get_time() + 100*period;	rt_task_make_periodic(task, expected, period);	for (skip = 0; skip < atoi(argv[2]); skip++) {		expected += period;		rt_task_wait_period();		average += (int)count2nano(rt_get_time() - expected);	}	rt_make_soft_real_time();	stop_rt_timer();	rt_task_delete(task);	write(fifo, &average, sizeof(average));	close(fifo);	exit(0);}

int main(void){	RT_TASK *Main_Task;	long msg;	if (!(Main_Task = rt_thread_init(nam2num("MNTSK"), 10, 0, SCHED_FIFO, 0xF))) {		printf("CANNOT INIT MAIN TASK/n");		exit(1);	}	if (!(hard_timer_running = rt_is_hard_timer_running())) {		start_rt_timer(0);	}	barrier = rt_sem_init(nam2num("PREMS"), 4);	latency_thread = rt_thread_create(latency_fun, NULL, 0);	fast_thread    = rt_thread_create(fast_fun, NULL, 0);	slow_thread    = rt_thread_create(slow_fun, NULL, 0);	start = rt_get_time() + nano2count(200000000);	rt_sem_wait_barrier(barrier);	rt_receive(0, &msg);	end = 1;	rt_sem_wait_barrier(barrier);	rt_thread_join(latency_thread);	rt_thread_join(fast_thread);	rt_thread_join(slow_thread);	if (!hard_timer_running) {		stop_rt_timer();	}	rt_sem_delete(barrier);	rt_thread_delete(Main_Task);	return 0;}

int main(void){	RT_TASK *spktsk, *plrtsk;	RTIME period;	char buf[BUFSIZE], data, temp;	unsigned int msg, i, len;        printf("/n/nGENERIC RECEIVE/n");	ioperm(PORT_ADR, 1, 1);	iopl(3);        if (!(spktsk = rt_task_init_schmod(nam2num("SPKTSK"), 1, 0, 0, SCHED_FIFO, 0xF))) {                printf("CANNOT INIT SPEAKER TASK/n");                exit(1);        }	rt_set_oneshot_mode();	start_rt_timer(0);	mlockall(MCL_CURRENT | MCL_FUTURE);	printf("/nSPEAKER TASK RUNNING/n");	rt_make_hard_real_time();	period = nano2count(PERIOD);	rt_task_make_periodic(spktsk, rt_get_time() + 5*period, period);	rt_returnx(rt_receivex(0, &msg, sizeof(int), &len), &msg, 1);        for (i = 0; i < 100; i++) {		rt_returnx(rt_receivex(0, &msg, sizeof(int), &len), &msg, 1);        }	len = 0;	while(1) {		if (len) {			data = filter(buf[i++]);			temp = inb(PORT_ADR);            			temp &= 0xfd;			temp |= (data & 1) << 1;			outb(temp, PORT_ADR);			len--;		} else {			if (rt_evdrpx(0, buf, BUFSIZE, &i)) {//				rt_printk("EVDRP %d/n", i);			}			if ((plrtsk = rt_receivex_if(0, buf, BUFSIZE, &len))) {				rt_returnx(plrtsk, &len, sizeof(int));				if (len == sizeof(int) && ((int *)buf)[0] == 0xFFFFFFFF) {					break;				} 				i = 0;			}		}		rt_task_wait_period();	}	rt_sleep(nano2count(100000000));	rt_make_soft_real_time();	stop_rt_timer();	rt_task_delete(spktsk);	printf("/nSPEAKER TASK STOPS/n");	return 0;}

static void__latency_exit(void){	int cpuid;	/* If we started the timer we have to revert this now. */	if (start_timer) {		rt_reset_irq_to_sym_mode(TIMER_8254_IRQ);		stop_rt_timer();	}	/* Now delete our task and remove the FIFO. */	rt_task_delete(&thread);	rtf_destroy(DEBUG_FIFO);	/* Remove proc dir entry */#ifdef CONFIG_PROC_FS	remove_proc_entry("rtai/latency_calibrate", NULL);#endif	/* Output some statistics about CPU usage */	printk("/n/nCPU USE SUMMARY/n");	for (cpuid = 0; cpuid < NR_RT_CPUS; cpuid++) {		printk("# %d -> %d/n", cpuid, cpu_used[cpuid]);	}	printk("END OF CPU USE SUMMARY/n/n");}

void cleanup_module(void){	stop_rt_timer();	rt_busy_sleep(nano2count(TICK_PERIOD));        rt_qCleanup(&agentask);	rt_task_delete(&agentask);}

int main(void){	struct sched_param mysched;	mysched.sched_priority = sched_get_priority_max(SCHED_FIFO);	if( sched_setscheduler( 0, SCHED_FIFO, &mysched ) == -1 ) {		puts(" ERROR IN SETTING THE SCHEDULER UP");		perror("errno");		exit(0); 	}	rt_grow_and_lock_stack(20000);#ifdef ONE_SHOT	rt_set_oneshot_mode();#endif	start_rt_timer(nano2count(TICK_PERIOD));	firing_time = rt_get_time();	period = nano2count(1000000);	prt = rt_init_timer();	rt_insert_timer(prt, 1, firing_time, period, prh, 0, 1);	rt_tasklet_use_fpu(prt, 1);	seqt = rt_init_timer();	rt_insert_timer(seqt, 0, firing_time, 0, seqh, 0, 1);	while(!end) sleep(1);	stop_rt_timer();	rt_delete_timer(prt);	rt_delete_timer(seqt);	return 0;}

int main(void){	int i, srq, count = 0, nextcount = 0, repeat;	rt_thread_init(nam2num("MNTSK"), 100, 0, SCHED_FIFO, 0x1);	rt_printk("/nTESTING THE SCHEDULER WITH SRQs [%d LOOPs]./n", LOOPS);	repeat = 1000000000LL/((long long)DELAY*(long long)PRINT_FREQ);	srq = rtai_open_srq(0xcacca);	start_rt_timer(0);	rt_grow_and_lock_stack(100000);#ifdef MAKE_HARD	MAKE_HARD();#endif	for (i = 0; i < LOOPS; i++) {		rtai_srq(srq, (unsigned long)nano2count(DELAY));		if (++count > nextcount) {			nextcount += repeat;			rt_printk(">>> %d./n", nextcount);		}	}	rt_make_soft_real_time();	stop_rt_timer();        rt_task_delete(NULL);	rt_printk("END SCHEDULER TEST WITH SRQs./n/n");	return 0;}

void __exit cleanup_mod(void){    printk(KERN_INFO PFX "Stopping.../n");	//ecrt_slave_config_dc(sc,        0x000, 2000000, 125000, 0, 0);        //ecrt_slave_config_dc(sc2,       0x000, 2000000, 125000, 0, 0);	//if( ( inpu[0] == 0x1637 )  &&  ( inpu[2] == 0x1637 ) ){        //EC_WRITE_U16(domain1_pd+ctrl_word, 0x0002 );        //EC_WRITE_U16(domain1_pd+ctrl_word2, 0x0002 );        //}        //else if( ( inpu[0] == 0x0650 )  &&  ( inpu[2] == 0x0650 ) ){        //++deactive ;        //}    rt_task_delete(&task);    stop_rt_timer();    ecrt_release_master(master);    rt_sem_delete(&master_sem);    printk(KERN_INFO PFX "Unloading./n");}

int main(void){	RT_TASK *task;	signal(SIGTERM, catch_signal);	signal(SIGINT,  catch_signal); 	if (!(task = rt_thread_init(nam2num("SWITCH"), 0, 0, SCHED_FIFO, 0xF))) {		printf("CANNOT INIT SWITCH TASK SIGNAL/n");		exit(1);	}	start_rt_timer(0);	rt_request_signal(SWITCH_SIGNAL, switch_handler);	rt_task_signal_handler(task, (void *)SWITCH_SIGNAL);	rt_make_hard_real_time();	while (!end) {		rt_sleep(nano2count(PERIOD));	}	rt_task_signal_handler(task, NULL);	rt_release_signal(SWITCH_SIGNAL, task);	rt_make_soft_real_time();	stop_rt_timer();		rt_task_delete(task);	return 0;}

static __exit void hello_exit(void){    stop_rt_timer();    rt_busy_sleep(10000000);    rt_task_delete(&thread);	printk(KERN_ALERT "Q8 Test Module removed./n");}

void cleanup_module(void){	char msg[] = "let's end the game";	int i;	for (i = 0; i < NTASKS; i++) {		end = i;		rt_msg_send(rmbx[i], msg, sizeof(msg), 1);	}	current->state = TASK_INTERRUPTIBLE;	schedule_timeout(HZ);	for (i = 0; i < NTASKS; i++) {		rt_named_msgq_delete(rmbx[i]);		printk("TASK %d, LOOPS: %d./n", i, cnt[i]);	}	rt_named_msgq_delete(smbx);	stop_rt_timer();	rt_sem_delete(&barrier);	for (i = 0; i < NTASKS; i++) {		rt_task_delete(&mthread[i]);	}	printk("MODULE ENDS./n");}

void my_exit(void) {	int i;    stop_rt_timer();    for (i = 0 ; i < N_TASK ; i++) {        rt_task_delete(&tasks[i]);    }}

void cleanup_module(void){	stop_rt_timer();	rt_sem_delete(&mutex);	rt_task_delete(&taskl);	rt_task_delete(&taskm);	rt_task_delete(&taskh);}

void cleanup_module(void){	rtdm_task_destroy(&stask1);	rtdm_task_destroy(&stask2);	rtdm_sem_destroy(&sem1);    	rtdm_sem_destroy(&sem2);    	stop_rt_timer();}

void cleanup_module(void){    if (period)	stop_rt_timer();    rt_task_delete(&thread);    rt_spclose(rt_port);    printk("%s: RX%d Test unloaded./n", test_name, rt_port);}

void _rtapi_module_timer_stop(void) {    stop_rt_timer();#if RTAI_VERSION <= 400    rt_free_timer();#else    rt_free_timers();#endif}

void endme(int dummy){	rt_sem_delete(sem);	stop_rt_timer();	rt_task_delete(mytask);	signal(SIGINT, SIG_DFL);	exit(1);}

void cleanup_module(void){	int i;	rt_mbx_delete(&mbx);	for (i = 0; i <= NUM_TASKS; i++) {		rt_task_delete(&task[i]);	}	stop_rt_timer();}

int main(void){	double omega = (2.0*M_PI*SIN_FREQ*SAMP_TIME)/1.0E9;	RTIME until;	RT_TASK *task;	lsampl_t data[NCHAN*2];	long k, sinewave, retval = 0;	signal(SIGKILL, endme);	signal(SIGTERM, endme);	start_rt_timer(0);	task = rt_task_init_schmod(nam2num("MYTASK"), 1, 0, 0, SCHED_FIFO, 0xF);	printf("COMEDI CMD TEST BEGINS: SAMPLING FREQ: %d, RUN TIME: %d./n", SAMP_FREQ, RUN_TIME);	if (init_board()) {;		printf("Board initialization failed./n");		return 1;	}	do_cmd();	mlockall(MCL_CURRENT | MCL_FUTURE);	rt_make_hard_real_time();	until = rt_get_cpu_time_ns() + (long long)RUN_TIME*1000000000;	for (k = 0; k < SAMP_FREQ*RUN_TIME && !end; k++) {		sinewave =  (long)(maxdata/4*sin(k*omega));		data[0] = (lsampl_t)(  sinewave + maxdata/2);		data[1] = (lsampl_t)(- sinewave + maxdata/2);		while (rt_comedi_command_data_write(dev, subdev, NCHAN, data) != NCHAN) {			rt_sleep(nano2count(SAMP_TIME/2));		}		if (k == TRIGSAMP) {			rt_comedi_trigger(dev, subdev);		}	}	while (until > rt_get_cpu_time_ns()) {		rt_sleep(nano2count(100000));	}	comedi_cancel(dev, subdev);	comedi_close(dev);	comedi_data_write(dev, subdev, 0, 0, AREF_GROUND, 2048);	comedi_data_write(dev, subdev, 1, 0, AREF_GROUND, 2048);	printf("COMEDI TEST ENDS./n");	if (retval < 0) {		printf("rt_comedi_wait_timed overruns: %d/n", abs(retval));	}	stop_rt_timer();	rt_make_soft_real_time();	rt_task_delete(task);	return 0;}

void cleanup_module(void){	stop_rt_timer();	rt_task_delete(&rt_task);	rtf_destroy(PRINT);	rt_sem_delete(&tx_sem);  	rt_socket_close(sock);}

int main(void){	int i, indx[NTASKS];       	unsigned long mytask_name = nam2num("MASTER");	signal(SIGINT, endme); 	if (!(mytask = rt_task_init(mytask_name, 1, 0, 0))) {		printf("CANNOT INIT TASK %lu/n", mytask_name);		exit(1);	}	printf("MASTER INIT: name = %lu, address = %p./n", mytask_name, mytask);	sem = rt_sem_init(10000, 0); 	rt_set_oneshot_mode();//	rt_set_periodic_mode();	start_rt_timer(0);	for (i = 0; i < ntasks; i++) {		indx[i] = i;		if (!(task[i] = rt_thread_create(thread_fun, &indx[i], 10000))) {			printf("ERROR IN CREATING THREAD %d/n", indx[i]);			exit(1); 		}        	}       	for (i = 0; i < ntasks; i++) {		while (!rt_get_adr(taskname(i))) {			rt_sleep(nano2count(20000000));		}	}	for (i = 0; i < ntasks; i++) {		rt_send(rt_get_adr(taskname(i)), (unsigned long)sem);	}	for (i = 0; i < ntasks; i++) {		rt_sem_wait(sem);	}	for (i = 0; i < ntasks; i++) {		while (rt_get_adr(taskname(i))) {			rt_sleep(nano2count(20000000));		}	}	for (i = 0; i < ntasks; i++) {		rt_thread_join(task[i]);	}	rt_sem_delete(sem);	stop_rt_timer();	rt_task_delete(mytask);	printf("MASTER %lu %p ENDS/n", mytask_name, mytask);	return 0;}

void my_exit(void) {    int i;    stop_rt_timer();    for (i = 0 ; i < N_TASK ; i++) {        rt_task_delete(&tasks[i]);    }    rt_sem_delete(&semaphore1);    rt_sem_delete(&semaphore2);}

void tdma_release(void){#if defined(CONFIG_RTAI_24) || defined(CONFIG_RTAI_30)    if (start_timer)        stop_rt_timer();#endif    rtmac_disc_deregister(&tdma_disc);    printk("RTmac/TDMA: unloaded/n");}

int main(void){	int pid;	char ch;	char k = 'k';	RT_TASK *mytask;	MBX *Keyboard;	menu();	pid = fork();	if (!pid) {		execl("./screen", "./screen", NULL);	}	sleep(1); 	if (!(mytask = rt_task_init(nam2num("KBRTSK"), 10, 0, 0))) {		printf("CANNOT INIT KEYBOARD TASK/n");		exit(1);	} 	if (!(Keyboard = rt_get_adr(nam2num("KEYBRD")))) {		printf("CANNOT FIND KEYBOARD MAILBOX/n");		exit(1);	}	if (rt_mbx_send(Keyboard, &k, 1) > 0 ) {		fprintf(stderr, "Can't send initial command to RT-task/n");		exit(1);	}	do {		ch = get_key();		if (ch == 'p' || ch == 'P') {			menu();		}		if (ch != 'f' && rt_mbx_send_if(Keyboard, &ch, 1) > 0 ) {			fprintf(stderr, "Can't send command to RT-task/n");		}	} while (ch != 'f');	ch = 'r';	rt_mbx_send(Keyboard, &ch, 1);	ch = 'c';	rt_mbx_send(Keyboard, &ch, 1);	ch = 'f';	rt_mbx_send(Keyboard, &ch, 1);	rt_task_resume(rt_get_adr(nam2num("MASTER")));	while (rt_get_adr(nam2num("MASTER"))) {		rt_sleep(nano2count(1000000));	}	kill(pid, SIGINT);	rt_task_delete(mytask);	stop_rt_timer();	exit(0);}

void cleanup_module(void){    int i;    stop_rt_timer();    for (i = 0; i < NUM_CHILDREN; i++) {	rt_task_delete(&child_task[i]);    }    rt_busy_sleep(nano2count(TICK_PERIOD));    rt_task_delete(&parent_task);}