void *CommandClock_task(void *args)
{
RT_TASK *mytask;
unsigned long command;
char R = 'R';
int ackn = 0;
RT_TASK *get = (RT_TASK *)0, *put = (RT_TASK *)0, *task;
if (!(mytask = rt_thread_init(nam2num("CLKTSK"), 1, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT TASK CommandClock_task\n");
exit(1);
}
printf("INIT TASK CommandClock_task %p.\n", mytask);
mlockall(MCL_CURRENT | MCL_FUTURE);
Clockstatus = stopped;
while (ackn != ('a' + 'b')) {
task = rt_receive((RT_TASK *)0, &command);
switch (command) {
case 'b':
get = task;
ackn += command;
break;
case 'a':
put = task;
ackn += command;
break;
}
}
rt_return(put, command);
rt_return(get, command);
while(1) {
switch (Clockstatus) {
case stopped:
rt_receive(put, &command);
if (command == 'R') {
Clockstatus = running;
}
break;
case running:
if (rt_receive_if(put, &command)) {
if (command == 'T') {
Clockstatus = stopped;
}
} else {
command = R;
}
break;
}
rt_send(get, command);
if (command == 'F') {
goto end;
}
}
end:
rt_task_delete(mytask);
printf("END TASK CommandClock_task %p.\n", mytask);
return 0;
}
static void Display_task(long t)
{
unsigned long command;
int ackn = 0;
RT_TASK *get = (RT_TASK *)0, *tput = (RT_TASK *)0, *hput = (RT_TASK *)0, *task;
while (ackn != ('g' + 'p' + 'P')) {
task = rt_receive((RT_TASK *)0, &command);
switch (command) {
case 'g':
get = task;
ackn += command;
break;
case 'p':
tput = task;
ackn += command;
break;
case 'P':
hput = task;
ackn += command;
break;
}
}
rt_return(get, command);
rt_return(tput, command);
rt_return(hput, command);
while(1) {
cpu_used[hard_cpu_id()]++;
task = rt_receive(0, &command);
if (task == tput || task == hput) {
rt_send(get, command);
}
}
}
static void CommandChrono_task(long t)
{
RTIME fiveSeconds = nano2count(FIVE_SECONDS);
unsigned long command;
unsigned int buffered = 0;
unsigned int C = 'C';
unsigned int R = 'R';
int ackn = 0;
RT_TASK *get = (RT_TASK *)0, *put = (RT_TASK *)0, *task;
Chronostatus = stoppedInitial;
while (ackn != ('c' + 'd')) {
task = rt_receive((RT_TASK *)0, &command);
switch (command) {
case 'd':
get = task;
ackn += command;
break;
case 'c':
put = task;
ackn += command;
break;
}
}
rt_return(put, command);
rt_return(get, command);
while(1) {
cpu_used[hard_cpu_id()]++;
switch (Chronostatus) {
case stoppedInitial:
if (buffered) {
command = buffered;
buffered = 0;
} else {
rt_receive(put, &command);
}
Chronostatus = running;
break;
case running:
if (rt_receive_if(put, &command)) {
if (command == 'E') {
Chronostatus = stoppedFinal;
}
} else {
command = C;
}
break;
case stoppedFinal:
Chronostatus = stoppedInitial;
if (rt_receive_timed(put, &command, fiveSeconds) > 0) {
buffered = command;
}
command = R;
break;
}
rt_send(get, command);
}
}
void taskm_func(long tid)
{
unsigned int msg = 0;
rt_receive(0, &msg);
rt_send(&taskl, msg);
while (1) {
rt_receive(&taskl, &msg);
rt_send(&taskh, msg);
rt_busy_sleep(5000000);
}
}
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;
}
void *Display_task(void *args)
{
RT_TASK *mytask;
unsigned long command;
int ackn = 0;
RT_TASK *get = (RT_TASK *)0, *tput = (RT_TASK *)0, *hput = (RT_TASK *)0, *task;
if (!(mytask = rt_thread_init(nam2num("DSPTSK"), 1, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT TASK Display_task\n");
exit(1);
}
printf("INIT TASK Display_task %p.\n", mytask);
mlockall(MCL_CURRENT | MCL_FUTURE);
while (ackn != ('g' + 'p' + 'P')) {
task = rt_receive((RT_TASK *)0, &command);
switch (command) {
case 'g':
get = task;
ackn += command;
break;
case 'p':
tput = task;
ackn += command;
break;
case 'P':
hput = task;
ackn += command;
break;
}
}
rt_return(get, command);
rt_return(tput, command);
rt_return(hput, command);
while(1) {
task = rt_receive(0, &command);
if (task == tput || task == hput) {
rt_send(get, command);
if (((char *)command)[1] == 101) {
goto end;
}
}
}
end:
rt_task_delete(mytask);
printf("END TASK Display_task %p.\n", mytask);
return 0;
}
int main(void)
{
RT_TASK *Main_Task;
long msg;
if (!(Main_Task = rt_thread_init(nam2num("MNTSK"), 10, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT MAIN TASK\n");
exit(1);
}
if (!(hard_timer_running = rt_is_hard_timer_running())) {
start_rt_timer(0);
}
barrier = rt_sem_init(nam2num("PREMS"), 4);
latency_thread = rt_thread_create(latency_fun, NULL, 0);
fast_thread = rt_thread_create(fast_fun, NULL, 0);
slow_thread = rt_thread_create(slow_fun, NULL, 0);
start = rt_get_time() + nano2count(200000000);
rt_sem_wait_barrier(barrier);
rt_receive(0, &msg);
end = 1;
rt_sem_wait_barrier(barrier);
rt_thread_join(latency_thread);
rt_thread_join(fast_thread);
rt_thread_join(slow_thread);
if (!hard_timer_running) {
stop_rt_timer();
}
rt_sem_delete(barrier);
rt_thread_delete(Main_Task);
return 0;
}
void taskh_func(long tid)
{
RTIME time;
unsigned int msg = 0, wait;
rt_send(&taskm, msg);
rt_send(&taskl, msg);
while (1) {
rt_receive(&taskm, &msg);
time = rt_get_time_ns();
if (MUTEX_LOCK(&mutex) <= 1) {
if ((wait = (int)(rt_get_time_ns() - time)) > 250000) {
rt_printk("PRIORITY INVERSION, WAITED FOR %d us\n", wait/1000);
} else {
rt_printk("NO PRIORITY INVERSION, WAITED FOR %d us\n", wait/1000);
}
if (SemType) {
MUTEX_LOCK(&mutex);
MUTEX_LOCK(&mutex);
rt_busy_sleep(100000);
MUTEX_LOCK(&mutex);
}
rt_busy_sleep(100000);
if (SemType) {
rt_sem_signal(&mutex);
rt_busy_sleep(100000);
rt_sem_signal(&mutex);
rt_sem_signal(&mutex);
}
rt_sem_signal(&mutex);
} else {
rt_task_suspend(0);
}
}
}
static void driver(int t)
{
RT_TASK *thread[NTASKS];
int i, l;
unsigned int msg = 0;
RTIME now;
for (i = 1; i < NTASKS; i++) {
thread[0] = rt_receive(0, &msg);
thread[msg] = thread[0];
}
for (i = 1; i < NTASKS; i++) {
rt_return(thread[i], i);
}
now = rt_get_time();
rt_task_make_periodic(rt_whoami(), now + NTASKS*tick_period, tick_period);
msg = 0;
l = LOOPS;
while(l--) {
for (i = 1; i < NTASKS; i++) {
cpu_used[hard_cpu_id()]++;
if (i%2) {
rt_rpc(thread[i], msg, &msg);
} else {
rt_send(thread[i], msg);
msg = 1 - msg;
}
rt_task_wait_period();
}
}
for (i = 1; i < NTASKS; i++) {
rt_send(thread[i], END);
}
}
void *thread_fun(void *arg)
{
RTIME start_time, period;
RTIME t0, t;
SEM *sem;
RT_TASK *mytask;
unsigned long mytask_name;
int mytask_indx, jit, maxj, maxjp, count;
mytask_indx = *((int *)arg);
mytask_name = taskname(mytask_indx);
cpus_allowed = 1 - cpus_allowed;
if (!(mytask = rt_task_init_schmod(mytask_name, 1, 0, 0, SCHED_FIFO, 1 << cpus_allowed))) {
printf("CANNOT INIT TASK %lu\n", mytask_name);
exit(1);
}
printf("THREAD INIT: index = %d, name = %lu, address = %p.\n", mytask_indx, mytask_name, mytask);
mlockall(MCL_CURRENT | MCL_FUTURE);
if (!(mytask_indx%2)) {
rt_make_hard_real_time();
}
rt_receive(0, (unsigned long *)((void *)&sem));
period = nano2count(PERIOD);
start_time = rt_get_time() + nano2count(10000000);
rt_task_make_periodic(mytask, start_time + (mytask_indx + 1)*period, ntasks*period);
// start of task body
{
count = maxj = 0;
t0 = rt_get_cpu_time_ns();
while(count++ < LOOPS) {
rt_task_wait_period();
t = rt_get_cpu_time_ns();
if ((jit = t - t0 - ntasks*(RTIME)PERIOD) < 0) {
jit = -jit;
}
if (count > 1 && jit > maxj) {
maxj = jit;
}
t0 = t;
// rtai_print_to_screen("THREAD: index = %d, count %d\n", mytask_indx, count);
}
maxjp = (maxj + 499)/1000;
}
// end of task body
rt_sem_signal(sem);
if (!(mytask_indx%2)) {
rt_make_soft_real_time();
}
rt_task_delete(mytask);
printf("THREAD %lu ENDS, LOOPS: %d MAX JIT: %d (us)\n", mytask_name, count, maxjp);
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;
}
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;
}
void CommandChrono_Get(char *command)
{
static RT_TASK *ackn = 0;
unsigned int get = 'd';
unsigned long msg;
if (ackn != &Chrono) {
ackn = rt_rpc(&Chrono, get, &msg);
}
rt_receive(&Chrono, &msg);
*command = (char)msg;
}
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 *thread_fun(void *arg)
{
int mytask_indx;
unsigned long msg;
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
mytask_indx = ((int *)arg)[0];
if (!(mytask[mytask_indx] = rt_thread_init(taskname(mytask_indx), 0, 0,
SCHED_FIFO, 0x1))) {
printf("CANNOT INIT TASK %u\n", taskname(mytask_indx));
exit(1);
}
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
hrt[mytask_indx] = 1;
while (!end) {
switch (change) {
case 0:
rt_task_suspend(mytask[mytask_indx]);
break;
case 1:
rt_sem_wait(sem);
break;
case 2:
rt_receive(NULL, &msg);
break;
case 3:
rt_return(rt_receive(NULL, &msg), 0);
break;
}
}
rt_make_soft_real_time();
rt_task_delete(mytask[mytask_indx]);
hrt[mytask_indx] = 0;
return (void*)0;
}
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 Display_Get(MenageHmsh_tChain11 *chain, Display_tDest *receiver)
{
static RT_TASK *ackn = 0;
unsigned int get = 'g';
unsigned long msg;
if (ackn != &Display) {
ackn = rt_rpc(&Display, get, &msg);
}
rt_receive(&Display, &msg);
*chain = *((MenageHmsh_tChain11 *)msg);
*receiver = chain->chain[0] == 't' ? destChrono : destClock;
}
static void fun(int t)
{
unsigned int msg;
rt_rpc(&thread[0], t, &msg);
while(msg != END) {
cpu_used[hard_cpu_id()]++;
rt_receive(&thread[0], &msg);
rt_leds_set_mask(1,msg);
if (rt_isrpc(&thread[0])) {
rt_return(&thread[0], 1 - msg);
}
}
rt_leds_set_mask(1,0);
}
void taskl_func(long tid)
{
unsigned int msg = 0;
rt_receive(0, &msg);
rt_receive(0, &msg);
while (MUTEX_LOCK(&mutex) <= 1) {
if (SemType) {
MUTEX_LOCK(&mutex);
rt_busy_sleep(100000);
MUTEX_LOCK(&mutex);
}
rt_send(&taskm, msg);
rt_busy_sleep(100000);
if (SemType) {
rt_sem_signal(&mutex);
rt_busy_sleep(100000);
rt_sem_signal(&mutex);
}
rt_sem_signal(&mutex);
rt_sleep(nano2count(500000000));
}
rt_task_suspend(0);
}
static void pend_task (long t)
{
unsigned long msg;
while(1) {
switch (change) {
case 0:
rt_task_suspend(thread + t);
break;
case 1:
rt_sem_wait(&sem);
break;
case 2:
rt_return(rt_receive(NULL, &msg), 0);
break;
}
cpu_used[hard_cpu_id()]++;
}
}
pid_t rt_Receive(pid_t pid, void *msg, size_t maxsize, size_t *msglen)
{
RT_TASK *task;
MSGCB *cb;
task = pid ? pid2rttask(pid) : 0;
if ((task = rt_receive(task, (unsigned int *)&cb))) {
if ((pid = rttask2pid(task))) {
*msglen = maxsize <= cb->sbytes ? maxsize : cb->sbytes;
if (*msglen) {
memcpy(msg, cb->sbuf, *msglen);
}
return pid;
}
return -ESRCH;
}
return -EINVAL;
}
static void ClockChrono_Clock(long t)
{
RTIME OneUnit = nano2count(ONE_UNIT);
const int hundredthes = FALSE;
MenageHmsh_tHour hour;
MenageHmsh_tChain11 hourChain;
char command;
BOOLEAN display;
unsigned long msg;
rt_receive(&read, &msg);
MenageHmsh_Initialise(&hour);
MenageHmsh_Convert(hour, hundredthes, &hourChain);
Display_PutHour(hourChain);
while(1) {
cpu_used[hard_cpu_id()]++;
CommandClock_Get(&command);
switch(command) {
case 'R':
rt_fractionated_sleep(OneUnit);
MenageHmsh_PlusOneUnit(&hour, &display);
break;
case 'T':
MenageHmsh_InitialiseHundredthes(&hour);
display = FALSE;
break;
case 'H':
MenageHmsh_AdvanceHours(&hour);
display = TRUE;
break;
case 'M':
MenageHmsh_AdvanceMinutes(&hour);
display = TRUE;
break;
case 'S':
MenageHmsh_AdvanceSeconds(&hour);
display = TRUE;
}
if (display) {
MenageHmsh_Convert(hour, hundredthes, &hourChain);
Display_PutHour(hourChain);
}
}
}
int main(void)
{
int i, k, prio, bprio;
task[0] = rt_task_init_schmod(0, NTASKS - 1, 0, 0, SCHED_FIFO, CPUS_ALLOWED);
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
for (i = 0; i < NTASKS; i++) {
sem[i] = rt_typed_sem_init(0, RESEMT, RES_SEM);
}
rt_sem_wait(sem[0]);
for (i = 1; i < NTASKS; i++) {
rt_thread_create(tskfun, (void *)i, 0);
rt_receive(NULL, &k);
rt_printk("AFTER TSKNR %d CREATED > (TSKNR-PRI):\n", i);
for (k = 0; k < i; k++) {
rt_get_priorities(task[k], &prio, &bprio);
rt_printk("%d-%d|", k, prio);
}
rt_get_priorities(task[i], &prio, &bprio);
rt_printk("%d-%d\n\n", i, prio);
}
rt_sem_signal(sem[0]);
rt_printk("FINAL > (TSKNR-PRI):\n");
for (k = 0; k < (NTASKS - 1); k++) {
rt_get_priorities(task[k], &prio, &bprio);
rt_printk("%d-%d|", k, prio);
}
rt_get_priorities(task[NTASKS - 1], &prio, &bprio);
rt_printk("%d-%d\n\n", (NTASKS - 1), prio);
for (i = 0; i < NTASKS; i++) {
rt_sem_delete(sem[i]);
}
return 0;
}
static void *rt_HostInterface(void *args)
{
RT_TASK *task;
unsigned int Request;
int Reply, len;
char nome[8];
if (!(rt_HostInterfaceTask = rt_task_init_schmod(nam2num(HostInterfaceTaskName), rt_HostInterfaceTaskPriority, 0, 0, SCHED_RR, 0xFF))) {
fprintf(stderr,"Cannot init rt_HostInterfaceTask.\n");
return (void *)1;
}
sem_post(&err_sem);
while (!endInterface) {
task = rt_receive(0, &Request);
num2nam(rt_get_name(task),nome);
if (endInterface) break;
switch (Request & 0xFF) {
case 'c': {
int i ,Idx, idx[2];
rtTargetParamInfo rtParam;
float samplingTime;
int NPAR,i1,i2;
mxp_t pardata;
double value;
strncpyz(rtParam.modelName, modelname, MAX_NAME_SIZE);
rtParam.dataType = 0;
NPAR = mxp_getnvars();
rt_return(task, (isRunning << 16) | ( NPAR & 0xFFFF ));
rt_receivex(task, &Request, 1, &len);
rt_returnx(task, &rtParam, sizeof(rtParam));
for (i = 0; i < NPAR; i++) {
sprintf(rtParam.blockName,"%s/%s",rtParam.modelName,"Tunable Parameters");
mxp_getvarbyidx(i, &pardata);
if ( pardata.ndim == 0 ){
rt_receivex(task,&Request,1,&len);
sprintf(rtParam.paramName, pardata.name);
mxp_getparam(i,idx, &value);
rtParam.dataValue[0] = value;
rtParam.dataClass = rt_SCALAR;
rtParam.nRows = 1;
rtParam.nCols = 1;
rt_returnx(task, &rtParam, sizeof(rtParam));
}
if ( pardata.ndim == 1 ){
rt_receivex(task,&Request,1,&len);
sprintf(rtParam.paramName, pardata.name);
rtParam.dataClass = rt_VECTOR;
rtParam.nRows = 1;
rtParam.nCols = pardata.dim[0];
for (i1 = 0; i1 < pardata.dim[0] ; i1++){
idx[0] = i1;
mxp_getparam(i,idx, &value);
rtParam.dataValue[i1] = value;
}
rt_returnx(task, &rtParam, sizeof(rtParam));
}
if ( pardata.ndim == 2 ){
rt_receivex(task,&Request,1,&len);
sprintf(rtParam.paramName, pardata.name);
rtParam.dataClass = rt_MATRIX_ROW_MAJOR;
rtParam.nRows = pardata.dim[0];
rtParam.nCols = pardata.dim[1];
for (i1 = 0; i1 < pardata.dim[0] ; i1++){
for (i2 = 0; i2 < pardata.dim[1] ; i2++){
idx[0] = i1;
idx[1] = i2;
mxp_getparam(i,idx, &value);
rtParam.dataValue[i1*rtParam.nCols+i2] = value;
}
}
rt_returnx(task, &rtParam, sizeof(rtParam));
}
if (pardata.ndim > 2){
fprintf(stderr,"MAX PARAMETER DIMESION = 2........\n");
}
}
while (1) {
rt_receivex(task, &Idx, sizeof(int), &len);
if (Idx < 0) {
rt_returnx(task, &Idx, sizeof(int));
break;
} else {
rt_returnx(task, &rtaiScope[Idx].ntraces, sizeof(int));
rt_receivex(task, &Idx, sizeof(int), &len);
rt_returnx(task, rtaiScope[Idx].name, MAX_NAME_SIZE);
rt_receivex(task, &Idx, sizeof(int), &len);
samplingTime = get_tsamp();
rt_returnx(task, &samplingTime, sizeof(float));
}
}
while (1) {
rt_receivex(task, &Idx, sizeof(int), &len);
if (Idx < 0) {
rt_returnx(task, &Idx, sizeof(int));
break;
} else {
rt_returnx(task, &rtaiLogData[Idx].nrow, sizeof(int));
rt_receivex(task, &Idx, sizeof(int), &len);
rt_returnx(task, &rtaiLogData[Idx].ncol, sizeof(int));
rt_receivex(task, &Idx, sizeof(int), &len);
rt_returnx(task, rtaiLogData[Idx].name, MAX_NAME_SIZE);
rt_receivex(task, &Idx, sizeof(int), &len);
samplingTime = get_tsamp();
rt_returnx(task, &samplingTime, sizeof(float));
}
}
while (1) {
rt_receivex(task, &Idx, sizeof(int), &len);
if (Idx < 0) {
rt_returnx(task, &Idx, sizeof(int));
break;
} else {
rt_returnx(task, &rtaiALogData[Idx].nrow, sizeof(int));
rt_receivex(task, &Idx, sizeof(int), &len);
rt_returnx(task, &rtaiALogData[Idx].ncol, sizeof(int));
rt_receivex(task, &Idx, sizeof(int), &len);
rt_returnx(task, rtaiALogData[Idx].name, MAX_NAME_SIZE);
rt_receivex(task, &Idx, sizeof(int), &len);
samplingTime = get_tsamp();
rt_returnx(task, &samplingTime, sizeof(float));
}
}
while (1) {
rt_receivex(task, &Idx, sizeof(int), &len);
if (Idx < 0) {
rt_returnx(task, &Idx, sizeof(int));
break;
} else {
rt_returnx(task, &rtaiLed[Idx].nleds, sizeof(int));
rt_receivex(task, &Idx, sizeof(int), &len);
rt_returnx(task, rtaiLed[Idx].name, MAX_NAME_SIZE);
rt_receivex(task, &Idx, sizeof(int), &len);
samplingTime = get_tsamp();
rt_returnx(task, &samplingTime, sizeof(float));
}
}
while (1) {
rt_receivex(task, &Idx, sizeof(int), &len);
if (Idx < 0) {
rt_returnx(task, &Idx, sizeof(int));
break;
} else {
rt_returnx(task, rtaiMeter[Idx].name, MAX_NAME_SIZE);
rt_receivex(task, &Idx, sizeof(int), &len);
samplingTime = get_tsamp();
rt_returnx(task, &samplingTime, sizeof(float));
}
}
while (1) {
rt_receivex(task, &Idx, sizeof(int), &len);
if (Idx < 0) {
rt_returnx(task, &Idx, sizeof(int));
break;
} else {
rt_returnx(task, "", MAX_NAME_SIZE);
rt_receivex(task, &Idx, sizeof(int), &len);
samplingTime = get_tsamp();
rt_returnx(task, &samplingTime, sizeof(float));
}
}
break;
}
case 's': {
rt_task_resume(rt_MainTask);
rt_return(task, 1);
break;
}
case 't': {
endex = 1;
rt_return(task, 0);
break;
}
case 'p': {
int index;
double param;
int mat_ind,Idx[2];
mxp_t pardata;
rt_return(task, isRunning);
rt_receivex(task, &index, sizeof(int), &len);
Reply = 0;
rt_returnx(task, &Reply, sizeof(int));
rt_receivex(task, ¶m, sizeof(double), &len);
Reply = 1;
rt_returnx(task, &Reply, sizeof(int));
rt_receivex(task, &mat_ind, sizeof(int), &len);
mxp_getvarbyidx(index, &pardata);
if ( pardata.ndim == 1 ) Idx[0] = mat_ind;
if ( pardata.ndim == 2 ){
Idx[0] = mat_ind/pardata.dim[1];
Idx[1] = mat_ind - Idx[0]*pardata.dim[1];
}
mxp_setparam(index, Idx, param);
rt_returnx(task, &Reply, sizeof(int));
break;
}
case 'g': {
int i, idx[2], i1,i2;
rtTargetParamInfo rtParam;
int NPAR;
mxp_t pardata;
double value;
strncpyz(rtParam.modelName, modelname, MAX_NAME_SIZE);
rtParam.dataType = 0;
NPAR = mxp_getnvars();
rt_return(task, isRunning);
for (i = 0; i < NPAR; i++) {
sprintf(rtParam.blockName,"%s/%s",rtParam.modelName,"Tunable Parameters");
mxp_getvarbyidx(i, &pardata);
if ( pardata.ndim == 0 ){
rt_receivex(task,&Request,1,&len);
sprintf(rtParam.paramName, pardata.name);
mxp_getparam(i,idx, &value);
rtParam.dataValue[0] = value;
rtParam.dataClass = rt_SCALAR;
rtParam.nRows = 1;
rtParam.nCols = 1;
rt_returnx(task, &rtParam, sizeof(rtParam));
}
if ( pardata.ndim == 1 ){
rt_receivex(task,&Request,1,&len);
sprintf(rtParam.paramName, pardata.name);
rtParam.dataClass = rt_VECTOR;
rtParam.nRows = 1;
rtParam.nCols = pardata.dim[0];
for (i1 = 0; i1 < pardata.dim[0] ; i1++){
idx[0] = i1;
mxp_getparam(i,idx, &value);
rtParam.dataValue[i1] = value;
}
rt_returnx(task, &rtParam, sizeof(rtParam));
}
if ( pardata.ndim == 2 ){
rt_receivex(task,&Request,1,&len);
sprintf(rtParam.paramName, pardata.name);
rtParam.dataClass = rt_MATRIX_ROW_MAJOR;
rtParam.nRows = pardata.dim[0];
rtParam.nCols = pardata.dim[1];
for (i1 = 0; i1 < pardata.dim[0] ; i1++){
for (i2 = 0; i2 < pardata.dim[1] ; i2++){
idx[0] = i1;
idx[1] = i2;
mxp_getparam(i,idx, &value);
rtParam.dataValue[i1*rtParam.nCols+i2] = value;
}
}
rt_returnx(task, &rtParam, sizeof(rtParam));
}
}
break;
}
case 'd': {
int ParamCnt;
int Idx[2];
mxp_t pardata;
rt_return(task, isRunning);
rt_receivex(task, &ParamCnt, sizeof(int), &len);
Reply = 0;
rt_returnx(task, &Reply, sizeof(int));
{
struct {
int index;
int mat_ind;
double value;
} Params[ParamCnt];
int i;
rt_receivex(task, &Params, sizeof(Params), &len);
for (i = 0; i < ParamCnt; i++) {
mxp_getvarbyidx(Params[i].index, &pardata);
if ( pardata.ndim == 1 ) Idx[0] = Params[i].mat_ind;
if ( pardata.ndim == 2 ){
Idx[0] = Params[i].mat_ind/pardata.dim[1];
Idx[1] = Params[i].mat_ind - Idx[0]*pardata.dim[1];
}
mxp_setparam(Params[i].index, Idx, Params[i].value);
}
}
Reply = 1;
rt_returnx(task, &Reply, sizeof(int));
break;
}
case 'm': {
float time = SIM_TIME;
rt_return(task, isRunning);
rt_receivex(task, &Reply, sizeof(int), &len);
rt_returnx(task, &time, sizeof(float));
break;
}
case 'b': {
rt_return(task, (unsigned int)rt_BaseRateTask);
break;
}
default : {
break;
}
}
}
rt_task_delete(rt_HostInterfaceTask);
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);
}
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[])
{
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;
}
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;
}
static int rt_Main(int priority)
{
SEM *hard_timers_cnt;
char name[7];
RTIME rt_BaseTaskPeriod;
struct timespec err_timeout;
int i;
rt_allow_nonroot_hrt();
for (i = 0; i < MAX_NTARGETS; i++) {
sprintf(name,"MNT%d",i);
if (!rt_get_adr(nam2num(name))) break;
}
if (!(rt_MainTask = rt_task_init_schmod(nam2num(name), rt_MainTaskPriority, 0, 0, SCHED_RR, 0xFF))) {
fprintf(stderr,"Cannot init rt_MainTask.\n");
return 1;
}
sem_init(&err_sem, 0, 0);
printf("TARGET STARTS.\n");
pthread_create(&rt_HostInterfaceThread, NULL, rt_HostInterface, NULL);
err_timeout.tv_sec = (long int)(time(NULL)) + 1;
err_timeout.tv_nsec = 0;
if ((sem_timedwait(&err_sem, &err_timeout)) != 0) {
fprintf(stderr, "Target is terminated.\n");
goto finish;
}
pthread_create(&rt_BaseRateThread, NULL, rt_BaseRate, &priority);
err_timeout.tv_sec = (long int)(time(NULL)) + 1;
err_timeout.tv_nsec = 0;
if ((sem_timedwait(&err_sem, &err_timeout)) != 0) {
endInterface = 1;
rt_send(rt_HostInterfaceTask, 0);
pthread_join(rt_HostInterfaceThread, NULL);
fprintf(stderr, "Target is terminated.\n");
goto finish;
}
rt_BaseTaskPeriod = (RTIME) (1e9*get_tsamp());
if (InternTimer) {
WaitTimingEvent = (void *)rt_task_wait_period;
if (!(hard_timers_cnt = rt_get_adr(nam2num("HTMRCN")))) {
if (!ClockTick) {
rt_set_oneshot_mode();
start_rt_timer(0);
rt_BaseRateTick = nano2count(rt_BaseTaskPeriod);
}
else {
rt_set_periodic_mode();
rt_BaseRateTick = start_rt_timer(nano2count(rt_BaseTaskPeriod));
}
hard_timers_cnt = rt_sem_init(nam2num("HTMRCN"), 0);
}
else {
rt_BaseRateTick = nano2count(rt_BaseTaskPeriod);
rt_sem_signal(hard_timers_cnt);
}
}
else {
WaitTimingEvent = (void *)DummyWait;
SendTimingEvent = (void *)DummySend;
}
if (verbose) {
printf("Model : %s .\n", modelname);
printf("Executes on CPU map : %x.\n", CpuMap);
printf("Sampling time : %e (s).\n", get_tsamp());
}
{
int msg;
rt_receive(0, &msg);
}
if (WaitToStart) {
if (verbose) {
printf("Target is waiting to start ... ");
fflush(stdout);
}
rt_task_suspend(rt_MainTask);
}
if (verbose) {
printf("Target is running.\n");
}
rt_return(rt_BaseRateTask, 0);
isRunning = 1;
while (!endex && (!FinalTime || SIM_TIME < FinalTime)) {
msleep(POLL_PERIOD);
}
endBaseRate = 1;
if (!InternTimer) {
SendTimingEvent(TimingEventArg);
}
pthread_join(rt_BaseRateThread, NULL);
isRunning = 0;
endInterface = 1;
rt_send(rt_HostInterfaceTask, 0);
if (verbose) {
printf("Target has been stopped.\n");
}
pthread_join(rt_HostInterfaceThread, NULL);
if (InternTimer) {
if (!rt_sem_wait_if(hard_timers_cnt)) {
rt_sem_delete(hard_timers_cnt);
}
}
finish:
for (i=0 ; i<NSCOPE ; i++)
RT_named_mbx_delete(0, 0, rtaiScope[i].mbx);
for (i=0 ; i<NLOGS ; i++)
RT_named_mbx_delete(0, 0, rtaiLogData[i].mbx);
for (i=0 ; i<NLEDS ; i++)
RT_named_mbx_delete(0, 0, rtaiLed[i].mbx);
for (i=0 ; i<NMETERS ; i++)
RT_named_mbx_delete(0, 0, rtaiMeter[i].mbx);
for ( i=0 ; i<MAX_COMEDI_DEVICES ; i++ ){
if ( ComediDev[i] != NULL ){
comedi_close(ComediDev[i]);
}
}
for ( i=0 ; i<N_DATAIN ; i++){
free( ComediDataIn[i].comdev );
}
for ( i=0 ; i<N_DATAOUT ; i++){
free( ComediDataOut[i].comdev );
}
for ( i=0 ; i<N_DIOIN ; i++){
free( ComediDioIn[i].comdev );
}
for ( i=0 ; i<N_DIOOUT ; i++){
free( ComediDioOut[i].comdev );
}
SA_Output_To_File();
rt_task_delete(rt_MainTask);
printf("TARGET ENDS.\n");
return 0;
}
