void *ClockChrono_Read(void *args)
{
RT_TASK *mytask;
char ch;
int run = 0;
mqd_t Keyboard;
struct mq_attr kb_attrs = { MAX_MSGS, 1, 0, 0 };
if (!(mytask = rt_thread_init(nam2num("READ"), 1, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT TASK ClockChronoRead\n");
exit(1);
}
Keyboard = mq_open("KEYBRD", O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, &kb_attrs);
printf("INIT TASK ClockChronoRead %p.\n", mytask);
mlockall(MCL_CURRENT | MCL_FUTURE);
while(1) {
mq_receive(Keyboard, &ch, 1, NULL);
ch = toupper(ch);
switch(ch) {
case 'T': case 'R': case 'H': case 'M': case 'S':
CommandClock_Put(ch);
break;
case 'C': case 'I': case 'E':
CommandChrono_Put(ch);
break;
case 'N':
hide = ~hide;
break;
case 'P':
Pause = TRUE;
rt_fractionated_sleep(nano2count(FIVE_SECONDS));
Pause = FALSE;
break;
case 'K': case 'D':
run |= ch;
if (run == ('K' | 'D')) {
sem_post(&sync_sem);
sem_post(&sync_sem);
}
break;
case 'F':
CommandClock_Put('F');
CommandChrono_Put('F');
goto end;
}
}
end:
mq_close(Keyboard);
rt_task_delete(mytask);
printf("END TASK ClockChronoRead %p.\n", mytask);
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;
}
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;
}
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 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;
}
void cleanup_module(void)
{
int i;
stop_rt_timer();
for (i = 0; i < NUM_CHILDREN; i++) {
rt_task_delete(&child_task[i]);
}
rt_busy_sleep(nano2count(TICK_PERIOD));
rt_task_delete(&parent_task);
}
static void sig_fun(long arg)
{
/*
* it could be here, but it has been done at task init already, so it
* might be useful here just for changes, including nullifing it.
* rt_task_signal_handler(&sig_task, sighdl);
*/
while (1) {
rt_sleep(nano2count(PERIOD));
}
}
void osh(unsigned long data)
{
if (ostloops++ < LOOPS) {
rt_printk("\nFIRED BUDDY: %3d, %lx", ostloops, data);
#if PERIODIC_BUDDY == 0
rt_insert_timer(&ost, 0, firing_time += nano2count(TICK_PERIOD/2), 0, osh, 0xBBBBBBBB, 0);
#endif
} else {
rt_printk("\n");
rt_remove_timer(&ost);
}
}
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)
{
long signal_a;
long signal_b;
t_info a = {
.id = 'A',
};
t_info b = {
.id = 'B',
};
finish = 0;
rt_set_periodic_mode();
start_rt_timer(nano2count(TICK_TIME));
rt_make_hard_real_time();
a.delay = 0;
a.period = nano2count(TICK_TIME);
signal_a = rt_thread_create(&signal_func, &a, 500);
if (!signal_a) {
printf("Can not initialize signal A\n");
return -ENODEV;
}
b.delay = nano2count(DELAY_TIME);
b.period = nano2count(TICK_TIME);
signal_b = rt_thread_create(&signal_func, &b, 500);
if (!signal_b) {
printf("Can not initialize signal B\n");
return -ENODEV;
}
scanf("%d", &finish);
finish = 1;
rt_thread_join(signal_a);
rt_thread_join(signal_b);
pthread_exit(NULL);
return 0;
}
int create_tasks(void)
{
int i;
struct thread_param *arrayThreadParams[NTASKS];
rt_set_periodic_mode();
rt_hard_timer_tick_cpuid(CPU_ALLOWED);
printf("************** Iniciando escalonamento **************\n");
for (i = 0; i < NTASKS; i++)
{
arrayThreads[i] = (pthread_t *) malloc(sizeof(pthread_t));
if (!arrayThreads[i])
{
printf("[ERRO] Não foi possivel criar a Thread da tarefa %d.\n\n", i);
return(0);
}
}
tick_period = start_rt_timer(nano2count(TICK_PERIOD));
printf("TICK_PERIOD =======> %llu\n", tick_period);
delay_timeline_sched = tick_period * 10;
timeline_sched = rt_get_time() + delay_timeline_sched;
for (i = 0; i < NTASKS; i++) {
if((arrayThreadParams[i] = malloc(sizeof(*arrayThreadParams[i]))) == NULL)
{
printf("[ERRO] Não foi possivel criar os parametros da tarefa %d.\n\n", i);
return (-1);
}
arrayThreadParams[i]->idTask = i;
// Inicializando as tarefas...
if(pthread_create(arrayThreads[i], 0, init_task, (void *)arrayThreadParams[i]))
{
printf("[ERRO] Não foi possível inicializar a Thread da tarefa %d.\n", i);
return(0);
}
}
while(!getchar()); // Aguardo o usuario apertar alguma tecla para finalizar o escalonamento...
for (i = 0; i < NTASKS; i++) {
pthread_cancel((pthread_t) *arrayThreads[i]);
free(arrayThreadParams[i]);
}
return 0;
}
static void ClockChrono_Chrono(long t)
{
RTIME OneUnit = nano2count(ONE_UNIT);
MenageHmsh_tHour times;
MenageHmsh_tChain11 timesChain;
BOOLEAN Intermediatetimes = FALSE;
MenageHmsh_tHour endIntermediateTimes;
BOOLEAN display;
BOOLEAN hundredthes = FALSE;
char command;
unsigned long msg;
rt_receive(&read, &msg);
command = 'R';
while(1) {
cpu_used[hard_cpu_id()]++;
switch(command) {
case 'R':
MenageHmsh_Initialise(×);
display = TRUE;
hundredthes = FALSE;
Intermediatetimes = FALSE;
break;
case 'C':
rt_fractionated_sleep(OneUnit);
MenageHmsh_PlusOneUnit(×, &display);
if (Intermediatetimes) {
Intermediatetimes = !MenageHmsh_Equal(
times, endIntermediateTimes);
display = !Intermediatetimes;
hundredthes = FALSE;
}
break;
case 'I':
Intermediatetimes = TRUE;
endIntermediateTimes = times;
MenageHmsh_PlusNSeconds(3,
&endIntermediateTimes);
display = TRUE;
hundredthes = TRUE;
break;
case 'E':
display = TRUE;
hundredthes = TRUE;
}
if (display) {
MenageHmsh_Convert(times, hundredthes, ×Chain);
Display_PutTimes(timesChain);
}
CommandChrono_Get(&command);
}
}
static void mfun(long t)
{
RTIME time;
unsigned long long msg;
int size, maxt = 0, itime;
while (1) {
time = rt_get_cpu_time_ns();
cpu_used[hard_cpu_id()]++;
mstat[t] = 's';
if ((size = rt_mbx_send_timed(&smbx, &name[t], sizeof(long long), nano2count(TIMEOUT)))) {
rt_printk("SEND TIMEDOUT TASK: %d, UNSENT: %d, STAT: %c %c %c, OVERTIME: %d.\n", t, size, mstat[0], mstat[1], bstat, (int)(rt_get_cpu_time_ns() - time));
goto prem;
}
msg = 0;
mstat[t] = 'r';
if ((size = rt_mbx_receive_timed(&rmbx[t], &msg, sizeof(msg), nano2count(TIMEOUT)))) {
rt_printk("RECEIVE TIMEDOUT TIME: %d, NOTRECEIVED: %d, MSG: %x%x, STAT: %c %c %c, OVERTIME: %d.\n", t, size, ((int *)&msg)[1], ((int *)&msg)[0], mstat[0], mstat[1], bstat, (int)(rt_get_cpu_time_ns() - time));
goto prem;
}
if (msg != 0xccccccccccccccccLL) {
rt_printk("WRONG REPLY TO TASK: %d, MSG: %x %x.\n", t, ((int *)&msg)[0], ((int *)&msg)[1]);
goto prem;
}
mstat[t] = 'd';
if ((itime = rt_get_cpu_time_ns() - time) > maxt) {
rt_printk("TASK: %d, MAXWAITIME: %d.\n", t, maxt = itime);
}
meant[t] = (itime + meant[t]) >> 1;
rt_sleep(nano2count(SLEEP_TIME));
}
prem:
premature = PREMATURE;
rt_printk("TASK # %d ENDS PREMATURELY\n", t);
}
static void Task7(long t)
{
int unsent;
MSG msg;
rt_printk("\nTask7 (%p) starting\n", rt_whoami());
while (count < MAXCOUNT) {
count++;
msg.progressive = count;
msg.sending_task = 7;
unsent = rt_tbx_urgent_timed(&bx, (char*)&msg, sizeof(msg),nano2count(TIMEOUT));
if (unsent != 0) {
rt_printk("\nTask7 urgent sending timed out");
} else {
rt_printk("\nTask7=%lu, urgent sending, unsent=%d\n", count, unsent);
}
rt_sleep(nano2count(3*DELAY + 2*SHIFT));
}
rt_printk("\nTask7 suspends itself\n");
cleanup = 1;
rt_task_suspend(rt_whoami());
}
static void SomeOtherThingsTodo( void *var1, int var2 )
{
// This function acts like a synchronous thread.
// Function rt_qReceive(...) does whatever is necessary to receive proxies,
// messages and schedule the execution of both static and dynamic QBLK's.
rt_printk( "QBLK Says: Hello World\n" );
count++;
// Reschedule for execution in one second.
if(count < 12) rt_qBlkWait( &Main, nano2count( 1000000000 ));
else rt_task_suspend(rt_whoami());
}
int init_module(void)
{
rt_bits_init(&bits, 0xFFFF0000);
rt_task_init(&task0, fun0, 0, STACK_SIZE, 0, 0, 0);
rt_task_init(&task1, fun1, 0, STACK_SIZE, 0, 0, 0);
rt_task_init(&task, fun, 0, STACK_SIZE, 0, 0, 0);
rt_set_oneshot_mode();
start_rt_timer(nano2count(SLEEP_TIME));
rt_task_resume(&task0);
rt_task_resume(&task1);
rt_task_resume(&task);
return 0;
}
void seqh(unsigned long data)
{
switch (opcod) {
case 0: {
rt_printk("- SEQUENCER FIRED FOR A FAST POLLING\n");
rt_insert_timer(seqt, 10, rt_get_time() + nano2count(500000), nano2count(500000), seqh, 0, 1);
opcod = 1;
}
break;
case 1: {
if (poloops++ < LOOPS) {
if (poloops == 1) {
rt_printk("- SEQUENCER BEGINS FAST POLLING\n");
}
} else {
rt_printk("- SEQUENCER FAST POLLING ENDED, TIMED FOR A LATER FINAL OPERATION\n");
rt_set_timer_firing_time(seqt, rt_get_time() + nano2count(50000000));
opcod = 2;
}
}
break;
case 2: {
rt_printk("- SEQUENCER EXECUTES FINAL OPERATION, ... THEN\n SLOWLY POLLS WAITING FOR THE END OF THE PERIODIC COMPUTATIONAL TASKLET\n");
opcod = 3;
}
break;
case 3: {
if (endp) {
rt_printk("- PERIODIC COMPUTATIONAL TASKLET GONE, SEQUENCER ENDS IT ALL\n");
rt_remove_timer(seqt);
end = 1;
} else {
// rt_printk("\nSEQUENCER WAITING FOR PERIODIC TIMER END");
}
}
break;
}
}
static void Task4(long t)
{
int wakedup;
rt_printk("\nTask4 (%p) starting\n", rt_whoami());
while (count < MAXCOUNT) {
count++;
wakedup = rt_tbx_broadcast(&bx, msg2, sizeof(msg2));
rt_printk("\nTask4=%lu, sending broadcast, wakedup=%d\n", count, wakedup);
rt_sleep(nano2count(DELAY + SHIFT));
}
rt_printk("\nTask4 suspends itself\n");
rt_task_suspend(rt_whoami());
}
int usleep(unsigned long useconds)
{
#ifdef _SYSTEM_LXRT_
if (isThisLxrtTask())
{
rt_sleep(nano2count(RTIME(1000*useconds)));
return 0;
}
else
#endif
{
return ::usleep(useconds);
}
}
static void Task1(long t)
{
int unsent;
rt_printk("\nTask1 (%p) starting\n", rt_whoami());
while (count < MAXCOUNT) {
count++;
unsent = rt_tbx_send(&bx, msg1, sizeof(msg1));
rt_printk("\nTask1=%lu, simple sending, unsent=%d %d\n", count, unsent, sizeof(msg1));
rt_sleep(nano2count(DELAY));
}
rt_printk("\nTask1 suspends itself\n");
rt_task_suspend(rt_whoami());
}
int init_module(void)
{
rt_typed_mbx_init(&smbx, 5, MBX_TYPE); //5
rt_typed_mbx_init(&rmbx[0], 1, MBX_TYPE); //1
rt_typed_mbx_init(&rmbx[1], 3, MBX_TYPE); //3
rt_task_init(&btask, bfun, 0, STACK_SIZE, 0, 0, 0);
rt_task_init(&mtask[0], mfun, 0, STACK_SIZE, 1, 0, 0);
rt_task_init(&mtask[1], mfun, 1, STACK_SIZE, 1, 0, 0);
rt_set_oneshot_mode();
start_rt_timer(nano2count(SLEEP_TIME));
rt_task_resume(&btask);
rt_task_resume(&mtask[0]);
rt_task_resume(&mtask[1]);
return 0;
}
int rtos_sem_wait_until(rt_sem_t* m, NANO_TIME when )
{
int ret;
CHK_LXRT_CALL();
ret = rt_sem_wait_until(m->sem, nano2count(when) ) ;
#if defined(CONFIG_RTAI_VERSION_MINOR) && defined(CONFIG_RTAI_VERSION_MAJOR)
# if CONFIG_RTAI_VERSION_MAJOR == 3 && CONFIG_RTAI_VERSION_MINOR > 3
return (ret == RTE_TIMOUT) ? -1 : 0;
# else
return (ret == SEM_TIMOUT) ? -1 : 0;
# endif
#else
return (ret == SEM_TIMOUT) ? -1 : 0;
#endif
}
static void Task7(long t)
{
int unsent;
rt_printk("\nTask7 (%p) starting\n", rt_whoami());
while (count < MAXCOUNT) {
count++;
unsent = rt_tbx_urgent(&bx, msg3, sizeof(msg3));
rt_printk("\nTask7=%lu, urgent sending, unsent=%d\n", count, unsent);
rt_sleep(nano2count(3*DELAY + 2*SHIFT));
}
rt_printk("\nTask7 suspends itself\n");
cleanup = 1;
rt_task_suspend(rt_whoami());
}
static void signalSan(long t)
{
while (1)
{
rt_sem_wait(&rMutex);
rt_printk(KERN_INFO "TESTE - Signal 3\n");
rt_sleep(nano2count(TICK * 6));
rt_sem_signal(&rMutex);
rt_task_wait_period();
}
}
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 mfun(int t)
{
char tname[6] = "MFUN", mname[6] = "RMBX";
RT_TASK *mytask;
int msg[MAXSIZ + 1], mtype, i;
void *smbx, *rmbx;
randu();
tname[4] = mname[4] = t + '0';
tname[5] = mname[5] = 0;
mytask = rt_thread_init(nam2num(tname), t + 1, 0, SCHED_FIFO, 0xF);
smbx = rt_msgq_init(nam2num("SMSG"), 0, 0);
rmbx = rt_msgq_init(nam2num(mname), 0, 0);
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
msg[0] = t;
rt_sem_wait_barrier(barrier);
while (end < t) {
msg[MAXSIZ] = 0;
for (i = 1; i < MAXSIZ; i++) {
msg[MAXSIZ] += (msg[i] = MAXSIZ*randu());
}
if (rt_msg_send(smbx, msg, sizeof(msg), 1)) {
rt_printk("SEND FAILED, TASK: %d\n", t);
goto prem;
}
msg[0] = msg[1] = 0;
if (rt_msg_receive(rmbx, msg, sizeof(msg), &mtype) < 0) {
rt_printk("RECEIVE FAILED, TASK: %d\n", t);
goto prem;
}
if (msg[0] != t || msg[1] != 0xFFFFFFFF || mtype != RETPRIO) {
rt_printk("WRONG REPLY TO TASK: %d.\n", t);
goto prem;
}
cnt[t]++;
// rt_printk("TASK: %d, OK (%d).\n", t, cnt[t]);
rt_sleep(nano2count(SLEEP_TIME));
}
prem:
rt_msgq_delete(rmbx);
rt_msgq_delete(smbx);
rt_make_soft_real_time();
rt_task_delete(mytask);
printf("TASK %d ENDS.\n", t);
}
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 Task3(long t)
{
int status;
MSG buf;
rt_printk("\nTask3 (%p) starting\n", rt_whoami());
while (count < MAXCOUNT) {
memset((char*)&buf, 0, sizeof(buf));
status = rt_tbx_receive_if(&bx, (char*)&buf, sizeof(buf));
if (status == 0) {
rt_printk("\nTask3 received msgnr %u from task %u, status=%d\n", buf.progressive, buf.sending_task, status);
}
rt_sleep(nano2count(TIMEBASE));
}
rt_printk("\nTask3 suspends itself\n");
rt_task_suspend(rt_whoami());
}
static void Task1(long t)
{
int unsent;
MSG msg;
rt_printk("\nTask1 (%p) starting\n", rt_whoami());
while (count < MAXCOUNT) {
count++;
msg.progressive = count;
msg.sending_task = 1;
unsent = rt_tbx_send_if(&bx, (char*)&msg, sizeof(msg));
rt_printk("\nTask1=%lu, simple sending, unsent=%d\n", count, unsent);
rt_sleep(nano2count(DELAY));
}
rt_printk("\nTask1 suspends itself\n");
rt_task_suspend(rt_whoami());
}
int init_module(void)
{
int ret;
RTIME tick_period;
unsigned int local_ip = rt_inet_aton(local_ip_s);
unsigned int server_ip = rt_inet_aton(server_ip_s);
if (interval < 1) interval = 1;
if (interval > 1000) interval = 1000;
if (packetsize < 1) packetsize = 1;
if (packetsize > 1400) packetsize = 1400;
printk ("***** start of rt_client ***** %s %s *****\n", __DATE__, __TIME__);
printk ("local ip address %s=%08x\n", local_ip_s, local_ip);
printk ("server ip address %s=%08x\n", server_ip_s, server_ip);
printk ("interval = %d\n", interval);
printk ("packetsize = %d\n", packetsize);
rtf_create(PRINT, 8000);
/* create rt-socket */
sock=rt_socket(AF_INET,SOCK_DGRAM,0);
/* bind the rt-socket to local_addr */
memset(&local_addr, 0, sizeof(struct sockaddr_in));
local_addr.sin_family = AF_INET;
local_addr.sin_port = htons(RCV_PORT);
local_addr.sin_addr.s_addr = local_ip;
ret=rt_socket_bind(sock, (struct sockaddr *) &local_addr, sizeof(struct sockaddr_in));
/* set server-addr */
memset(&server_addr, 0, sizeof(struct sockaddr_in));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SRV_PORT);
server_addr.sin_addr.s_addr = server_ip;
/* set up receiving */
rt_socket_callback(sock, echo_rcv, NULL);
tick_period = start_rt_timer(nano2count(TICK_PERIOD));
ret=rt_task_init(&rt_task,(void *)process,0,4096,0,0,NULL);
ret=rt_task_make_periodic_relative_ns( &rt_task, 1000000, (RTIME) interval * 1000000);
return 0;
}
