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; }
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); }
int main(void) { RT_TASK *sending_task ; SEM *shmsem, *agentsem; int i, *shm, shm_size, count; unsigned long chksum; struct sched_param mysched; mysched.sched_priority = 99; if( sched_setscheduler( 0, SCHED_FIFO, &mysched ) == -1 ) { puts(" ERROR IN SETTING THE SCHEDULER UP"); perror( "errno" ); exit( 0 ); } mlockall(MCL_CURRENT | MCL_FUTURE); sending_task = rt_task_init(nam2num("STSK"), 0, 0, 0); shmsem = rt_get_adr(nam2num("SHSM")); agentsem = rt_get_adr(nam2num("AGSM")); shm = rtai_malloc(nam2num("MEM"), 1); 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; }
void CommandClock_Get(char *command) { static RT_TASK *ackn = 0; unsigned int get = 'b'; unsigned long msg; if (ackn != rt_get_adr(nam2num("CLKTSK"))) { ackn = rt_rpc(rt_get_adr(nam2num("CLKTSK")), get, &msg); } rt_receive(rt_get_adr(nam2num("CLKTSK")), &msg); *command = (char)msg; }
void Display_Get(MenageHmsh_tChain11 *chain, Display_tDest *receiver) { static RT_TASK *ackn = 0; unsigned int get = 'g'; unsigned long msg; if (ackn != rt_get_adr(nam2num("DSPTSK"))) { ackn = rt_rpc(rt_get_adr(nam2num("DSPTSK")), get, &msg); } rt_receive(rt_get_adr(nam2num("DSPTSK")), &msg); *chain = *((MenageHmsh_tChain11 *)msg); *receiver = chain->chain[0] == 't' ? destChrono : destClock; }
void CommandClock_Put(char command) { static RT_TASK *ackn = 0; unsigned int put = 'a'; unsigned long msg; if (ackn != rt_get_adr(nam2num("CLKTSK"))) { ackn = rt_rpc(rt_get_adr(nam2num("CLKTSK")), put, &msg); } if (((Clockstatus == running) == (command == 'T')) || command == 'F') { rt_send(rt_get_adr(nam2num("CLKTSK")), (unsigned int)command); } }
void Display_PutHour(MenageHmsh_tChain11 chain) { static MenageHmsh_tChain11 hours; static RT_TASK *ackn = 0; unsigned int put = 'p'; unsigned long msg; if (ackn != rt_get_adr(nam2num("DSPTSK"))) { ackn = rt_rpc(rt_get_adr(nam2num("DSPTSK")), put, &msg); } hours = chain; hours.chain[0] = 'h'; rt_send_if(rt_get_adr(nam2num("DSPTSK")), (unsigned long)hours.chain); }
void Display_PutTimes(MenageHmsh_tChain11 chain) { static MenageHmsh_tChain11 times; static RT_TASK *ackn = 0; unsigned int put = 'P'; unsigned long msg; if (ackn != rt_get_adr(nam2num("DSPTSK"))) { ackn = rt_rpc(rt_get_adr(nam2num("DSPTSK")), put, &msg); } times = chain; times.chain[0] = 't'; rt_send_if(rt_get_adr(nam2num("DSPTSK")), (unsigned long)times.chain); }
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(void) { pthread_t thread; unsigned int player, cnt; unsigned long msg; RT_TASK *mytask; MBX *mbx; char data[BUFSIZE]; signal(SIGINT, endme); rt_allow_nonroot_hrt(); if ((player = open("../../../share/linux.au", O_RDONLY)) < 0) { printf("ERROR OPENING SOUND FILE (linux.au)\n"); exit(1); } if (!(mytask = rt_task_init(nam2num("SNDMAS"), 2, 0, 0))) { printf("CANNOT INIT MASTER TASK\n"); exit(1); } mlockall(MCL_CURRENT | MCL_FUTURE); printf("\nINIT MASTER TASK %p\n\n(CTRL-C TO END EVERYTHING)\n", mytask); mbx = rt_typed_named_mbx_init("SNDMBX", 2000, FIFO_Q); rt_set_oneshot_mode(); start_rt_timer(0); thread = rt_thread_create(intr_handler, NULL, 10000); rt_mbx_receive(mbx, &data, 1); while (!end) { lseek(player, 0, SEEK_SET); while(!end && (cnt = read(player, &data, BUFSIZE)) > 0) { rt_mbx_send(mbx, data, cnt); } } rt_rpc(rt_get_adr(nam2num("SOUND")), msg, &msg); while (rt_get_adr(nam2num("SOUND"))) { rt_sleep(nano2count(1000000)); } rt_task_delete(mytask); rt_mbx_delete(mbx); stop_rt_timer(); close(player); printf("\nEND MASTER TASK %p\n", mytask); rt_thread_join(thread); return 0; }
static void mdlStart(SimStruct *S) { #ifndef MATLAB_MEX_FILE char name[7]; MBX *mbx; int i; #ifdef KRTAI i = mbx_rt_get_adr(TargetLedMbxID, MAX_RTAI_LEDS); sprintf(name, "%s%d", TargetLedMbxID, i); rtaiLed[i] = S; mbx = mbx_rt_mbx_init(name, (MBX_RTAI_LED_SIZE/(sizeof(unsigned int))*(sizeof(unsigned int)))); #else for (i = 0; i < MAX_RTAI_LEDS; i++) { sprintf(name, "%s%d", TargetLedMbxID, i); if (!rt_get_adr(nam2num(name))) break; } rtaiLed[i] = S; if (!(mbx = (MBX *)rt_mbx_init(nam2num(name), (MBX_RTAI_LED_SIZE/(sizeof(unsigned int))*(sizeof(unsigned int)))))) { printf("Cannot init mailbox\n"); exit(1); } #endif ssGetPWork(S)[0]= (void *)mbx; #endif }
static RTAI_SYSCALL_MODE void rt_set_heap(unsigned long name, void *adr) { void *heap, *hptr; int size; RT_TASK *task; heap = rt_get_adr(name); hptr = ALIGN2PAGE(heap); size = ((abs(rt_get_type(name)) - sizeof(rtheap_t) - (hptr - heap)) & PAGE_MASK); heap = hptr + size; if (!atomic_cmpxchg((atomic_t *)hptr, 0, name)) { rtheap_init(heap, hptr, size, PAGE_SIZE, 0); } RTAI_TASK(return); if (name == GLOBAL_HEAP_ID) { task->heap[GLOBAL].heap = &rtai_global_heap; task->heap[GLOBAL].kadr = rtai_global_heap_adr; task->heap[GLOBAL].uadr = adr; } else { task->heap[SPECIFIC].heap = heap; task->heap[SPECIFIC].kadr = hptr; task->heap[SPECIFIC].uadr = adr; } }
static void mdlStart(SimStruct *S) { #ifndef MATLAB_MEX_FILE MBX *mbx; char name[7]; int i; int_T *dim = ssGetInputPortDimensions(S,0); #ifdef KRTAI i = mbx_rt_get_adr(TargetLogMbxID,MAX_RTAI_LOGS); sprintf(name, "%s%d", TargetLogMbxID, i); rtaiLog[i] = S; mbx = mbx_rt_mbx_init(name, (MBX_RTAI_LOG_SIZE/(dim[0]*dim[1]*sizeof(float))*(dim[0]*dim[1]*sizeof(float)))); #else for (i = 0; i < MAX_RTAI_LOGS; i++) { sprintf(name, "%s%d", TargetLogMbxID, i); if (!rt_get_adr(nam2num(name))) break; } rtaiLog[i] = S; if (!(mbx = (MBX *)rt_mbx_init(nam2num(name), (MBX_RTAI_LOG_SIZE/(dim[0]*dim[1]*sizeof(float))*(dim[0]*dim[1]*sizeof(float)))))) { printf("Cannot init mailbox\n"); exit(1); } #endif ssGetPWork(S)[0] = (void *)mbx; #endif }
INTERNAL_QUAL int rtos_task_create(RTOS_TASK* task, int priority, const char* name, int sched_type, size_t stack_size, void * (*start_routine)(void *), ThreadInterface* obj) { char taskName[7]; if ( strlen(name) == 0 ) name = "Thread"; strncpy(taskName, name, 7); unsigned long task_num = nam2num( taskName ); if ( rt_get_adr(nam2num( taskName )) != 0 ) { unsigned long nname = nam2num( taskName ); while ( rt_get_adr( nname ) != 0 ) // check for existing 'NAME' ++nname; num2nam( nname, taskName); // set taskName to new name taskName[6] = 0; task_num = nname; } // Set and truncate name task->name = strcpy( (char*)malloc( (strlen(name)+1)*sizeof(char) ), name); // name, priority, stack_size, msg_size, policy, cpus_allowed ( 1111 = 4 first cpus) // Set priority task->priority = priority; // Set rtai task struct to zero task->rtaitask = 0; RTAI_Thread* rt = (RTAI_Thread*)malloc( sizeof(RTAI_Thread) ); rt->priority = priority; rt->data = obj; rt->wrapper = start_routine; rt->task = task; rt->tnum = task_num; int retv = pthread_create(&(task->thread), 0, rtai_thread_wrapper, rt); // poll for thread creation to be done. int timeout = 0; while ( task->rtaitask == 0 && ++timeout < 20) usleep(100000); return timeout < 20 ? retv : -1; }
void cleanRosBlock(unsigned int num) { SEM *sem; rt_shm_free(nam2num(rosBlockConfigs[num].shmName)); sem = (SEM*)rt_get_adr(nam2num(rosBlockConfigs[num].semName)); rt_sem_broadcast(sem); rt_sem_delete(sem); }
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; }
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 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; }
char *get_a_name(const char *root, char *name) { unsigned long i; for (i = 0; i < MAX_ADR_SRCH; i++) { sprintf(name, "%s%ld", root, i); if (!rt_get_adr(nam2num(name))) { return name; } } return 0; }
static int rtai_shm_f_mmap(struct file *file, struct vm_area_struct *vma) { unsigned long name; int size; if (!vma->vm_ops) { vma->vm_ops = &rtai_shm_vm_ops; vma->vm_flags |= VM_LOCKED; name = (unsigned long)(vma->vm_private_data = current->rtai_tskext(TSKEXT1)); current->rtai_tskext(TSKEXT1) = current->rtai_tskext(TSKEXT0) ? current : NULL; return (size = rt_get_type(name)) < 0 ? rkmmap(ALIGN2PAGE(rt_get_adr(name)), -size, vma) : rvmmap(rt_get_adr(name), size, vma); } return -EFAULT; }
int main(void) { fd_set input; struct timeval tv; unsigned int msg, ch; MBX *mbx; struct sample { long long min; long long max; int index; double s; int ts; } samp; tv.tv_sec = 0; if (!(task = rt_task_init(nam2num("LATCHK"), 20, 0, 0))) { printf("CANNOT INIT MASTER TASK\n"); exit(1); } if (!(mbx = rt_get_adr(nam2num("LATMBX")))) { printf("CANNOT FIND MAILBOX\n"); exit(1); } while (1) { rt_mbx_receive(mbx, &samp, sizeof(samp)); printf("*** min: %d, max: %d average: %d, dot %f ts %d (ent ends check, a/ent both) ***\n", (int) samp.min, (int) samp.max, samp.index, samp.s, samp.ts); FD_ZERO(&input); FD_SET(0, &input); tv.tv_usec = 20000; if (select(1, &input, NULL, NULL, &tv)) { ch = getchar(); break; } } if (ch == 'a') { rt_rpc(rt_get_adr(nam2num("LATCAL")), msg, &msg); } rt_task_delete(task); exit(0); }
rosBlockInitResult_t registerRosBlock(SimStruct *S, char *rosName, int type, int subType) { char name[7]; int_T i; int num = numRosBlocks; rosBlockInitResult_t res; rosBlockConfigs[num].S = S; memcpy(rosBlockConfigs[num].name, rosName, MAX_NAMES_SIZE); rosBlockConfigs[num].type = type; rosBlockConfigs[num].subType = subType; for (i = 0; i < MAX_ROS_BLOCKS; i++) { sprintf(name, "%s%d", RosShmID, i); if (!rt_get_adr(nam2num(name))) break; } if (!(res.shm = (rosShmData_t *)rt_shm_alloc(nam2num(name), sizeof(rosShmData_t), USE_VMALLOC))) { printf("Cannot init shared memory %s: Time to die!\n", name); exit(1); } memcpy(rosBlockConfigs[num].shmName, name, 7); for (i = 0; i < MAX_ROS_BLOCKS; i++) { sprintf(name, "%s%d", RosSemID, i); if (!rt_get_adr(nam2num(name))) break; } if (!(res.sem = rt_typed_sem_init(nam2num(name), 1, BIN_SEM | PRIO_Q))) { printf("Cannot init semaphore %s: Time to kill myself!\n", name); exit(1); } memcpy(rosBlockConfigs[num].semName, name, 7); res.shm->length = 0; res.shm->state = 0; res.shm->msg.state = 0; res.num = num; numRosBlocks++; return res; }
RTAI_SYSCALL_MODE void *rt_bits_init_u(unsigned long name, unsigned long mask) { BITS *bits; if (rt_get_adr(name)) { return NULL; } if ((bits = rt_malloc(sizeof(BITS)))) { rt_bits_init(bits, mask); if (rt_register(name, bits, IS_BIT, current)) { return bits; } else { rt_free(bits); } } return NULL; }
int main(void) { RT_TASK *receiving_task; RT_TASK *agentask; int i, *shm; unsigned int msg, chksum; struct sched_param mysched; mysched.sched_priority = 99; if( sched_setscheduler( 0, SCHED_FIFO, &mysched ) == -1 ) { puts(" ERROR IN SETTING THE SCHEDULER UP"); perror( "errno" ); exit( 0 ); } mlockall(MCL_CURRENT | MCL_FUTURE); receiving_task = rt_task_init(nam2num("RTSK"), 0, 0, 0); agentask = rt_get_adr(nam2num("ATSK")); shm = rtai_malloc(nam2num("MEM"), 1); while(1) { printf("RECEIVING TASK RPCS TO AGENT TASK %x\n", 0xaaaaaaaa); rt_rpc(agentask, 0xaaaaaaaa, &msg); printf("AGENT TASK RETURNED %x\n", msg); if (msg != 0xeeeeeeee) { chksum = 0; for (i = 1; i <= shm[0]; i++) { chksum += shm[i]; } printf("RECEIVING TASK: CHECKSUM = %x\n", chksum); if (chksum != shm[shm[0] + 1]) { printf("RECEIVING TASK: WRONG SHMEM CHECKSUM\n"); } printf("RECEIVING TASK SENDS TO AGENT TASK %x\n", 0xaaaaaaaa); rt_send(agentask, 0xaaaaaaaa); } else { printf("RECEIVING TASK DELETES ITSELF\n"); rt_task_delete(receiving_task); printf("END RECEIVING TASK\n"); exit(1); } } 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; }
void *urt_sys_shmem_new(const char *name, size_t size, int *error) { unsigned long num = nam2num(name); void *mem; if (rt_get_adr(num)) goto exit_exists; mem = rt_shm_alloc(num, size, USE_VMALLOC); if (mem == NULL && error) *error = ENOMEM; return mem; exit_exists: if (error) *error = EEXIST; return NULL; }
static inline int _rt_shm_free(unsigned long name, int size) { void *adr; if (size && (adr = rt_get_adr(name))) { if (RT_SHM_OP_PERM()) { if (!rt_drg_on_name_cnt(name) && name != GLOBAL_HEAP_ID) { if (size < 0) { rkfree(adr, -size); } else { rvfree(adr, size); } } } return abs(size); } return 0; }
RTAI_SYSCALL_MODE BITS *rt_named_bits_init(const char *bits_name, unsigned long mask) { BITS *bits; unsigned long name; if ((bits = rt_get_adr(name = nam2num(bits_name)))) { return bits; } if ((bits = rt_malloc(sizeof(SEM)))) { rt_bits_init(bits, mask); if (rt_register(name, bits, IS_BIT, 0)) { return bits; } rt_bits_delete(bits); } rt_free(bits); return NULL; }
int main(int argc,char *argv[]) { MBX *mbx; struct pollfd pollkb; struct sample { long min, max, avrg, jitters[2]; } samp; int n = 0; setlinebuf(stdout); pollkb.fd = 0; pollkb.events = POLLIN; signal(SIGHUP, endme); signal(SIGINT, endme); signal(SIGKILL, endme); signal(SIGTERM, endme); signal(SIGALRM, endme); if (!rt_thread_init(nam2num("DSPLY"), 0, 0, SCHED_FIFO, 0xF)) { printf("CANNOT INIT DISPLAY TASK\n"); exit(1); } if (!(mbx = rt_get_adr(nam2num("MBX")))) { fprintf(stderr, "Error opening mbx in display\n"); exit(1); } printf("RTAI Testsuite - LXRT preempt (all data in nanoseconds)\n"); while (!end) { if ((n++ % 21) == 0) { printf("RTH|%12s|%12s|%12s|%12s|%12s\n", "lat min","lat avg","lat max","jit fast","jit slow"); } rt_mbx_receive(mbx, &samp, sizeof(samp)); printf("RTD|%12ld|%12ld|%12ld|%12ld|%12ld\n", samp.min, samp.avrg, samp.max, samp.jitters[0], samp.jitters[1]); fflush(stdout); if (poll(&pollkb, 1, 1) > 0) { getchar(); break; } } 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; }