int init_module(void)
{
int i;
DBG_PRINT_INIT;
if (rt_task_init(&start_task, start_task_code, 0, 10000, 10, 0, 0) != 0) {
printk("Could not start init task\n");
}
if (rt_mbx_init(&mbx_in, NUM_TASKS*8) || rt_mbx_init(&mbx_out, NUM_TASKS*8)) {
printk("could not create message queue\n");
return 1;
}
for (i = 0; i < NUM_TASKS; ++i) {
rt_sem_init(&sems[i], 0);
if (rt_task_init(&tasks[i], task_code, i, 3000, NUM_TASKS - i, 0, 0) != 0) {
printk("rt_task_ipc_init failed\n");
return 1;
}
}
#ifdef ONE_SHOT
rt_set_oneshot_mode();
#endif
start_rt_timer_ns(10000000);
checkt = rdtsc();
checkj = jiffies;
rt_task_resume(&start_task);
for (i = 0; i < NUM_TASKS; ++i) {
rt_task_resume(&tasks[i]);
}
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 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
}
static int init_module(void)
{
int i;
rt_set_oneshot_mode();
start_rt_timer(0);
sync_sem = rt_sem_init(nam2num("SYNCSM"), 0);
prio_sem = rt_sem_init(nam2num("PRIOSM"), 0);
if (!(mbx_in = rt_mbx_init(nam2num("MBXIN"), NUM_TASKS*8)) || !(mbx_out = rt_mbx_init(nam2num("MBXOUT"), NUM_TASKS*8))) {
printf("could not create message queues\n");
return 1;
}
for (i = 0; i < NUM_TASKS; ++i) {
sems[i] = rt_sem_init(nam2num(sem[i]), 0);
}
end_sem = rt_typed_sem_init(nam2num("ENDSEM"), 0, CNT_SEM);
print_sem = rt_typed_sem_init(nam2num("PRTSEM"), 1, BIN_SEM);
return 0;
}
int init_module(void)
{
tasknode = ddn2nl(TaskNode);
rt_mbx_init(&mbx, 1);
rt_register(nam2num("HDLMBX"), &mbx, IS_MBX, 0);
rt_task_init(&sup_task, sup_fun, 0, 2000, 1, 0, 0);
rt_task_resume(&sup_task);
rt_request_timer(timer_tick, imuldiv(PERIOD, FREQ_8254, 1000000000), 0);
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;
}
/***
* rt_stack_mgr_init
*/
int rt_stack_mgr_init (struct rtnet_mgr *mgr)
{
int ret = 0;
if ( (ret=rt_mbx_init (&(mgr->mbx), sizeof(struct rtnet_msg))) )
return ret;
if ( (ret=rt_task_init(&(mgr->task), &do_stacktask, (int)mgr, 4096, RTNET_STACK_PRIORITY, 0, 0)) )
return ret;
if ( (ret=rt_task_resume(&(mgr->task))) )
return ret;
return (ret);
}
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;
}
int main(void)
{
unsigned int player, msg, cnt;
RT_TASK *mytask;
MBX *mbx;
char data[BUFSIZE];
signal(SIGINT, endme);
// rt_allow_nonroot_hrt();
if ((player = open("../../examples/sound/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_mbx_init(nam2num("SNDMBX"), 2000);
rt_set_oneshot_mode();
start_rt_timer(0);
pthread_create(&thread, NULL, intr_handler, NULL);
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);
pthread_join(thread, NULL);
return 0;
}
int init_module(void)
{
int i;
rt_set_oneshot_mode();
start_rt_timer(0);
rt_mbx_init(&mbx, 5);
for (i = 0; i < NUM_TASKS; i++) {
rt_task_init(&task[i], fun1, i, STACK_SIZE, 0, 0, 0);
rt_task_resume(&task[i]);
}
rt_task_init(&task[NUM_TASKS], fun2, NUM_TASKS, STACK_SIZE, 1, 0, 0);
rt_task_resume(&task[NUM_TASKS]);
while (atomic_read(&cleanup) < (NUM_TASKS + 1)) {
current->state = TASK_INTERRUPTIBLE;
schedule_timeout(HZ/10);
}
return 0;
}
static void mdlStart(SimStruct *S)
{
#ifndef MATLAB_MEX_FILE
MBX *mbx;
#ifdef KRTAI
rtaiSynchronoscope = S;
mbx = mbx_rt_mbx_init(TargetSynchronoscopeMbxID, (MBX_RTAI_SYNCHRONOSCOPE_SIZE/(sizeof(float))*(sizeof(float))));
#else
rtaiSynchronoscope = S;
if (!(mbx = (MBX *)rt_mbx_init(nam2num(TargetSynchronoscopeMbxID), (MBX_RTAI_SYNCHRONOSCOPE_SIZE/(sizeof(float))*(sizeof(float)))))) {
printf("Cannot init mailbox\n");
exit(1);
}
#endif
ssGetPWork(S)[0]= (void *)mbx;
#endif
}
/****
* Initialize the realtime txqueue wakeup manager and its mailbox.
*/
int rt_wakeup_mgr_init (struct rtnet_mgr *mgr) {
int ret = 0;
if ( (ret=rt_mbx_init (&(mgr->mbx), sizeof(struct rtnet_msg))) )
return ret;
if ( (ret=rt_task_init(&(mgr->task), &rt_wakeup_manager_task, (int)mgr, 4096, RTNET_RT_WAKEUP_PRIORITY, 0, 0)) )
goto rt_mbox_err;
if ( (ret=rt_task_resume(&(mgr->task))) )
goto rt_task_err;
return (ret);
rt_task_err:
rt_task_delete(&(mgr->task));
rt_mbox_err:
rt_mbx_delete(&(mgr->mbx));
return (ret);
}
int main(int argc, char *argv[])
{
unsigned long sndnode;
long sndport, i, r;
RT_TASK *rcvtsk, *sndtsk;
struct sockaddr_in addr;
static MBX *sndmbx;
SERVER = atoi(argv[1]);
if (!(rcvtsk = rt_task_init_schmod(nam2num("RCVTSK"), 2, 0, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT RECEIVER TASK\n");
exit(1);
}
mbx = rt_mbx_init(nam2num("MBX"), 100);
athread = rt_thread_create(async_fun, NULL, 10000);
sndnode = 0;
if (argc == 3 && strstr(argv[2], "SndNode=")) {
inet_aton(argv[2] + 8, &addr.sin_addr);
sndnode = addr.sin_addr.s_addr;
}
if (!sndnode) {
inet_aton("127.0.0.1", &addr.sin_addr);
sndnode = addr.sin_addr.s_addr;
}
rt_set_oneshot_mode();
start_rt_timer(0);
while ((sndport = rt_request_port_mbx(sndnode, mbx)) <= 0 && sndport != -EINVAL);
while (!(sndmbx = RT_get_adr(sndnode, sndport, "SNDMBX"))) {
rt_sleep(nano2count(100000000));
}
sndtsk = RT_get_adr(sndnode, sndport, "SNDTSK");
printf("\nRECEIVER TASK RUNNING\n");
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
while (!end) {
r = RT_mbx_receive(sndnode, -sndport, sndmbx, &i, sizeof(long));
rt_printk("RECEIVE %ld %ld\n", r, i);
if (SERVER) {
rt_sleep(nano2count(100000000));
} else {
while (!end && rt_waiting_return(sndnode, sndport)) {
rt_sleep(nano2count(1000000));
}
if (!end) {
unsigned long long retval;
long i1, i2;
int l1, l2;
if (rt_sync_net_rpc(sndnode, -sndport)) {
l1 = l2 = sizeof(long);
rt_get_net_rpc_ret(mbx, &retval, &i1, &l1, &i2, &l2, 0LL, MBX_RECEIVE);
rt_printk("RECEIVER ASYNC MSG: RETVAL = %d, MSG = %ld, LEN = %d.\n", (int)retval, i1, l1);
if (i1 < 0) {
end = 1;
break;
}
}
}
}
}
rt_mbx_delete(mbx);
rt_release_port(sndnode, sndport);
rt_make_soft_real_time();
rt_thread_join(athread);
rt_return(rt_receive(0, &i), i);
rt_task_delete(rcvtsk);
stop_rt_timer();
printf("\nRECEIVER TASK STOPS\n");
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;
}
int main(int argc, char *argv[])
{
int diff;
int sample;
long average;
int min_diff;
int max_diff;
int period;
int i;
RTIME t, svt;
RTIME expected, exectime[3];
MBX *mbx;
RT_TASK *task, *latchk;
struct sample { long long min; long long max; int index, ovrn; } samp;
double s = 0.0, sref;
long long max = -1000000000, min = 1000000000;
signal(SIGINT, endme);
signal(SIGKILL, endme);
signal(SIGTERM, endme);
if (!(mbx = rt_mbx_init(nam2num("LATMBX"), 20*sizeof(samp)))) {
printf("CANNOT CREATE MAILBOX\n");
exit(1);
}
if (!(task = rt_task_init_schmod(nam2num("LATCAL"), 0, 0, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT MASTER LATENCY TASK\n");
exit(1);
}
printf("\n## RTAI latency calibration tool ##\n");
printf("# period = %i (ns) \n", PERIOD);
printf("# average time = %i (s)\n", (int)AVRGTIME);
printf("# use the FPU\n");
printf("#%sstart the timer\n", argc == 1 ? " " : " do not ");
printf("# timer_mode is %s\n", TIMER_MODE ? "periodic" : "oneshot");
printf("\n");
if (!(hard_timer_running = rt_is_hard_timer_running())) {
if (TIMER_MODE) {
rt_set_periodic_mode();
} else {
rt_set_oneshot_mode();
}
period = start_rt_timer(nano2count(PERIOD));
} else {
period = nano2count(PERIOD);
}
for(i = 0; i < MAXDIM; i++) {
a[i] = b[i] = 3.141592;
}
sref = dot(a, b, MAXDIM);
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
expected = rt_get_time() + 200*period;
rt_task_make_periodic(task, expected, period);
svt = rt_get_cpu_time_ns();
i = 0;
samp.ovrn = 0;
while (!end) {
min_diff = 1000000000;
max_diff = -1000000000;
average = 0;
for (sample = 0; sample < SMPLSXAVRG && !end; sample++) {
expected += period;
if (!rt_task_wait_period()) {
if (TIMER_MODE) {
diff = (int) ((t = rt_get_cpu_time_ns()) - svt - PERIOD);
svt = t;
} else {
diff = (int) count2nano(rt_get_time() - expected);
}
} else {
samp.ovrn++;
diff = 0;
if (TIMER_MODE) {
svt = rt_get_cpu_time_ns();
}
}
outb(i = 1 - i, 0x378);
if (diff < min_diff) {
min_diff = diff;
}
if (diff > max_diff) {
max_diff = diff;
}
average += diff;
s = dot(a, b, MAXDIM);
if (fabs((s - sref)/sref) > 1.0e-15) {
printf("\nDOT PRODUCT RESULT = %20.16e %20.16e %20.16e\n", s, sref, fabs((s - sref)/sref));
return 0;
}
}
samp.min = min_diff;
samp.max = max_diff;
samp.index = average/SMPLSXAVRG;
#if SOLO
if (max < samp.max) max = samp.max;
if (min > samp.min) min = samp.min;
rt_printk("SOLO * min: %lld/%lld, max: %lld/%lld average: %d (%d) <Hit [RETURN] to stop> *\n", samp.min, min, samp.max, max, samp.index, samp.ovrn);
#else
rt_mbx_send_if(mbx, &samp, sizeof(samp));
if ((latchk = rt_get_adr(nam2num("LATCHK"))) && (rt_receive_if(latchk, &average) || end)) {
rt_return(latchk, average);
break;
}
#endif
}
while (rt_get_adr(nam2num("LATCHK"))) {
rt_sleep(nano2count(1000000));
}
rt_make_soft_real_time();
if (!hard_timer_running) {
stop_rt_timer();
}
rt_get_exectime(task, exectime);
if (exectime[1] && exectime[2]) {
printf("\n>>> S = %g, EXECTIME = %G\n", s, (double)exectime[0]/(double)(exectime[2] - exectime[1]));
}
rt_task_delete(task);
rt_mbx_delete(mbx);
return 0;
}
int main(int argc, char *argv[])
{
int diff;
int skip;
long average;
int min_diff;
int max_diff;
int period;
int i;
RTIME t, svt;
RTIME expected, exectime[3];
MBX *mbx;
RT_TASK *task, *latchk;
struct sample { long long min; long long max; int index, ovrn; } samp;
double s;
signal(SIGHUP, endme);
signal(SIGKILL, endme);
signal(SIGTERM, endme);
signal(SIGALRM, endme);
if (!(mbx = rt_mbx_init(nam2num("LATMBX"), 20*sizeof(samp)))) {
printf("CANNOT CREATE MAILBOX\n");
exit(1);
}
if (!(task = rt_task_init_schmod(nam2num("LATCAL"), 0, 0, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT MASTER TASK\n");
exit(1);
}
printf("\n## RTAI latency calibration tool ##\n");
printf("# period = %i (ns) \n", PERIOD);
printf("# average time = %i (s)\n", (int)AVRGTIME);
printf("# use the FPU\n");
printf("#%sstart the timer\n", argc == 1 ? " " : " do not ");
printf("# timer_mode is %s\n", TIMER_MODE ? "periodic" : "oneshot");
printf("\n");
if (argc == 1) {
if (TIMER_MODE) {
rt_set_periodic_mode();
} else {
rt_set_oneshot_mode();
}
period = start_rt_timer(nano2count(PERIOD));
} else {
period = nano2count(PERIOD);
}
for(i = 0; i < MAXDIM; i++) {
a[i] = b[i] = 3.141592;
}
s = dot(a, b, MAXDIM);
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
rt_task_make_periodic(task, expected = rt_get_tscnt() + 10*period, period);
svt = rt_get_cpu_time_ns();
samp.ovrn = i = 0;
while (!end) {
min_diff = 1000000000;
max_diff = -1000000000;
average = 0;
for (skip = 0; skip < SKIP && !end; skip++) {
expected += period;
if (!rt_task_wait_period()) {
if (TIMER_MODE) {
diff = (int) ((t = rt_get_cpu_time_ns()) - svt - PERIOD);
svt = t;
} else {
diff = (int) count2nano(rt_get_tscnt() - expected);
}
} else {
samp.ovrn++;
diff = 0;
if (TIMER_MODE) {
svt = rt_get_cpu_time_ns();
}
}
if (diff < min_diff) {
min_diff = diff;
}
if (diff > max_diff) {
max_diff = diff;
}
average += diff;
s = dot(a, b, MAXDIM);
}
samp.min = min_diff;
samp.max = max_diff;
samp.index = average/SKIP;
rt_mbx_send_if(mbx, &samp, sizeof(samp));
if ((latchk = rt_get_adr(nam2num("LATCHK"))) && (rt_receive_if(latchk, (unsigned long *)&average) || end)) {
rt_return(latchk, (unsigned long)average);
break;
}
}
while (rt_get_adr(nam2num("LATCHK"))) {
rt_sleep(nano2count(1000000));
}
rt_make_soft_real_time();
if (argc == 1) {
stop_rt_timer();
}
rt_get_exectime(task, exectime);
if (exectime[1] && exectime[2]) {
printf("\n>>> S = %g, EXECTIME = %G\n", s, (double)exectime[0]/(double)(exectime[2] - exectime[1]));
}
rt_task_delete(task);
rt_mbx_delete(mbx);
return 0;
}
int main(int argc, char *argv[])
{
int diff;
int skip;
int average;
int min_diff;
int max_diff;
int period;
int i;
RTIME expected, ts;
MBX *mbx;
RT_TASK *task;
struct sample { long long min; long long max; int index; double s; int ts; } samp;
double s;
if (!(mbx = rt_mbx_init(nam2num("LATMBX"), 20*sizeof(samp)))) {
printf("CANNOT CREATE MAILBOX\n");
exit(1);
}
if (!(task = rt_task_init_schmod(nam2num("LATCAL"), 0, 0, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT MASTER TASK\n");
exit(1);
}
if (argc == 1) {
rt_set_oneshot_mode();
start_rt_timer(0);
}
for(i = 0; i < MAXDIM; i++) {
a[i] = b[i] = 3.141592;
}
vdot(a, b, MAXDIM);
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
period = nano2count(PERIOD);
rt_task_make_periodic(task, expected = rt_get_time() + 5*period, period);
#ifdef OVERALL
min_diff = 1000000000;
max_diff = -1000000000;
#endif
while (1) {
#ifndef OVERALL
min_diff = 1000000000;
max_diff = -1000000000;
#endif
average = 0;
for (skip = 0; skip < SKIP; skip++) {
expected += period;
rt_task_wait_period();
diff = (int)count2nano(rt_get_time() - expected);
if (diff < min_diff) {
min_diff = diff;
}
if (diff > max_diff) {
max_diff = diff;
}
average += diff;
ts = rt_get_time();
s = vdot(a, b, MAXDIM);
ts = rt_get_time() - expected;
}
samp.min = min_diff;
samp.max = max_diff;
samp.index = average/SKIP;
samp.s = (double)s;
samp.ts = (int)count2nano(ts);
rt_mbx_send_if(mbx, &samp, sizeof(samp));
if (rt_receive_if(rt_get_adr(nam2num("LATCHK")), (unsigned int *)&average)) {
rt_return(rt_get_adr(nam2num("LATCHK")), (unsigned int)average);
break;
}
}
while (rt_get_adr(nam2num("LATCHK"))) {
rt_sleep(nano2count(1000000));
}
rt_make_soft_real_time();
if (argc == 1) {
stop_rt_timer();
}
rt_task_delete(task);
rt_mbx_delete(mbx);
return 0;
}
int main(int argc, char *argv[])
{
RT_TASK *buddy, *logmsg_buddy;
int i, narg, priority;
char *optStr;
priority = PRIORITY;
narg = argc;
for (i = 0; i < argc; i++) {
if (strstr(argv[i], "p=")) {
priority = atoi(argv[i] + 2);
argv[i] = 0;
narg--;
continue;
}
if (strstr(argv[i], "o=")) {
ovr_chk_stp = atoi(argv[i] + 2);
argv[i] = 0;
narg--;
continue;
}
if (strstr(argv[i], "nohrt")) {
use_hrt = 0;
argv[i] = 0;
narg--;
continue;
}
}
if (narg > 2) {
printf("TOO MANY ARGS IN COMMAND LINE.\n");
return 1;
}
optStr = NULL;
for (i = 1; i < argc; i++) {
if (argv[i]) {
optStr = argv[i];
break;
}
}
if (optStr == NULL) {
optStr = "\0";
}
rt_allow_nonroot_hrt();
if (!(buddy = rt_task_init_schmod(nam2num("RTWPRG"), 98, 0, 0, SCHED_FIFO, 0xFFFFFFFF))) {
printf("CANNOT INIT MAIN TASK BUDDY %p.\n", buddy);
return 1;
}
#ifdef DBGPRT
printf("MAIN TASK BUDDY CREATED %p, EXECUTION STARTED.\n", buddy);
#endif
logfile = fopen("rtw_log", "w");
if (!(logmbx = rt_mbx_init(nam2num("LOGMBX"), LOGMBX_SIZE))) {
printf("CANNOT INIT LOG MSG SERVER SUPPORT MAILBOX %p.\n", logmbx);
return 1;
}
#ifdef DBGPRT
printf("LOG MSG SERVER SUPPORT MAILBOX CREATED %p.\n", logmbx);
#endif
iopl(3);
pthread_create(&overuns_mon_thread, NULL, overuns_mon_fun, NULL);
pthread_create(&logMsg_thread, NULL, logMsg_fun, &buddy);
rt_receive(0, (unsigned int *)&logmsg_buddy);
rtai_main_buddy = buddy;
signal(SIGINT, endme);
signal(SIGTERM, endme);
#ifdef DBGPRT
printf("LOG MSG SERVER BUDDY TASK CREATED %p, LOG MSG SERVER RUNNING.\n", buddy);
printf ("CALLING RT_MAIN WITH: HRT %d, PRIORITY %d, OVRCHK %d (s), OPTSTR %s.\n", use_hrt, priority, ovr_chk_stp, optStr);
#endif
rt_main(MODEL, optStr, NULL, 0, priority, 0);
#ifdef DBGPRT
printf ("RT_MAIN RETURNED.\n");
#endif
pthread_cancel(overuns_mon_thread);
pthread_join(overuns_mon_thread, NULL);
#ifdef DBGPRT
printf("OVERUNS MONITOR STOPPED.\n");
#endif
rt_task_delete(logmsg_buddy);
pthread_cancel(logMsg_thread);
pthread_join(logMsg_thread, NULL);
#ifdef DBGPRT
printf("LOG MSG SERVER BUDDY TASK %p DELETED, LOG MSG SERVER STOPPED.\n", buddy);
#endif
rt_mbx_delete(logmbx);
#ifdef DBGPRT
printf("LOG MSG SERVER SUPPORT MAILBOX %p DELETED.\n", logmbx);
#endif
rt_task_delete(buddy);
#ifdef DBGPRT
printf("MAIN TASK BUDDY DELETED %p, EXECUTION TERMINATED.\n", buddy);
printf("\nTOTAL OVERUNS: %ld.\n", sysAuxClkOveruns());
#endif
fprintf(logfile, "\nTOTAL OVERUNS: %ld.\n", sysAuxClkOveruns());
fclose(logfile);
return 0;
}
