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"); }
void __exit cleanup_mod(void) { printk(KERN_INFO PFX "Stopping...\n"); 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) { 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); }