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;
}
