int __init hello_init(void) { RTIME sampling; rt_printk(KERN_INFO "TESTE - *************************** INICIO *******************************\n"); rt_task_init(&Task_1, signalIchi, 0, 3000, 0, 0, NULL); rt_task_init(&Task_2, signalNi, 0, 3000, 0, 0, NULL); rt_task_init(&Task_3, signalSan, 0, 3000, 0, 0, NULL); sampling = start_rt_timer(nano2count(TICK)); rt_sem_init(&rMutex, 1); rt_task_make_periodic(&Task_1, rt_get_time() + sampling * 16, sampling * 16); rt_task_make_periodic(&Task_2, rt_get_time() + sampling * 18, sampling * 18); rt_task_make_periodic(&Task_3, rt_get_time() + sampling * 30, sampling * 30); rt_change_prio(&Task_1, 2); rt_change_prio(&Task_2, 1); rt_change_prio(&Task_3, 3); rt_printk(KERN_INFO "Init module function\n"); return 0; }
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; }
void *init_task_1(void *arg) { unsigned long Task_1_name = nam2num("TASK_1"); //TODO:RAWLINSON if(!(Task_1 = rt_task_init_schmod(Task_1_name,1,0,0,SCHED_FIFO, CPU_ALLOWED))) { printf("[ERRO] Não foi possível criar a tarefa 1.\n"); exit(1); } rt_allow_nonroot_hrt(); rt_make_hard_real_time(); rt_task_make_periodic(Task_1, rt_get_time() + sampling * 5, sampling * 10); while (1) { time(&aclock); // Pega tempo em segundos. newtime = localtime(&aclock); printf("[TASK 1] =======> %s", asctime(newtime)); rt_task_wait_period(); } }
static int my_init(void) { int i, ierr1, ierr2; rt_typed_sem_init(&semaphore1, 0, BIN_SEM); rt_typed_sem_init(&semaphore2, 0, BIN_SEM); rt_set_oneshot_mode(); ierr1 = rt_task_init_cpuid(&tasks[0], task_body1, 0, STACK_SIZE, 1, 0, 0, 0); ierr2 = rt_task_init_cpuid(&tasks[1], task_body2, 0, STACK_SIZE, 0, 0, 0, 0); printk("[task 1] init return code %d by program %s\n", ierr1, __FILE__); printk("[task 2] init return code %d by program %s\n", ierr2, __FILE__); if (ierr1 == -1 || ierr2 == -1) { return -1; } start_rt_timer(nano2count(TICK_PERIOD)); first_release = rt_get_time(); for (i = 0 ; i < N_TASK ; i++) { rt_task_make_periodic(&tasks[i], first_release, PERIOD); } return 0; }
int realtime_on(void){ int retval; /*RT_TASK * rt_task_init_schmod(unsigned long name, int priority, int stack_size, int max_msg_size, int policy, int cpus_allowed)*/ if(!(task = rt_task_init_schmod(nam2num("TAREA11"), 1, 0, 0, SCHED_FIFO, 0xF))){ printf("rt_task_init_schmod error\n"); return -1; } mlockall( MCL_CURRENT | MCL_FUTURE ); printf("TAREAL EN TIEMPO REAL (name = %lu, address = %p)\n", nam2num("TAREA1"), task); rt_set_oneshot_mode(); task_period_count = nano2count(task_period_ns); timer_period_count = start_rt_timer(task_period_count);/*Inicia temporizador*/ printf("\tRequested %d counts, got %d counts\n",(int) task_period_count, (int) timer_period_count); retval = rt_task_make_periodic(task, rt_get_time() + task_period_count, task_period_count); /* recurring period */ if (0 != retval) { printf("rt_task_make_periodic error\n"); return -1; } rt_make_hard_real_time(); printf("\tPeriodo=%f\n\n",(double)task_period_ns/1e9); return 1; }
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; }
void *signalSan(void *arg) { RT_TASK *Task_3; unsigned long Task_3_name = nam2num("TSK_3") + i++; time_t aclock; time_t clockNow; int timeEx, begin_3; int count = 0; struct tm *newtime; Task_3 = rt_task_init(Task_3_name, 0, 0, 0); // if(!(Task_3 = rt_task_init_schmod(Task_3_name,3,0,0,SCHED_FIFO,1))) { // printf("CANNOT INIT HANDLER TASK > Task 3 <\n"); // exit(1); // } rt_allow_nonroot_hrt(); rt_make_hard_real_time(); rt_task_make_periodic(Task_3, rt_get_time(), sampling * 30); rt_change_prio(Task_3, 3); begin_3 = begin; while (count < 20) { rt_sem_wait(rMutex); time(&aclock); // Pega tempo em segundos. newtime = localtime(&aclock); printf(" Signal 3 =======> %s", asctime(newtime)); sleep(1); time(&aclock); // Pega tempo em segundos. newtime = localtime(&aclock); printf(" Signal 3 after Sleep =======> %s", asctime(newtime)); timeEx = 3600 * newtime->tm_hour + 60 * newtime->tm_min + newtime->tm_sec; if( (timeEx - begin_3) > 15 ) printf(" Time Failure of the Signal 3\n"); else printf(" Time Correct of the Signal 3\n"); begin_3 = timeEx + (15 - (timeEx-begin)%15); rt_sem_signal(rMutex); rt_task_wait_period(); count++; } rt_make_soft_real_time(); rt_task_delete(Task_3); return 0; }
int signal_func(void *param) { RT_TASK *rt_signal; //TODO: RTIME sampling; int value = 0; int rval = 0; char name[8]; t_info *t = param; snprintf(name, 8, "S_%c", t->id); printf("%s\n", name); rt_signal = rt_thread_init(nam2num(name), 0, 0, SCHED_FIFO, CPUMAP); if (!rt_signal) { printf("Could not init real time signal %c\n", t->id); rval = -ENODEV; goto exit; } rt_task_make_periodic(rt_signal, rt_get_time() + t->period + t->delay, t->period); while (!finish) { value = !value; printf("[%Ld] signal %c now in %s.\n", rt_get_time_ns(), t->id, value ? "up" : "down"); rt_task_wait_period(); } rt_task_delete(rt_signal); exit: pthread_exit(NULL); return rval; }
static int my_init(void) { int i; rt_set_oneshot_mode(); for (i = 0 ; i < N_TASK ; i++) { int ierr = rt_task_init_cpuid(&tasks[i], task_body, i, STACK_SIZE, Priority[i], 0, 0, 0); printk("[task %d] init return code %d by program %s\n", i, ierr, __FILE__); if (ierr == -1) { return ierr; } } start_rt_timer(nano2count(TICK_PERIOD)); time_unit = calibrate(); first_release = rt_get_time(); for (i = 0 ; i < N_TASK ; i++) { rt_task_make_periodic(&tasks[i], first_release, Period[i] * time_unit); } return 0; }
static void driver(int t) { RT_TASK *thread[NTASKS]; int i, l; unsigned int msg = 0; RTIME now; for (i = 1; i < NTASKS; i++) { thread[0] = rt_receive(0, &msg); thread[msg] = thread[0]; } for (i = 1; i < NTASKS; i++) { rt_return(thread[i], i); } now = rt_get_time(); rt_task_make_periodic(rt_whoami(), now + NTASKS*tick_period, tick_period); msg = 0; l = LOOPS; while(l--) { for (i = 1; i < NTASKS; i++) { cpu_used[hard_cpu_id()]++; if (i%2) { rt_rpc(thread[i], msg, &msg); } else { rt_send(thread[i], msg); msg = 1 - msg; } rt_task_wait_period(); } } for (i = 1; i < NTASKS; i++) { rt_send(thread[i], END); } }
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); }
static void *fast_fun(void *arg) { int jit, period; RTIME expected; if (!(Fast_Task = rt_thread_init(nam2num("FSTSK"), 2, 0, SCHED_FIFO, CPUMAP))) { printf("CANNOT INIT FAST TASK\n"); exit(1); } mlockall(MCL_CURRENT | MCL_FUTURE); rt_make_hard_real_time(); rt_sem_wait_barrier(barrier); period = nano2count(FASTMUL*TICK_TIME); expected = start + 6*nano2count(TICK_TIME); rt_task_make_periodic(Fast_Task, expected, period); while (!end) { jit = abs(count2nano(rt_get_time() - expected)); if (jit > fastjit) { fastjit = jit; } rt_busy_sleep((FASTMUL*TICK_TIME*USEDFRAC)/100); expected += period; END("FE\n"); rt_task_wait_period(); BEGIN("FB\n"); } rt_sem_wait_barrier(barrier); rt_make_soft_real_time(); rt_thread_delete(Fast_Task); return 0; }
int init_module (void) { RTIME tick_period; RTIME now; #ifdef SHM_DEBUG int size = SHMSIZ ; unsigned long vaddr, paddr; #endif shm = (int *)rtai_kmalloc(nam2num(SHMNAM), SHMSIZ); shm = (int *)rtai_kmalloc(nam2num(SHMNAM), SHMSIZ); shm = (int *)rtai_kmalloc(nam2num(SHMNAM), SHMSIZ); shm = (int *)rtai_kmalloc(nam2num(SHMNAM), SHMSIZ); if (shm == NULL) return -ENOMEM; memset(shm, 0, SHMSIZ); #ifdef SHM_DEBUG /* Show physical addresses of */ vaddr = (unsigned long)shm; while (size > 0) { paddr = kvirt_to_pa(vaddr); printk("vaddr=0x%lx paddr=0x%lx\n", vaddr, paddr); vaddr += PAGE_SIZE; size -= PAGE_SIZE; } #endif rt_task_init(&thread, fun, 0, STACK_SIZE, 0, 0, 0); tick_period = start_rt_timer(nano2count(TICK_PERIOD)); now = rt_get_time(); rt_task_make_periodic(&thread, now + tick_period, tick_period*PERIOD_COUNT); return 0; }
int init_module(void) { RTIME tick_period; int err; printk("%s: Loading RX%d Test module...\n", test_name, rt_port); err = rt_spopen(rt_port, line_param[0], line_param[1], line_param[2], line_param[3], line_param[4], line_param[5]); if (err) return err; /* Register error handler */ rt_spset_err_callback_fun(rt_port, error_handler); /* Start RX message handler */ rt_task_init(&thread, rx_handler, 0, STACK_SIZE, 0, 0, 0); rt_task_resume(&thread); rt_set_oneshot_mode(); if (period) { tick_period = start_rt_timer(nano2count(period)); rt_task_make_periodic(&thread, rt_get_time(), tick_period); } return 0; }
int init_module(void) { RTIME period; rt_task_init(&agentask, fun, 0, STACK_SIZE, 0, 0, 0); rt_set_oneshot_mode(); period = start_rt_timer((int) nano2count(TICK_PERIOD)); rt_task_make_periodic(&agentask, rt_get_time() + period, period); return 0; }
void *thread_fun(void *arg) { RTIME start_time, period; RTIME t0, t; SEM *sem; RT_TASK *mytask; unsigned long mytask_name; int mytask_indx, jit, maxj, maxjp, count; mytask_indx = *((int *)arg); mytask_name = taskname(mytask_indx); cpus_allowed = 1 - cpus_allowed; if (!(mytask = rt_task_init_schmod(mytask_name, 1, 0, 0, SCHED_FIFO, 1 << cpus_allowed))) { printf("CANNOT INIT TASK %lu\n", mytask_name); exit(1); } printf("THREAD INIT: index = %d, name = %lu, address = %p.\n", mytask_indx, mytask_name, mytask); mlockall(MCL_CURRENT | MCL_FUTURE); if (!(mytask_indx%2)) { rt_make_hard_real_time(); } rt_receive(0, (unsigned long *)((void *)&sem)); period = nano2count(PERIOD); start_time = rt_get_time() + nano2count(10000000); rt_task_make_periodic(mytask, start_time + (mytask_indx + 1)*period, ntasks*period); // start of task body { count = maxj = 0; t0 = rt_get_cpu_time_ns(); while(count++ < LOOPS) { rt_task_wait_period(); t = rt_get_cpu_time_ns(); if ((jit = t - t0 - ntasks*(RTIME)PERIOD) < 0) { jit = -jit; } if (count > 1 && jit > maxj) { maxj = jit; } t0 = t; // rtai_print_to_screen("THREAD: index = %d, count %d\n", mytask_indx, count); } maxjp = (maxj + 499)/1000; } // end of task body rt_sem_signal(sem); if (!(mytask_indx%2)) { rt_make_soft_real_time(); } rt_task_delete(mytask); printf("THREAD %lu ENDS, LOOPS: %d MAX JIT: %d (us)\n", mytask_name, count, maxjp); return 0; }
static void *latency_fun(void *arg) { struct sample { long min, max, avrg, jitters[2]; } samp; int diff; int skip; int average; int min_diff; int max_diff; int period; RT_TASK *chktsk; RTIME expected; min_diff = 1000000000; max_diff = -1000000000; if (!(Latency_Task = rt_thread_init(nam2num("PRETSK"), 0, 0, SCHED_FIFO, CPUMAP))) { printf("CANNOT INIT LATENCY TASK\n"); exit(1); } mlockall(MCL_CURRENT | MCL_FUTURE); rt_make_hard_real_time(); rt_sem_wait_barrier(barrier); period = nano2count(TICK_TIME); expected = start + 3*period; rt_task_make_periodic(Latency_Task, expected, period); while (!end) { average = 0; for (skip = 0; skip < NAVRG && !end; skip++) { expected += period; END("HE\n"); rt_task_wait_period(); BEGIN("HB\n"); diff = count2nano(rt_get_time() - expected); if (diff < min_diff) { min_diff = diff; } if (diff > max_diff) { max_diff = diff; } average += diff; } samp.min = min_diff; samp.max = max_diff; samp.avrg = average/NAVRG; samp.jitters[0] = fastjit; samp.jitters[1] = slowjit; if ((chktsk = rt_get_adr(nam2num("PRECHK")))) { rt_sendx_if(chktsk, &samp, sizeof(samp)); } } rt_sem_wait_barrier(barrier); rt_make_soft_real_time(); rt_thread_delete(Latency_Task); return 0; }
static int __latency_init(void) { /* XXX check option ranges here */ /* register a proc entry */ #ifdef CONFIG_PROC_FS create_proc_read_entry("rtai/latency_calibrate", /* name */ 0, /* default mode */ NULL, /* parent dir */ proc_read, /* function */ NULL /* client data */ ); #endif rtf_create(DEBUG_FIFO, 16000); /* create a fifo length: 16000 bytes */ rt_linux_use_fpu(use_fpu); /* declare if we use the FPU */ rt_task_init( /* create our measuring task */ &thread, /* poiter to our RT_TASK */ fun, /* implementation of the task */ 0, /* we could transfer data -> task */ 3000, /* stack size */ 0, /* priority */ use_fpu, /* do we use the FPU? */ 0 /* signal? XXX */ ); rt_set_runnable_on_cpus( /* select on which CPUs the task is */ &thread, /* allowed to run */ RUN_ON_CPUS ); /* Test if we have to start the timer */ if (start_timer || (start_timer = !rt_is_hard_timer_running())) { if (timer_mode) { rt_set_periodic_mode(); } else { rt_set_oneshot_mode(); } rt_assign_irq_to_cpu(TIMER_8254_IRQ, TIMER_TO_CPU); period_counts = start_rt_timer(nano2count(period)); } else { period_counts = nano2count(period); } loops = (1000000000*avrgtime)/period; /* Calculate the start time for the task. */ /* We set this to "now plus 10 periods" */ expected = rt_get_time() + 10 * period_counts; rt_task_make_periodic(&thread, expected, period_counts); return 0; }
static int __preempt_init(void) { RTIME start; rtf_create(FIFO, 1000); rt_linux_use_fpu(USE_FPU); rt_task_init_cpuid(&thread, fun, 0, 5000, 0, USE_FPU, 0, 0); rt_task_init_cpuid(&Fast_Task, Fast_Thread, 0, 5000, 1, 0, 0, 0); rt_task_init_cpuid(&Slow_Task, Slow_Thread, 0, 5000, 2, 0, 0, 0); #ifdef ONESHOT_MODE rt_set_oneshot_mode(); #endif period = start_rt_timer(nano2count(TICK_TIME)); expected = start = rt_get_time() + 100*period; rt_task_make_periodic(&thread, start, period); rt_task_make_periodic(&Fast_Task, start, FASTMUL*period); rt_task_make_periodic(&Slow_Task, start, SLOWMUL*period); return 0; }
int init_module(void) { rt_task_init(&thread, fun, 0, 3000, 0, 0, 0); rt_set_oneshot_mode(); period = start_rt_timer(nano2count(PERIOD)); expected = rt_get_time() + 10*period; rt_task_make_periodic(&thread, expected, period); // rt_printk("\n\n*** 'LATENCY_8254 IN USE %d", LATENCY_8254); printk("\n*** Wait %d seconds for it ... ***\n\n", (int)(((long long)SKIP*(long long)PERIOD)/1000000000)); return 0; }
static void *rt_BaseRate(void *args) { char name[7]; int i; static RTIME t0; for (i = 0; i < MAX_NTARGETS; i++) { sprintf(name,"BRT%d",i); if (!rt_get_adr(nam2num(name))) break; } if (!(rt_BaseRateTask = rt_task_init_schmod(nam2num(name), *((int *)args), 0, 0, SCHED_FIFO, CpuMap))) { fprintf(stderr,"Cannot init rt_BaseRateTask.\n"); return (void *)1; } sem_post(&err_sem); iopl(3); rt_task_use_fpu(rt_BaseRateTask, 1); MXmain(); grow_and_lock_stack(stackinc); if (UseHRT) { rt_make_hard_real_time(); } rt_rpc(rt_MainTask, 0, (void *)name); t0 = rt_get_cpu_time_ns(); rt_task_make_periodic(rt_BaseRateTask, rt_get_time() + rt_BaseRateTick, rt_BaseRateTick); while (!endBaseRate) { #ifdef TASKDURATION RTTSKper=rt_get_cpu_time_ns()-RTTSKinit; #endif WaitTimingEvent(TimingEventArg); if (endBaseRate) break; APPLICATION_Process_Event(TIME_EV); SIM_TIME = (rt_get_cpu_time_ns() - t0)*1.0E-9; #ifdef TASKDURATION RTTSKinit=rt_get_cpu_time_ns(); #endif } if (UseHRT) { rt_make_soft_real_time(); } rt_task_delete(rt_BaseRateTask); return 0; }
void parent_func(int arg) { int i; rt_printk("Starting parent task %d\n", arg); for (i = 0; i < NUM_CHILDREN; i++) { rt_task_init(&child_task[i], child_func, i, STACK_SIZE, PRIORITY, 0, 0); rt_set_task_trap_handler(&child_task[i], 14, my_trap_handler); rt_task_make_periodic(&child_task[i], rt_get_time() + period, period*i); } rt_task_suspend(rt_whoami()); }
int init_module(void) { RTIME tick_period; rtf_create_using_bh(CMDF, 4, 0); #ifdef ONE_SHOT rt_set_oneshot_mode(); #endif tick_period = start_rt_timer(nano2count(TICK_PERIOD)); rt_task_init(&thread, intr_handler, 0, STACK_SIZE, 0, 0, 0); rt_task_make_periodic(&thread, rt_get_time() + 2*tick_period, tick_period); return 0; }
int main(void) { RT_TASK *spktsk, *plrtsk; RTIME period; MBX *mbx; char data, temp; unsigned int msg, i; // 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); } mbx = rt_mbx_init(nam2num("SNDMBX"), 4000); printf("\nSPEAKER TASK RUNNING\n"); rt_set_oneshot_mode(); start_rt_timer(0); mlockall(MCL_CURRENT | MCL_FUTURE); rt_make_hard_real_time(); period = nano2count(PERIOD); rt_task_make_periodic(spktsk, rt_get_time() + 5*period, period); for (i = 0; i < 100; i++) { plrtsk = rt_receive(0, &msg); rt_return(plrtsk, msg); } while(1) { if (!rt_mbx_receive_if(mbx, &data, 1)) { data = filter(data); temp = inb(PORT_ADR); temp &= 0xfd; temp |= (data & 1) << 1; outb(temp, PORT_ADR); } rt_task_wait_period(); if ((plrtsk = rt_receive_if(0, &msg))) { rt_return(plrtsk, msg); break; } } rt_sleep(nano2count(100000000)); rt_make_soft_real_time(); rt_mbx_delete(mbx); stop_rt_timer(); rt_task_delete(spktsk); printf("\nSPEAKER TASK STOPS\n"); return 0; }
static void *intr_handler(void *args) { RT_TASK *mytask, *master; RTIME period; MBX *mbx; char data = 'G'; char temp; unsigned int msg; pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); // rt_allow_nonroot_hrt(); ioperm(PORT_ADR, 1, 1); if (!(mytask = rt_task_init_schmod(nam2num("SOUND"), 1, 0, 0, SCHED_FIFO, 0xF))) { printf("CANNOT INIT SOUND TASK\n"); exit(1); } mbx = rt_get_adr(nam2num("SNDMBX")); mlockall(MCL_CURRENT | MCL_FUTURE); printf("\nINIT SOUND TASK %p\n", mytask); rt_make_hard_real_time(); period = nano2count(PERIOD); rt_mbx_send(mbx, &data, 1); rt_task_make_periodic(mytask, rt_get_time() + 100*period, period); while(1) { if (!rt_mbx_receive_if(mbx, &data, 1)) { data = filter(data); temp = inb(PORT_ADR); temp &= 0xfd; temp |= (data & 1) << 1; outb(temp, PORT_ADR); } rt_task_wait_period(); if ((master = rt_receive_if(0, &msg))) { rt_return(master, msg); break; } } rt_make_soft_real_time(); rt_task_delete(mytask); printf("\nEND SOUND TASK %p\n", mytask); return 0; }
static int test_init(void) { int ierr; rt_set_oneshot_mode(); printk("PGM STARTING\n"); init_matrices(); // Create real-time tasks ierr = rt_task_init_cpuid(&sens_task, // task senscode, // rt_thread 0, // data STACK_SIZE, // stack_size 3, // priority 0, // uses_fpu 0, // signal 0); // cpuid ierr = rt_task_init_cpuid(&act_task, // task actcode, // rt_thread 0, // data STACK_SIZE, // stack_size 4, // priority 0, // uses_fpu 0, // signal 0); // cpuid // init semaphores rt_typed_sem_init(&sensDone, // semaphore pointer 0, // initial value BIN_SEM); // semaphore type if (!ierr) { start_rt_timer(nano2count(TICK_PERIOD)); now = rt_get_time(); // Start tasks rt_task_make_periodic(&sens_task, now, nano2count(PERIOD)); //rt_task_resume(&act_task); } //return ierr; return 0; // pour ne pas faire planter le kernel }
int _rtapi_task_start_hook(task_data *task, int task_id, unsigned long int period_nsec) { int retval; unsigned long int quo, period_counts; period_counts = nano2count((RTIME)period_nsec); quo = (period_counts + timer_counts / 2) / timer_counts; period_counts = quo * timer_counts; period_nsec = count2nano(period_counts); /* start the task */ retval = rt_task_make_periodic(ostask_array[task_id], rt_get_time() + period_counts, period_counts); if (retval != 0) { return -EINVAL; } return 0; }
static __init int hello_init(void) { RTIME tick_period; RTIME now; Q8_Initialise(0); // initialise Q8 Board 0 Q8_DACConfigure(0, 4, 1, 10); // configure the DAC: brd 0, channel 4, bipolar, 10V range Q8_EncInitialise(0,1,0,0,1,1,1); // configure the encoder: brd 0, encoder 1, single quad, index & polarity set rt_task_init(&thread, fun, 0, STACK_SIZE, PRIORITY, USE_FPU, NULL); // init the rt thread tick_period = start_rt_timer(nano2count(TICK_PERIOD)); // start the timer now = rt_get_time(); rt_task_make_periodic(&thread, now + tick_period, tick_period*PERIOD_COUNT); printk(KERN_ALERT "Q8 Test Module Running:\n"); printk(KERN_ALERT "DAC4 mirroring voltage on ADC0 + encoder value.\n"); return 0; }
static void* rt_system_thread(void * arg) { struct timeval tv; int64_t ts1, ts2; SEM * shm_sem; SEM * sync_sem; RT_TASK *task; M3EcSystemShm * sys = (M3EcSystemShm *)arg; printf("Starting real-time thread\n",0); RTIME t_last; int cntr=0; task = rt_task_init_schmod(nam2num("M3SYSP"), 0, 0, 0, SCHED_FIFO, 0xF); rt_allow_nonroot_hrt(); if (task==NULL) { printf("Failed to create RT-TASK M3SYSP\n",0); return 0; } shm_sem=(SEM*)rt_get_adr(nam2num(SEMNAM_M3LSHM)); if (!shm_sem) { printf("Unable to find the SEMNAM_M3LSHM semaphore.\n",0); rt_task_delete(task); return 0; } //else // printf("Allocated shm_sem semaphore %08x \n",shm_sem); sync_sem=(SEM*)rt_get_adr(nam2num(SEMNAM_M3SYNC)); if (!sync_sem) { printf("Unable to find the SEMNAM_M3SYNC semaphore.\n",0); rt_task_delete(task); rt_sem_delete(shm_sem); return 0; } //else // printf("Allocated sync_sem semaphore %08x \n",sync_sem); RTIME tick_period = nano2count(RT_TIMER_TICKS_NS); RTIME now = rt_get_time(); rt_task_make_periodic(task, now + tick_period, tick_period); mlockall(MCL_CURRENT | MCL_FUTURE); rt_make_hard_real_time(); t_last=now; sys_thread_active=1; uint64_t tl; while(!sys_thread_end) { rt_sem_wait(sync_sem); rt_sem_wait(shm_sem); if (cntr%200==0) { now=rt_get_time_ns(); float dt = (now-t_last)/1000000.0; count2timeval(nano2count(rt_get_real_time_ns()), &tv); printf("\n\nM3 Cycle: %d: 200 cycles in %4.3f ms. EC cycles: %d\n", cntr,dt, sys->counter); printf("DT: timestamp_dt (uS) : %lld\n",(sys->timestamp_ns-tl)/1000); t_last=now; SysEcShmPrettyPrint(sys); } tl=sys->timestamp_ns; cntr++; rt_sem_signal(shm_sem); rt_task_wait_period(); } printf("Exiting RealTime Thread...\n",0); rt_make_soft_real_time(); rt_task_delete(task); sys_thread_active=0; return 0; }
int main(int argc, char* argv[]) { unsigned long mtsk_name = nam2num("MTSK"); unsigned long btsk_name = nam2num("BTSK"); unsigned long sem_name = nam2num("SEM"); unsigned long smbx_name = nam2num("SMBX"); unsigned long rmbx_name = nam2num("RMBX"); unsigned long msg; long long mbx_msg; long long llmsg = 0xaaaaaaaaaaaaaaaaLL; RT_TASK *mtsk, *rcvd_from; SEM *sem; MBX *smbx, *rmbx; int pid, count; if (!(mtsk = rt_task_init_schmod(mtsk_name, 0, 0, 0, SCHED_FIFO, 0x1))) { printf("CANNOT INIT MASTER TASK\n"); exit(1); } printf("MASTER TASK INIT: name = %lx, address = %p.\n", mtsk_name, mtsk); printf("MASTER TASK STARTS THE ONESHOT TIMER\n"); rt_set_oneshot_mode(); start_rt_timer(nano2count(10000000)); mlockall(MCL_CURRENT | MCL_FUTURE); rt_make_hard_real_time(); rt_sleep(1000000); printf("MASTER TASK MAKES ITSELF PERIODIC WITH A PERIOD OF 1 ms\n"); rt_task_make_periodic(mtsk, rt_get_time(), nano2count(PERIOD)); rt_sleep(nano2count(1000000000)); count = PERIODIC_LOOPS; printf("MASTER TASK LOOPS ON WAIT_PERIOD FOR %d PERIODS\n", count); while(count--) { printf("PERIOD %d\n", count); rt_task_wait_period(); } count = SLEEP_LOOPS; printf("MASTER TASK LOOPS ON SLEEP 0.1 s FOR %d PERIODS\n", count); while(count--) { printf("SLEEPING %d\n", count); rt_sleep(nano2count(DELAY)); } printf("MASTER TASK YIELDS ITSELF\n"); rt_task_yield(); printf("MASTER TASK CREATES BUDDY TASK\n"); pid = fork(); if (!pid) { execl("./slave", "./slave", NULL); } printf("MASTER TASK SUSPENDS ITSELF, TO BE RESUMED BY BUDDY TASK\n"); rt_task_suspend(mtsk); printf("MASTER TASK RESUMED BY BUDDY TASK\n"); if (!(sem = rt_sem_init(sem_name, 0))) { printf("CANNOT CREATE SEMAPHORE %lx\n", sem_name); exit(1); } printf("MASTER TASK CREATES SEM: name = %lx, address = %p.\n", sem_name, sem); printf("MASTER TASK WAIT_IF ON SEM\n"); rt_sem_wait_if(sem); printf("MASTER STEP BLOCKS WAITING ON SEM\n"); rt_sem_wait(sem); printf("MASTER TASK SIGNALLED BY BUDDY TASK WAKES UP AND BLOCKS WAIT TIMED 1 s ON SEM\n"); rt_sem_wait_timed(sem, nano2count(1000000000)); printf("MASTER TASK DELETES SEM\n"); rt_sem_delete(sem); printf("MASTER TASK BLOCKS RECEIVING FROM ANY\n"); rcvd_from = rt_receive(0, (void *)&msg); printf("MASTER TASK RECEIVED MESSAGE %lx FROM BUDDY TASK\n", msg); printf("MASTER TASK RPCS TO BUDDY TASK THE MESSAGE %lx\n", 0xabcdefL); rcvd_from = rt_rpc(rcvd_from, 0xabcdef, (void *)&msg); printf("MASTER TASK RECEIVED THE MESSAGE %lx RETURNED BY BUDDY TASK\n", msg); //exit(1); if (!(smbx = rt_mbx_init(smbx_name, 1))) { printf("CANNOT CREATE MAILBOX %lx\n", smbx_name); exit(1); } if (!(rmbx = rt_mbx_init(rmbx_name, 1))) { printf("CANNOT CREATE MAILBOX %lx\n", rmbx_name); exit(1); } printf("MASTER TASK CREATED TWO MAILBOXES %p %p %p %p \n", smbx, rmbx, &mtsk_name, &msg); count = MBX_LOOPS; while(count--) { rt_mbx_send(smbx, &llmsg, sizeof(llmsg)); printf("%d MASTER TASK SENDS THE MESSAGE %llx MBX\n", count, llmsg); mbx_msg = 0; rt_mbx_receive_timed(rmbx, &mbx_msg, sizeof(mbx_msg), nano2count(MSG_DELAY)); printf("%d MASTER TASK RECEIVED THE MESSAGE %llx FROM MBX\n", count, mbx_msg); rt_sleep(nano2count(DELAY)); } printf("MASTER TASK SENDS THE MESSAGE %lx TO BUDDY TO ALLOW ITS END\n", 0xeeeeeeeeL); rt_send(rcvd_from, 0xeeeeeeee); printf("MASTER TASK WAITS FOR BUDDY TASK END\n"); while (rt_get_adr(btsk_name)) { rt_sleep(nano2count(1000000000)); } printf("MASTER TASK STOPS THE PERIODIC TIMER\n"); stop_rt_timer(); printf("MASTER TASK DELETES MAILBOX %p\n", smbx); rt_mbx_delete(smbx); printf("MASTER TASK DELETES MAILBOX %p\n", rmbx); rt_mbx_delete(rmbx); printf("MASTER TASK DELETES ITSELF\n"); rt_task_delete(mtsk); printf("END MASTER TASK\n"); return 0; }