static void *async_fun(void *args) { RT_TASK *asynctsk; if (!(asynctsk = rt_task_init_schmod(nam2num("ASYTSK"), 2, 0, 0, SCHED_FIFO, 0xF))) { printf("CANNOT INIT ASYNC TASK\n"); exit(1); } mlockall(MCL_CURRENT | MCL_FUTURE); while (!end) { if (SERVER) { unsigned long long retval; long i1, i2; int l1, l2; l1 = l2 = sizeof(long); rt_get_net_rpc_ret(mbx, &retval, &i1, &l1, &i2, &l2, 0LL, MBX_RECEIVE); printf("SERVER ASYNC MSG: RETVAL = %llu, MSG = %ld, LEN = %d.\n", retval, i1, l1); if (i1 < 0) { end = 1; break; } } else { rt_sleep(nano2count(100000000)); } } rt_task_delete(asynctsk); printf("\nASYNC SERVER TASK STOPS\n"); return (void *)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; }
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); }
void *thread_fun(void *arg) { funtask = rt_task_init_schmod(0xcaccb, 0, 0, 0, SCHED_FIFO, 0x1); rt_printk("FUN INIT\n"); mlockall(MCL_CURRENT | MCL_FUTURE); rt_make_hard_real_time(); if (!SNDBRCV) { rt_sleep(nano2count(100000000)); } if (USE_RPC) { unsigned long msg; rt_printk("FUN RPC\n"); rt_rpc(maintask, 0, &msg); } else { rt_printk("FUN SEND\n"); rt_send(maintask, 0); rt_printk("FUN SUSP\n"); rt_task_suspend(funtask); } rt_printk("FUN DONE\n"); rt_task_delete(funtask); rt_printk("FUN END\n"); 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(); } }
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; }
static void *logMsg_fun(void *args) { RT_TASK *buddy; struct { int nch; FILE *fs; } type; char msg[MAX_MSG_SIZE]; pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); if (!(buddy = rt_task_init_schmod(nam2num("LOGSRV"), 1, 0, 0, SCHED_FIFO, 0xFFFFFFFF))) { printf("CANNOT INIT LOG MSG SERVER BUDDY TASK %p.\n", buddy); return (void *)1; } rt_send(*(RT_TASK **)args, (unsigned int)buddy); while (1) { if (!rt_mbx_receive(logmbx, &type, sizeof(type)) && !rt_mbx_receive(logmbx, msg, type.nch)) { if (type.fs) { fprintf(type.fs, msg); } else { fprintf(stderr, msg); fprintf(logfile, msg); } } else { while(!rt_mbx_receive_wp(logmbx, msg, MAX_MSG_SIZE)); } } return (void *)0; }
//---------------------------------------------------------------------------- // real time task void writing_task_proc(void *arg) { #ifdef RTAI writing_task = rt_task_init_schmod(nam2num("WRTSK"),2, 0, 0, SCHED_FIFO, 0xF); rt_make_hard_real_time(); #endif while (1) { std::list<TPCANMsg>::iterator iter; for (iter = List->begin(); iter != List->end(); iter++) { // test for standard frames only if ((nExtended == CAN_INIT_TYPE_EX) || !(iter->MSGTYPE & MSGTYPE_EXTENDED)) { // send the message if ((errno = CAN_Write(h, &(*iter)))) shutdownnow = 1; } if (shutdownnow == 1) break; } if (shutdownnow == 1) break; } #ifdef RTAI rt_make_soft_real_time(); rt_task_delete(writing_task); #endif }
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[]) { unsigned int player, msg, spknode, spkport, i; RT_TASK *plrtsk, *spktsk; struct sockaddr_in addr; char data[BUFSIZE]; thread = rt_thread_create(endme, NULL, 2000); if ((player = open("../../../share/linux.au", O_RDONLY)) < 0) { printf("ERROR OPENING SOUND FILE (linux.au)\n"); exit(1); } if (!(plrtsk = rt_task_init_schmod(nam2num("PLRTSK"), 2, 0, 0, SCHED_FIFO, 0xF))) { printf("CANNOT INIT PLAYER TASK\n"); exit(1); } spknode = 0; if (argc == 2 && strstr(argv[1], "SpkNode=")) { inet_aton(argv[1] + 8, &addr.sin_addr); spknode = addr.sin_addr.s_addr; } if (!spknode) { inet_aton("127.0.0.1", &addr.sin_addr); spknode = addr.sin_addr.s_addr; } while ((spkport = rt_request_hard_port(spknode)) <= 0 && spkport != -EINVAL); rt_make_hard_real_time(); spktsk = RT_get_adr(spknode, spkport, "SPKTSK"); RT_rpcx(spknode, spkport, spktsk, &i, &msg, sizeof(int), sizeof(int)); for (i = 0; i < 100; i++) { RT_rpcx(spknode, spkport, spktsk, &i, &msg, sizeof(int), sizeof(int)); } mlockall(MCL_CURRENT | MCL_FUTURE); printf("\nPLAYER TASK RUNNING\n(TYPE ENTER TO END EVERYTHING)\n"); while (!end) { lseek(player, 0, SEEK_SET); while(!end && (i = read(player, data, BUFSIZE)) > 0) { RT_rpcx(spknode, spkport, spktsk, data, &msg, i, sizeof(int)); if (msg != i) { printf("SPEAKER RECEIVED LESS THAN SENT BY PLAYER\n"); } } } msg = 0xFFFFFFFF; RT_rpcx(spknode, spkport, spktsk, &msg, &msg, sizeof(int), 1); rt_make_soft_real_time(); rt_release_port(spknode, spkport); rt_task_delete(plrtsk); close(player); printf("PLAYER TASK STOPS\n"); return 0; }
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 *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; }
int init() { mlockall(MCL_CURRENT | MCL_FUTURE); /* Initialize LXRT */ #ifdef RTAI maint = rt_task_init_schmod(nam2num("MAINT"), 3, 0, 0, SCHED_FIFO, 0xF); #endif }
void *tx_thread(void *arg) { int fd=*((int*)arg); RT_TASK *task; int ret; int i; char dummy_data[10]; if (fd > 0) { ret = netlink_send(fd,NLCMD_INIT,10,&dummy_data[0]); printf("tx_thread starting, fd %d\n",fd); task = rt_task_init_schmod(nam2num("TASK1"), 0, 0, 0, SCHED_FIFO, 0xF); mlockall(MCL_CURRENT | MCL_FUTURE); // rt_make_hard_real_time(); while (!oai_exit) { if (tx_sdu_active == 1) printf("tx_thread: waiting (MBOX %d)\n",((unsigned int*)DAQ_MBOX)[0]); while(((volatile int)tx_sdu_active) != 0) { rt_sleep(nano2count(66666)); } printf("tx_thread: calling netlink\n"); ret = netlink_recv(fd,rxsdu); tx_sdu_active = 1; tx_sdu_length = ret; /* if (ret > 0) { printf("received TX SDU: "); for (i=0;i<ret;i++) { printf("%02hhx ",rxsdu[i]); } printf("\n"); } */ } } else { printf("tx_thread: no netlink\n"); } printf("tx_thread exiting\n"); return(0); }
int main(int argc, char *argv[]) { unsigned long msg; int prio, bprio; if (argc > 1) { USE_RPC = atoi(argv[1]); SNDBRCV = atoi(argv[2]); HARDMAIN = atoi(argv[3]); } if (!(maintask = rt_task_init_schmod(0xcacca, 1, 0, 0, SCHED_FIFO, 0x1))) { rt_printk("CANNOT INIT MAIN\n"); exit(1); } start_rt_timer(0); rt_printk("MAIN INIT\n"); pthread_create(&thread, NULL, thread_fun, NULL); mlockall(MCL_CURRENT | MCL_FUTURE); if (HARDMAIN) { rt_make_hard_real_time(); } rt_get_priorities(maintask, &prio, &bprio); rt_printk("TEST: %s, %s, %d\n", USE_RPC ? "WITH RPC" : "WITH SUSP/RESM", SNDBRCV ? "SEND BEFORE RECEIVE" : "RECEIVE BEFORE SEND", prio); if (SNDBRCV) { rt_sleep(nano2count(100000000)); } rt_get_priorities(maintask, &prio, &bprio); rt_printk("MAIN REC %d\n", prio); if (USE_RPC) { RT_TASK *task; task = rt_receive(0, &msg); rt_get_priorities(maintask, &prio, &bprio); rt_printk("MAIN RET %d\n", prio); rt_return(task, 0); } else { rt_receive(0, &msg); rt_get_priorities(maintask, &prio, &bprio); rt_printk("MAIN RES %d\n", prio); rt_task_resume(funtask); } rt_get_priorities(maintask, &prio, &bprio); rt_printk("MAIN DONE %d\n", prio); stop_rt_timer(); rt_task_delete(maintask); rt_printk("MAIN END\n"); 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; }
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; }
int main (void) { M3EcSystemShm * sys; RT_TASK *task; pthread_t ptsys; int cntr=0; signal(SIGINT, endme); sys = rtai_malloc (nam2num(SHMNAM_M3MKMD),1); if (sys==-1) { printf("Error allocating shared memory\n"); return 0; } int ns=sys->slaves_active; printf("Found %d active M3 EtherCAT slaves\n",ns); if (ns==0) { printf("No slaves available. Exiting...\n"); return 0; } rt_allow_nonroot_hrt(); if (!(task = rt_task_init_schmod(nam2num("M3MAIN"), RT_TASK_PRIORITY, 0, 0, SCHED_FIFO, 0xF))) { rt_shm_free(nam2num(SHMNAM_M3MKMD)); printf("Cannot init the RTAI task %s\n","M3MAIN"); return 0; } hst=rt_thread_create((void*)rt_system_thread, sys, 10000); usleep(100000); //Let start up if (!sys_thread_active) { rt_task_delete(task); rt_shm_free(nam2num(SHMNAM_M3MKMD)); printf("Startup of thread failed.\n",0); return 0; } while(!end) { //SysEcShmPrettyPrint(sys); usleep(250000); } printf("Removing RT thread...\n",0); sys_thread_end=1; rt_thread_join(hst); if (sys_thread_active)printf("Real-time thread did not shutdown correctly\n"); rt_task_delete(task); rt_shm_free(nam2num(SHMNAM_M3MKMD)); return 0; }
int main(void) { RT_TASK *mytask; MBX *Keyboard, *Screen; unsigned int i; char d = 'd'; char chain[12]; char displine[40] = "CLOCK-> 00:00:00 CHRONO-> 00:00:00"; signal(SIGINT, endme); if (!(mytask = rt_task_init_schmod(nam2num("SCRTSK"), 20, 0, 0, SCHED_FIFO, 0xF))) { printf("CANNOT INIT SCREEN TASK\n"); exit(1); } if (!(Keyboard = rt_get_adr(nam2num("KEYBRD")))) { printf("CANNOT FIND KEYBOARD MAILBOX\n"); exit(1); } if (rt_mbx_send(Keyboard, &d, 1) > 0 ) { fprintf(stderr, "Can't send initial command to RT-task\n"); exit(1); } if (!(Screen = rt_get_adr(nam2num("SCREEN")))) { printf("CANNOT FIND SCREEN MAILBOX\n"); exit(1); } sleep(1); printf("%s\n", displine); while(1) { if (rt_mbx_receive(Screen, chain, 12)) break; if (chain[0] == 't') { for (i = 0; i < 11; i++) { displine[i+27] = chain[i+1]; } } else if (chain[0] == 'h') { for (i = 0; i < 8; i++) { displine[i+8] = chain[i+1]; } } printf("%s\n", displine); } rt_task_delete(mytask); return 0; }
int main(int argc, char *argv[]) { unsigned long rcvnode; RT_TASK *sndtsk, *rcvtsk; MBX *mbx; long rcvport, i; struct sockaddr_in addr; thread = rt_thread_create(endme, NULL, 2000); if (!(sndtsk = rt_task_init_schmod(nam2num("SNDTSK"), 1, 0, 0, SCHED_FIFO, 0xF))) { printf("CANNOT INIT SENDER TASK\n"); exit(1); } rcvnode = 0; if (argc == 2 && strstr(argv[1], "RcvNode=")) { inet_aton(argv[1] + 8, &addr.sin_addr); rcvnode = addr.sin_addr.s_addr; } if (!rcvnode) { inet_aton("127.0.0.1", &addr.sin_addr); rcvnode = addr.sin_addr.s_addr; } mbx = rt_mbx_init(nam2num("SNDMBX"), 500); while ((rcvport = rt_request_port(rcvnode)) <= 0 && rcvport != -EINVAL); printf("\nSENDER TASK RUNNING\n"); mlockall(MCL_CURRENT | MCL_FUTURE); rt_make_hard_real_time(); for (i = 0; i < MAXLOOPS && !end; i++) { rt_mbx_send(mbx, &i, sizeof(long)); rt_printk("SENT %ld\n", i); RT_sleep(rcvnode, rcvport, 200000000); } i = -1; rt_mbx_send(mbx, &i, sizeof(long)); rt_make_soft_real_time(); while (!(rcvtsk = RT_get_adr(rcvnode, rcvport, "RCVTSK"))) { RT_sleep(rcvnode, rcvport, 100000000); } RT_rpc(rcvnode, rcvport, rcvtsk, i, &i); rt_release_port(rcvnode, rcvport); rt_mbx_delete(mbx); rt_task_delete(sndtsk); printf("\nSENDER 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 void *Task2(void *arg) { RT_TASK *t2; int status; MSG buf; t2 = rt_task_init_schmod(nam2num("T2"), BASE_PRIO + 3, 0, 0, SCHED_FIFO, 0xF); printf("\nTask2 (%p) starting\n", t2); mlockall(MCL_CURRENT | MCL_FUTURE); while (!endall) { memset((char*)&buf, 0, sizeof(buf)); status = rt_tbx_receive(bx, (char*)&buf, sizeof(buf)); printf("\nTask2 received msgnr %u from task %u, status=%d\n", buf.progressive, buf.sending_task, status); } printf("\nTask2 ends itself\n"); return 0; }
int StartMainTask( int priority) { //function to start a real time task with the given priority //StartMainTask is designed to be called from the Pascal Program to start the Main (i.e., Pascal) rt program if(!(GlobalTask = rt_task_init_schmod(nam2num( "SomeTask" ), // Name priority, // Priority 0, // Stack Size 0, //, // max_msg_size SCHED_FIFO, // Policy CPUMAP ))) // cpus_allowed { return 1; } else { return 0; } }
int main(void) { RT_TASK *sending_task ; SEM *shmsem, *agentsem; int i, *shm, shm_size, count; unsigned long chksum; sending_task = rt_task_init_schmod(nam2num("STSK"), 0, 0, 0, SCHED_FIFO, 0xF); mlockall(MCL_CURRENT | MCL_FUTURE); rt_make_hard_real_time(); shmsem = rt_get_adr(nam2num("SHSM")); agentsem = rt_get_adr(nam2num("AGSM")); shm = rt_shm_alloc(nam2num("MEM"), 0, 0); shm_size = shm[0]; count = COUNT; while(count--) { printf("SENDING TASK WAIT ON SHMSEM\n"); rt_sem_wait(shmsem); printf("SENDING TASK SIGNALLED ON SHMSEM\n"); if (!(shm[0] = ((float)rand()/(float)RAND_MAX)*shm_size) || shm[0] > shm_size) { shm[0] = shm_size; } chksum = 0; for (i = 1; i <= shm[0]; i++) { shm[i] = rand(); chksum += shm[i]; } shm[shm[0] + 1] = chksum; printf("STSK: %d CHECKSUM = %lx\n", count, chksum); printf("SENDING TASK SIGNAL AGENTSEM\n"); rt_sem_signal(agentsem); } printf("SENDING TASK LAST WAIT ON SHMSEM\n"); rt_sem_wait(shmsem); printf("SENDING TASK SIGNALLED ON SHMSEM\n"); shm[0] = 0; printf("SENDING TASK LAST SIGNAL TO AGENTSEM\n"); rt_sem_signal(agentsem); printf("SENDING TASK DELETES ITSELF\n"); rt_task_delete(sending_task); printf("END SENDING TASK\n"); return 0; }
int main(void) { int i, k, prio, bprio; task[0] = rt_task_init_schmod(0, NTASKS - 1, 0, 0, SCHED_FIFO, CPUS_ALLOWED); mlockall(MCL_CURRENT | MCL_FUTURE); rt_make_hard_real_time(); for (i = 0; i < NTASKS; i++) { sem[i] = rt_typed_sem_init(0, RESEMT, RES_SEM); } rt_sem_wait(sem[0]); for (i = 1; i < NTASKS; i++) { rt_thread_create(tskfun, (void *)i, 0); rt_receive(NULL, &k); rt_printk("AFTER TSKNR %d CREATED > (TSKNR-PRI):\n", i); for (k = 0; k < i; k++) { rt_get_priorities(task[k], &prio, &bprio); rt_printk("%d-%d|", k, prio); } rt_get_priorities(task[i], &prio, &bprio); rt_printk("%d-%d\n\n", i, prio); } rt_sem_signal(sem[0]); rt_printk("FINAL > (TSKNR-PRI):\n"); for (k = 0; k < (NTASKS - 1); k++) { rt_get_priorities(task[k], &prio, &bprio); rt_printk("%d-%d|", k, prio); } rt_get_priorities(task[NTASKS - 1], &prio, &bprio); rt_printk("%d-%d\n\n", (NTASKS - 1), prio); for (i = 0; i < NTASKS; i++) { rt_sem_delete(sem[i]); } return 0; }
static void *Task1(void *arg) { RT_TASK *t1; int unsent; MSG msg; t1 = rt_task_init_schmod(nam2num("T1"), BASE_PRIO + 1, 0, 0, SCHED_FIFO, 0xF); printf("\nTask1 (%p) starting\n", t1); mlockall(MCL_CURRENT | MCL_FUTURE); while (count < MAXCOUNT) { count++; msg.progressive = count; msg.sending_task = 1; unsent = rt_tbx_send(bx, (char*)&msg, sizeof(msg)); printf("\nTask1=%lu, simple sending, unsent=%d\n", count, unsent); rt_sleep(nano2count(DELAY)); } rt_task_delete(t1); printf("\nTask1 ends itself\n"); return 0; }
static void *Task7(void *arg) { RT_TASK *t7; int unsent; MSG msg; t7 = rt_task_init_schmod(nam2num("T7"), BASE_PRIO + 0, 0, 0, SCHED_FIFO, 0xF); printf("\nTask7 (%p) starting\n", t7); mlockall(MCL_CURRENT | MCL_FUTURE); while (count < MAXCOUNT) { count++; msg.progressive = count; msg.sending_task = 7; unsent = rt_tbx_urgent(bx, (char*)&msg, sizeof(msg)); printf("\nTask7=%lu, urgent sending, unsent=%d\n", count, unsent); rt_sleep(nano2count(3*DELAY + 2*SHIFT)); } rt_task_delete(t7); printf("\nTask7 ends itself\n"); return 0; }
static void *Task4(void *arg) { RT_TASK *t4; int wakedup; MSG msg; t4 = rt_task_init_schmod(nam2num("T4"), BASE_PRIO + 6, 0, 0, SCHED_FIFO, 0xF); printf("\nTask4 (%p) starting\n", t4); mlockall(MCL_CURRENT | MCL_FUTURE); while (count < MAXCOUNT) { count++; msg.progressive = count; msg.sending_task = 4; wakedup = rt_tbx_broadcast(bx, (char*)&msg, sizeof(msg)); printf("\nTask4=%lu, sent broadcast, wakedup=%d\n", count, wakedup); rt_sleep(nano2count(DELAY + SHIFT)); } rt_task_delete(t4); printf("\nTask4 ends itself\n"); return 0; }
void *tskfun(void *tasknr) { int tsknr, k, prio, bprio; tsknr = (int)tasknr; task[tsknr] = rt_task_init_schmod(0, NTASKS - tsknr - 1, 0, 0, SCHED_FIFO, CPUS_ALLOWED); mlockall(MCL_CURRENT | MCL_FUTURE); rt_make_hard_real_time(); rt_sem_wait(sem[tsknr]); rt_send(task[0], 0); rt_sem_wait(sem[tsknr - 1]); rt_sem_signal(sem[tsknr]); rt_sem_signal(sem[tsknr - 1]); rt_printk("AT TSKNR EXIT %d > (TSKNR-PRI):\n", tsknr); for (k = 0; k < tsknr; k++) { rt_get_priorities(task[k], &prio, &bprio); rt_printk("%d-%d|", k, prio); } rt_get_priorities(task[tsknr], &prio, &bprio); rt_printk("%d-%d\n\n", tsknr, prio); return NULL; }
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; }