int main(int argc, char *argv[])
{
unsigned int player, msg, spknode, spkport, i;
RT_TASK *plrtsk, *spktsk;
struct sockaddr_in addr;
MBX *mbx;
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_port(spknode)) <= 0 && spkport != -EINVAL);
spktsk = RT_get_adr(spknode, spkport, "SPKTSK");
mbx = RT_get_adr(spknode, spkport, "SNDMBX");
for (i = 0; i < 100; i++) {
RT_rpc(spknode, spkport, spktsk, msg, &msg);
}
mlockall(MCL_CURRENT | MCL_FUTURE);
printf("\nPLAYER TASK RUNNING\n\n(TYPE ENTER TO END EVERYTHING)\n");
while (!end) {
lseek(player, 0, SEEK_SET);
while(!end && (msg = read(player, data, BUFSIZE)) > 0) {
RT_mbx_send(spknode, spkport, mbx, data, msg);
}
}
RT_rpc(spknode, spkport, spktsk, msg, &msg);
rt_release_port(spknode, spkport);
rt_task_delete(plrtsk);
close(player);
printf("\nPLAYER TASK STOPS\n");
return 0;
}
static int init_module(void)
{
int i, srvport;
while ((srvport = rt_request_hard_port(tasknode)) <= 0) {
msleep(100);
}
printf("START TASK GOT SYNC TASKNODE PORT %lx, %d\n", tasknode, srvport);
rt_make_hard_real_time();
while (!RT_get_adr(tasknode, srvport, task[NUM_TASKS - 1])) {
msleep(100);
}
rt_make_soft_real_time();
printf("START TASK REL SYNC TASKNODE PORT %lx, %d\n", tasknode, srvport);
rt_release_port(tasknode, srvport);
srvport = rt_request_hard_port(comnode);
printf("START TASK GOT INIT COMNODE PORT %lx, %d\n", comnode, srvport);
rt_make_hard_real_time();
print_sem = RT_get_adr(comnode, srvport, "PRTSEM");
sync_sem = RT_get_adr(comnode, srvport, "SYNCSM");
prio_sem = RT_get_adr(comnode, srvport, "PRIOSM");
end_sem = RT_get_adr(comnode, srvport, "ENDSEM");
mbx_in = RT_get_adr(comnode, srvport, "MBXIN");
mbx_out = RT_get_adr(comnode, srvport, "MBXOUT");
for (i = 0; i < NUM_TASKS; ++i) {
sems[i] = RT_get_adr(comnode, srvport, sem[i]);
}
printf("START TASK REL INIT COMNODE PORT %lx, %d\n", comnode, srvport);
rt_make_soft_real_time();
rt_release_port(comnode, srvport);
thread = rt_thread_create(start_task_code, NULL, 10000);
return 0;
}
static int init_module(void)
{
int i, srvport;
while ((srvport = rt_request_port(comnode)) <= 0) {
msleep(100);
}
printf("TASK CODE GOT INIT COMNODE PORT %lx, %d\n", comnode, srvport);
while (!(print_sem = RT_get_adr(comnode, srvport, "PRTSEM"))) {
msleep(100);
}
sync_sem = RT_get_adr(comnode, srvport, "SYNCSM");
prio_sem = RT_get_adr(comnode, srvport, "PRIOSM");
end_sem = RT_get_adr(comnode, srvport, "ENDSEM");
mbx_in = RT_get_adr(comnode, srvport, "MBXIN");
mbx_out = RT_get_adr(comnode, srvport, "MBXOUT");
for (i = 0; i < NUM_TASKS; i++) {
sems[i] = RT_get_adr(comnode, srvport, sem[i]);
if (!(thread[i] = rt_thread_create(task_code, (void *)&i, 10000))) {
printf("ERROR IN CREATING THREAD %d\n", i);
exit(1);
}
msleep(100);
}
printf("TASK CODE REL INIT COMNODE PORT %lx, %d\n", comnode, srvport);
rt_release_port(comnode, srvport);
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;
}
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;
}
static void start_task_code(long none)
{
int i, srvport;
char buf[9];
while ((srvport = rt_request_port(tasknode)) <= 0);
rt_printk("START TASK GOT SYNC TASKNODE PORT %lx, %d\n", tasknode, srvport);
while (!RT_get_adr(tasknode, srvport, task[NUM_TASKS - 1]));
rt_printk("START TASK REL SYNC TASKNODE PORT %lx, %d\n", tasknode, srvport);
rt_release_port(tasknode, srvport);
srvport = rt_request_port(comnode);
rt_printk("START TASK GOT ITS INIT AND EXEC COMNODE PORT %lx, %d\n", comnode, srvport);
print_sem = RT_get_adr(comnode, srvport, "PRTSEM");
sync_sem = RT_get_adr(comnode, srvport, "SYNCSM");
prio_sem = RT_get_adr(comnode, srvport, "PRIOSM");
mbx_in = RT_get_adr(comnode, srvport, "MBXIN");
mbx_out = RT_get_adr(comnode, srvport, "MBXOUT");
for (i = 0; i < NUM_TASKS; ++i) {
sems[i] = RT_get_adr(comnode, srvport, sem[i]);
}
buf[8] = 0;
RT_sem_signal(comnode, srvport, sems[0]);
for (i = 0; i < NUM_TASKS; ++i) {
RT_sem_wait(comnode, srvport, sync_sem);
}
TAKE_PRINT;
rt_printk(sync_str);
GIVE_PRINT;
for (i = 0; i < NUM_TASKS; ++i) {
RT_sem_signal(comnode, srvport, prio_sem);
}
TAKE_PRINT;
rt_printk("\n");
GIVE_PRINT;
for (i = 0; i < NUM_TASKS; ++i) {
RT_sem_wait(comnode, srvport, sync_sem);
}
TAKE_PRINT;
rt_printk(sync_str);
GIVE_PRINT;
TAKE_PRINT;
rt_printk("testing message queues\n");
GIVE_PRINT;
for (i = 0; i < NUM_TASKS; ++i) {
if (RT_mbx_send(comnode, srvport, mbx_in, strs[i], 8)) {
TAKE_PRINT;
rt_printk("RT_mbx_send() failed\n");
GIVE_PRINT;
}
}
for (i = 0; i < NUM_TASKS; ++i) {
RT_mbx_receive(comnode, srvport, mbx_out, buf, 8);
TAKE_PRINT;
rt_printk("\nreceived from mbx_out: %s", buf);
GIVE_PRINT;
}
TAKE_PRINT;
rt_printk("\n");
GIVE_PRINT;
for (i = 0; i < NUM_TASKS; ++i) {
RT_sem_signal(comnode, srvport, sync_sem);
}
TAKE_PRINT;
rt_printk("\ninit task complete\n");
GIVE_PRINT;
rt_release_port(comnode, srvport);
rt_printk("START TASK REL ITS EXEC COMNODE PORT %lx, %d\n", comnode, srvport);
atomic_inc(&cleanup);
}
int main(int argc, char *argv[])
{
unsigned int plrnode, plrport;
RT_TASK *spktsk, *plrtsk;
RTIME period;
struct sockaddr_in addr;
char buf[BUFSIZE], data, temp;
unsigned int msg, i, len;
printf("\n\nSPECIFIC RECEIVE USING EXPLICITELY ASSIGNED LOCAL STUB\n");
ioperm(PORT_ADR, 1, 1);
if (!(spktsk = rt_task_init_schmod(nam2num("SPKTSK"), 1, 0, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT SPEAKER TASK\n");
exit(1);
}
rt_returnx(rt_receivex(0, &msg, sizeof(int), &len), &msg, 1);
plrnode = 0;
if (argc == 2 && strstr(argv[1], "PlrNode=")) {
inet_aton(argv[1] + 8, &addr.sin_addr);
plrnode = addr.sin_addr.s_addr;
}
if (!plrnode) {
inet_aton("127.0.0.1", &addr.sin_addr);
plrnode = addr.sin_addr.s_addr;
}
rt_set_oneshot_mode();
start_rt_timer(0);
while ((plrport = rt_request_hard_port(plrnode)) <= 0 && plrport != -EINVAL);
rt_make_hard_real_time();
while (!(plrtsk = RT_get_adr(plrnode, plrport, "PLRTSK"))) {
rt_sleep(nano2count(10000000));
}
printf("\nSPEAKER TASK RUNNING\n");
mlockall(MCL_CURRENT | MCL_FUTURE);
period = nano2count(PERIOD);
rt_task_make_periodic(spktsk, rt_get_time() + 5*period, period);
plrtsk = rt_find_asgn_stub(OWNER(plrnode, plrtsk), 1);
for (i = 0; i < 100; i++) {
rt_returnx(rt_receivex(plrtsk, &msg, sizeof(int), &len), &msg, sizeof(int));
}
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(plrtsk, buf, BUFSIZE, &i)) {
// rt_printk("EVDRP %d\n", i);
}
if (rt_receivex_if(plrtsk, buf, BUFSIZE, &len) == plrtsk) {
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_release_port(plrnode, plrport);
rt_task_delete(spktsk);
printf("\nSPEAKER TASK STOPS\n");
return 0;
}
int main(int argc, char *argv[])
{
MBX *mbx;
SEM *sem;
RT_TASK *task;
RTIME t0, t;
int i, count, jit, maxj, test_time, hdlnode, hdlport;
struct sockaddr_in addr;
unsigned long run;
char c;
if (!(task = rt_task_init_schmod(nam2num("PRCTSK"), 1, 0, 0, SCHED_FIFO, TASK_CPU))) {
printf("CANNOT INIT PROCESS TASK\n");
exit(1);
}
hdlnode = 0;
if (argc == 2 && strstr(argv[1], "HdlNode=")) {
inet_aton(argv[1] + 8, &addr.sin_addr);
hdlnode = addr.sin_addr.s_addr;
}
if (!hdlnode) {
inet_aton("127.0.0.1", &addr.sin_addr);
hdlnode = addr.sin_addr.s_addr;
}
while ((hdlport = rt_request_port(hdlnode)) <= 0 && hdlport != -EINVAL);
mbx = RT_get_adr(hdlnode, hdlport, "HDLMBX");
sem = rt_sem_init(nam2num("PRCSEM"), 0);
printf("USE: SEM SEND/WAIT (s), TASK RESM/SUSP (r), INTERTASK MSG (m): [s|r|m]? ");
scanf("%c", &c);
switch (c) {
case 'r': printf("TESTING TASK SUSPEND/RESUME TIME (s): ");
run = 2;
break;
case 'm': printf("TESTING INTERTASK SEND/RECEIVE TIME (s): ");
run = 3;
break;
default: printf("TESTING SEMAPHORE WAIT/SEND TIME (s): ");
run = 1;
break;
}
scanf("%d", &test_time);
printf("... WAIT FOR %d SECONDS (RUNNING AT %d hz).\n", test_time, 1000000000/PERIOD);
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
RT_mbx_send(hdlnode, hdlport, mbx, &task, sizeof(task));
RT_mbx_send(hdlnode, hdlport, mbx, &sem, sizeof(sem));
RT_mbx_send(hdlnode, hdlport, mbx, &run, sizeof(run));
count = maxj = 0;
t0 = rt_get_cpu_time_ns();
while(++count <= test_time*(1000000000/(PERIOD*100))) {
for (i = 0; i < 100; i++) {
t = rt_get_cpu_time_ns();
if ((jit = t - t0 - PERIOD) < 0) {
jit = -jit;
}
if (count > 1 && jit > maxj) {
maxj = jit;
}
t0 = t;
switch (run) {
case 1: rt_sem_wait(sem);
break;
case 2: rt_task_suspend(task);
break;
case 3: rt_receive(0, &run);
break;
}
}
}
run = 0;
RT_mbx_send(hdlnode, hdlport, mbx, &run, sizeof(run));
rt_make_soft_real_time();
rt_release_port(hdlnode, hdlport);
rt_task_delete(task);
printf("***** MAX JITTER %3d (us) *****\n", (maxj + 499)/1000);
exit(0);
}
