int main(void)
{
RT_TASK *task;
RTIME now;
int cnt=0;
// make main thread LXRT soft realtime
task = rt_task_init_schmod(nam2num("MYTASK"), 9, 0, 0, SCHED_FIFO, 0xF);
mlockall(MCL_CURRENT | MCL_FUTURE);
// start realtime timer and scheduler
//rt_set_oneshot_mode();
rt_set_periodic_mode();
start_rt_timer(0);
now = rt_get_time() + 10*PERIOD;
rt_task_make_periodic(task, now, PERIOD);
printf("Init mutex and cond.\n");
mutex = rt_sem_init(nam2num("MUTEX"), 1);
if (mutex==0)
printf("Error init mutex\n");
cond = rt_cond_init(nam2num("CONDITION"));
if (cond==0)
printf("Error init cond\n");
thread0 = rt_thread_create(fun0, NULL, 10000);
//thread1 = rt_thread_create(fun1, NULL, 20000);
//rt_sleep(PERIOD);
while (cnt < THRESHOLD) {
rt_task_wait_period();
rt_printk("main: Hello World %d!\n",cnt);
rt_sem_wait(mutex); //now the mutex should have value 0
if (instance_cnt==0) {
rt_sem_signal(mutex); //now the mutex should have vaule 1
rt_printk("worker thread busy!\n");
} else {
instance_cnt++;
rt_cond_signal(cond);
rt_sem_signal(mutex); //now the mutex should have vaule 1
rt_printk("signaling worker thread to start!\n");
}
cnt++;
}
// wait for end of program
printf("TYPE <ENTER> TO TERMINATE\n");
getchar();
// cleanup
stop_rt_timer();
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;
}
static int my_init(void) {
int i, ierr1, ierr2;
rt_typed_sem_init(&semaphore1, 0, BIN_SEM);
rt_typed_sem_init(&semaphore2, 0, BIN_SEM);
rt_set_oneshot_mode();
ierr1 = rt_task_init_cpuid(&tasks[0], task_body1, 0, STACK_SIZE, 1, 0, 0, 0);
ierr2 = rt_task_init_cpuid(&tasks[1], task_body2, 0, STACK_SIZE, 0, 0, 0, 0);
printk("[task 1] init return code %d by program %s\n", ierr1, __FILE__);
printk("[task 2] init return code %d by program %s\n", ierr2, __FILE__);
if (ierr1 == -1 || ierr2 == -1) {
return -1;
}
start_rt_timer(nano2count(TICK_PERIOD));
first_release = rt_get_time();
for (i = 0 ; i < N_TASK ; i++) {
rt_task_make_periodic(&tasks[i], first_release, PERIOD);
}
return 0;
}
int init_module (void)
{
RTIME tick_period;
RTIME now;
#ifdef SHM_DEBUG
int size = SHMSIZ ;
unsigned long vaddr, paddr;
#endif
shm = (int *)rtai_kmalloc(nam2num(SHMNAM), SHMSIZ);
shm = (int *)rtai_kmalloc(nam2num(SHMNAM), SHMSIZ);
shm = (int *)rtai_kmalloc(nam2num(SHMNAM), SHMSIZ);
shm = (int *)rtai_kmalloc(nam2num(SHMNAM), SHMSIZ);
if (shm == NULL)
return -ENOMEM;
memset(shm, 0, SHMSIZ);
#ifdef SHM_DEBUG
/* Show physical addresses of */
vaddr = (unsigned long)shm;
while (size > 0)
{
paddr = kvirt_to_pa(vaddr);
printk("vaddr=0x%lx paddr=0x%lx\n", vaddr, paddr);
vaddr += PAGE_SIZE;
size -= PAGE_SIZE;
}
#endif
rt_task_init(&thread, fun, 0, STACK_SIZE, 0, 0, 0);
tick_period = start_rt_timer(nano2count(TICK_PERIOD));
now = rt_get_time();
rt_task_make_periodic(&thread, now + tick_period, tick_period*PERIOD_COUNT);
return 0;
}
int main(void)
{
RT_TASK *task;
signal(SIGTERM, catch_signal);
signal(SIGINT, catch_signal);
if (!(task = rt_thread_init(nam2num("SWITCH"), 0, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT SWITCH TASK SIGNAL\n");
exit(1);
}
start_rt_timer(0);
rt_request_signal(SWITCH_SIGNAL, switch_handler);
rt_task_signal_handler(task, (void *)SWITCH_SIGNAL);
rt_make_hard_real_time();
while (!end) {
rt_sleep(nano2count(PERIOD));
}
rt_task_signal_handler(task, NULL);
rt_release_signal(SWITCH_SIGNAL, task);
rt_make_soft_real_time();
stop_rt_timer();
rt_task_delete(task);
return 0;
}
static int my_init(void) {
int i;
rt_set_oneshot_mode();
for (i = 0 ; i < N_TASK ; i++) {
int ierr = rt_task_init_cpuid(&tasks[i], task_body, i, STACK_SIZE, Priority[i], 0, 0, 0);
printk("[task %d] init return code %d by program %s\n", i, ierr, __FILE__);
if (ierr == -1) {
return ierr;
}
}
start_rt_timer(nano2count(TICK_PERIOD));
time_unit = calibrate();
first_release = rt_get_time();
for (i = 0 ; i < N_TASK ; i++) {
rt_task_make_periodic(&tasks[i], first_release, Period[i] * time_unit);
}
return 0;
}
int main(void)
{
pthread_setschedparam_np(0, SCHED_FIFO, 0, 0xF, PTHREAD_HARD_REAL_TIME);
start_rt_timer(0);
do_test();
return 0;
}
int main(void)
{
int i, srq, count = 0, nextcount = 0, repeat;
rt_thread_init(nam2num("MNTSK"), 100, 0, SCHED_FIFO, 0x1);
rt_printk("\nTESTING THE SCHEDULER WITH SRQs [%d LOOPs].\n", LOOPS);
repeat = 1000000000LL/((long long)DELAY*(long long)PRINT_FREQ);
srq = rtai_open_srq(0xcacca);
start_rt_timer(0);
rt_grow_and_lock_stack(100000);
#ifdef MAKE_HARD
MAKE_HARD();
#endif
for (i = 0; i < LOOPS; i++) {
rtai_srq(srq, (unsigned long)nano2count(DELAY));
if (++count > nextcount) {
nextcount += repeat;
rt_printk(">>> %d.\n", nextcount);
}
}
rt_make_soft_real_time();
stop_rt_timer();
rt_task_delete(NULL);
rt_printk("END SCHEDULER TEST WITH SRQs.\n\n");
return 0;
}
int main(void)
{
pthread_init_real_time_np("TASKA", 0, SCHED_FIFO, 0xF, PTHREAD_HARD_REAL_TIME);
start_rt_timer(0);
do_test();
return 0;
}
int main(void)
{
struct sched_param mysched;
mysched.sched_priority = sched_get_priority_max(SCHED_FIFO);
if( sched_setscheduler( 0, SCHED_FIFO, &mysched ) == -1 ) {
puts(" ERROR IN SETTING THE SCHEDULER UP");
perror("errno");
exit(0);
}
rt_grow_and_lock_stack(20000);
#ifdef ONE_SHOT
rt_set_oneshot_mode();
#endif
start_rt_timer(nano2count(TICK_PERIOD));
firing_time = rt_get_time();
period = nano2count(1000000);
prt = rt_init_timer();
rt_insert_timer(prt, 1, firing_time, period, prh, 0, 1);
rt_tasklet_use_fpu(prt, 1);
seqt = rt_init_timer();
rt_insert_timer(seqt, 0, firing_time, 0, seqh, 0, 1);
while(!end) sleep(1);
stop_rt_timer();
rt_delete_timer(prt);
rt_delete_timer(seqt);
return 0;
}
int main(void)
{
RT_TASK *spktsk, *plrtsk;
RTIME period;
char buf[BUFSIZE], data, temp;
unsigned int msg, i, len;
printf("\n\nGENERIC RECEIVE\n");
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);
}
rt_set_oneshot_mode();
start_rt_timer(0);
mlockall(MCL_CURRENT | MCL_FUTURE);
printf("\nSPEAKER TASK RUNNING\n");
rt_make_hard_real_time();
period = nano2count(PERIOD);
rt_task_make_periodic(spktsk, rt_get_time() + 5*period, period);
rt_returnx(rt_receivex(0, &msg, sizeof(int), &len), &msg, 1);
for (i = 0; i < 100; i++) {
rt_returnx(rt_receivex(0, &msg, sizeof(int), &len), &msg, 1);
}
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(0, buf, BUFSIZE, &i)) {
// rt_printk("EVDRP %d\n", i);
}
if ((plrtsk = rt_receivex_if(0, buf, BUFSIZE, &len))) {
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_task_delete(spktsk);
printf("\nSPEAKER TASK STOPS\n");
return 0;
}
int realtime_on(void){
int retval;
/*RT_TASK * rt_task_init_schmod(unsigned long name, int priority, int stack_size, int max_msg_size, int policy, int cpus_allowed)*/
if(!(task = rt_task_init_schmod(nam2num("TAREA11"), 1, 0, 0, SCHED_FIFO, 0xF))){
printf("rt_task_init_schmod error\n");
return -1;
}
mlockall( MCL_CURRENT | MCL_FUTURE );
printf("TAREAL EN TIEMPO REAL (name = %lu, address = %p)\n", nam2num("TAREA1"), task);
rt_set_oneshot_mode();
task_period_count = nano2count(task_period_ns);
timer_period_count = start_rt_timer(task_period_count);/*Inicia temporizador*/
printf("\tRequested %d counts, got %d counts\n",(int) task_period_count, (int) timer_period_count);
retval = rt_task_make_periodic(task, rt_get_time() + task_period_count, task_period_count); /* recurring period */
if (0 != retval) {
printf("rt_task_make_periodic error\n");
return -1;
}
rt_make_hard_real_time();
printf("\tPeriodo=%f\n\n",(double)task_period_ns/1e9);
return 1;
}
int main(void)
{
pthread_setschedparam_np(0, SCHED_FIFO, 0, 0x1, PTHREAD_HARD_REAL_TIME_NP);
mlockall(MCL_CURRENT | MCL_FUTURE);
RT_SET_REAL_TIME_MODE();
pthread_cleanup_push(main_exit_handler, 0);
start_rt_timer(nano2count(TICK));
DISPLAY("User space POSIX test program.\n");
pthread_cond_init(cond = &conds, NULL);
pthread_mutex_init(mtx = &mtxs, NULL);
pthread_barrier_init(barrier = &barriers, NULL, 5);
pthread_create(&thread1, NULL, task_func1, NULL);
pthread_create(&thread2, NULL, task_func2, NULL);
pthread_create(&thread3, NULL, task_func3, NULL);
pthread_create(&thread4, NULL, task_func4, NULL);
pthread_barrier_wait(barrier);
DISPLAY("\nDo not panic, wait 2 s, till task3 times out.\n\n");
pthread_barrier_wait(barrier);
pthread_join(thread1, NULL);
pthread_join(thread2, NULL);
pthread_join(thread3, NULL);
pthread_join(thread4, NULL);
pthread_cond_destroy(cond);
pthread_mutex_destroy(mtx);
pthread_cleanup_pop(1);
DISPLAY("User space POSIX test program removed.\n");
pthread_exit(0);
return 0;
}
int init_module(void)
{
RTIME tick_period;
int err;
printk("%s: Loading RX%d Test module...\n", test_name, rt_port);
err = rt_spopen(rt_port,
line_param[0], line_param[1], line_param[2],
line_param[3], line_param[4], line_param[5]);
if (err) return err;
/* Register error handler */
rt_spset_err_callback_fun(rt_port, error_handler);
/* Start RX message handler */
rt_task_init(&thread, rx_handler, 0, STACK_SIZE, 0, 0, 0);
rt_task_resume(&thread);
rt_set_oneshot_mode();
if (period) {
tick_period = start_rt_timer(nano2count(period));
rt_task_make_periodic(&thread, rt_get_time(), tick_period);
}
return 0;
}
int init_module(void)
{
int i;
rt_sem_init(&barrier, NTASKS + 1);
smbx = rt_msgget(nam2num("SMSG"), 0x666 | IPC_CREAT);
for (i = 0; i < NTASKS; i++) {
char mname[6] = "RMBX";
mname[4] = i + '0';
mname[5] = 0;
rmbx[i] = rt_msgget(nam2num(mname), 0x666 | IPC_CREAT);
}
rt_set_oneshot_mode();
start_rt_timer(0);
rt_kthread_init(&bthread, bfun, 0, 0x8000, 1, 1, 0);
rt_task_resume(&bthread);
for (i = 0; i < NTASKS; i++) {
rt_kthread_init(&mthread[i], mfun, i, 0x8000, i + 2, 1, 0);
rt_task_resume(&mthread[i]);
}
return 0;
}
int main(int argc, char *argv[])
{
int fifo, period, skip, average = 0;
RT_TASK *task;
RTIME expected;
if ((fifo = open("/dev/rtf0", O_WRONLY)) < 0) {
printf("Error opening FIFO0 in UCAL\n");
exit(1);
}
if (!(task = rt_task_init_schmod(nam2num("UCAL"), 0, 0, 0, SCHED_FIFO, 0xF))) {
printf("Cannot init UCAL\n");
exit(1);
}
rt_set_oneshot_mode();
period = start_rt_timer(nano2count(atoi(argv[1])));
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
expected = rt_get_time() + 100*period;
rt_task_make_periodic(task, expected, period);
for (skip = 0; skip < atoi(argv[2]); skip++) {
expected += period;
rt_task_wait_period();
average += (int)count2nano(rt_get_time() - expected);
}
rt_make_soft_real_time();
stop_rt_timer();
rt_task_delete(task);
write(fifo, &average, sizeof(average));
close(fifo);
exit(0);
}
int main(void)
{
RT_TASK *maint;
MSG msg = { 0, 0 };
maint = rt_task_init(nam2num("MAIN"), 99, 0, 0);
bx = rt_tbx_init(nam2num("BX"), TBXSIZE, ORDER);
start_rt_timer(nano2count(TIMEBASE));
pthread_create(&pt1, NULL, Task1, NULL);
pthread_create(&pt2, NULL, Task2, NULL);
pthread_create(&pt3, NULL, Task3, NULL);
pthread_create(&pt4, NULL, Task4, NULL);
pthread_create(&pt5, NULL, Task5, NULL);
pthread_create(&pt6, NULL, Task6, NULL);
pthread_create(&pt7, NULL, Task7, NULL);
printf("\ntasks started\n");
pthread_join(pt1, NULL);
pthread_join(pt4, NULL);
pthread_join(pt7, NULL);
endall = 1;
rt_tbx_broadcast(bx, (char*)&msg, sizeof(msg));
pthread_join(pt2, NULL);
pthread_join(pt3, NULL);
pthread_join(pt5, NULL);
pthread_join(pt6, NULL);
rt_tbx_delete(bx);
rt_task_delete(maint);
stop_rt_timer();
printf("\n\nEND\n\n");
return 0;
}
int __init hello_init(void)
{
RTIME sampling;
rt_printk(KERN_INFO "TESTE - *************************** INICIO *******************************\n");
rt_task_init(&Task_1, signalIchi, 0, 3000, 0, 0, NULL);
rt_task_init(&Task_2, signalNi, 0, 3000, 0, 0, NULL);
rt_task_init(&Task_3, signalSan, 0, 3000, 0, 0, NULL);
sampling = start_rt_timer(nano2count(TICK));
rt_sem_init(&rMutex, 1);
rt_task_make_periodic(&Task_1, rt_get_time() + sampling * 16, sampling * 16);
rt_task_make_periodic(&Task_2, rt_get_time() + sampling * 18, sampling * 18);
rt_task_make_periodic(&Task_3, rt_get_time() + sampling * 30, sampling * 30);
rt_change_prio(&Task_1, 2);
rt_change_prio(&Task_2, 1);
rt_change_prio(&Task_3, 3);
rt_printk(KERN_INFO "Init module function\n");
return 0;
}
void _rtapi_clock_set_period_hook(long int nsecs, RTIME *counts,
RTIME *got_counts) {
rt_set_periodic_mode();
*counts = nano2count((RTIME) nsecs);
if(count2nano(*counts) > nsecs) (*counts)--;
*got_counts = start_rt_timer(*counts);
rtapi_data->timer_period = count2nano(*got_counts);
}
int init_module(void)
{
start_rt_timer(0);
worst_lat = rt_shm_alloc(nam2num("WSTLAT"), sizeof(RTIME), USE_VMALLOC);
task = rt_named_task_init_cpuid("LOOPER", fun, 0, 100000, 0, 1, 0, 1);
rt_task_resume(task);
return 0;
}
int tdma_attach(struct rtnet_device *rtdev, void *priv)
{
struct rtmac_tdma *tdma = (struct rtmac_tdma *)priv;
rt_printk("RTmac: tdma1: init time devision multiple access (tdma) for realtime stations\n");
memset(tdma, 0, sizeof(struct rtmac_tdma));
spin_lock_init(&tdma->delta_t_lock);
tdma->rtdev = rtdev;
/*
* init semas, they implement a producer consumer between the
* sending realtime- and the driver-task
*
*/
rt_sem_init(&tdma->client_tx, 0);
/*
* init tx queue
*
*/
rtskb_prio_queue_init(&tdma->tx_queue);
/*
* init rt stuff
* - timer
* - list heads
*
*/
/* generic */
/* master */
init_timer(&tdma->rt_add_timer);
INIT_LIST_HEAD(&tdma->rt_add_list);
INIT_LIST_HEAD(&tdma->rt_list);
INIT_LIST_HEAD(&tdma->rt_list_rate);
init_timer(&tdma->task_change_timer);
init_timer(&tdma->master_wait_timer);
init_timer(&tdma->master_sent_conf_timer);
init_timer(&tdma->master_sent_test_timer);
rtskb_queue_init(&tdma->master_queue);
/* client */
init_timer(&tdma->client_sent_ack_timer);
/*
* start timer
*/
rt_set_oneshot_mode();
start_rt_timer(0);
return 0;
}
int init_module(void)
{
start_rt_timer(0);
rt_task_init(&rtai_sig_task, tsk_sig_fun, 0, STKSZ, 0, 0, 0);
rt_task_resume(&rtai_sig_task);
rt_task_init(&sig_task, sig_fun, 0, STKSZ, 0, 0, sighdl);
rt_task_resume(&sig_task);
return 0;
}
int init_module(void)
{
rt_task_init(&parent_task, parent_func, 0, STACK_SIZE, 0, 0, 0);
rt_set_oneshot_mode();
period = start_rt_timer((int) nano2count(TICK_PERIOD));
rt_set_runnable_on_cpus(&parent_task, RUN_ON_CPUS);
rt_task_resume(&parent_task);
return 0;
}
int main(void)
{
pthread_setschedparam_np(0, SCHED_FIFO, 0, 0xF, PTHREAD_HARD_REAL_TIME_NP);
start_rt_timer(0);
pthread_mutex_init(&m, NULL);
pthread_cond_init(&c, NULL);
do_test();
return 0;
}
int init_module(void)
{
RTIME period;
rt_task_init(&agentask, fun, 0, STACK_SIZE, 0, 0, 0);
rt_set_oneshot_mode();
period = start_rt_timer((int) nano2count(TICK_PERIOD));
rt_task_make_periodic(&agentask, rt_get_time() + period, period);
return 0;
}
int main(void)
{
double omega = (2.0*M_PI*SIN_FREQ*SAMP_TIME)/1.0E9;
RTIME until;
RT_TASK *task;
lsampl_t data[NCHAN*2];
long k, sinewave, retval = 0;
signal(SIGKILL, endme);
signal(SIGTERM, endme);
start_rt_timer(0);
task = rt_task_init_schmod(nam2num("MYTASK"), 1, 0, 0, SCHED_FIFO, 0xF);
printf("COMEDI CMD TEST BEGINS: SAMPLING FREQ: %d, RUN TIME: %d.\n", SAMP_FREQ, RUN_TIME);
if (init_board()) {;
printf("Board initialization failed.\n");
return 1;
}
do_cmd();
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
until = rt_get_cpu_time_ns() + (long long)RUN_TIME*1000000000;
for (k = 0; k < SAMP_FREQ*RUN_TIME && !end; k++) {
sinewave = (long)(maxdata/4*sin(k*omega));
data[0] = (lsampl_t)( sinewave + maxdata/2);
data[1] = (lsampl_t)(- sinewave + maxdata/2);
while (rt_comedi_command_data_write(dev, subdev, NCHAN, data) != NCHAN) {
rt_sleep(nano2count(SAMP_TIME/2));
}
if (k == TRIGSAMP) {
rt_comedi_trigger(dev, subdev);
}
}
while (until > rt_get_cpu_time_ns()) {
rt_sleep(nano2count(100000));
}
comedi_cancel(dev, subdev);
comedi_close(dev);
comedi_data_write(dev, subdev, 0, 0, AREF_GROUND, 2048);
comedi_data_write(dev, subdev, 1, 0, AREF_GROUND, 2048);
printf("COMEDI TEST ENDS.\n");
if (retval < 0) {
printf("rt_comedi_wait_timed overruns: %d\n", abs(retval));
}
stop_rt_timer();
rt_make_soft_real_time();
rt_task_delete(task);
return 0;
}
int init_module(void)
{
unsigned int local_ip;
unsigned int server_ip = rt_inet_aton(server_ip_s);
struct rtnet_callback callback = {echo_rcv, NULL};
if (strlen(local_ip_s) != 0)
local_ip = rt_inet_aton(local_ip_s);
else
local_ip = INADDR_ANY;
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);
printk("start timer %d\n", start_timer);
rtf_create(PRINT, 8000);
/* create rt-socket */
sock = socket_rt(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;
bind_rt(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 callback handler */
ioctl_rt(sock, RTNET_RTIOC_CALLBACK, &callback);
if (start_timer) {
rt_set_oneshot_mode();
start_rt_timer(0);
}
rt_task_init(&rt_task,(void *)process,0,4096,10,0,NULL);
rt_task_make_periodic_relative_ns(&rt_task, 1000000,
(RTIME)interval * 1000000);
return 0;
}
int init_module(void)
{
printk("TESTING RTDM SEMs [LOOPs %d, TIMEOUTs %d (ns)].\n", LOOPS, DELAY);
start_rt_timer(0);
rtdm_sem_init(&sem1, 0);
rtdm_sem_init(&sem2, 0);
rtdm_task_init_cpuid(&stask1, "task1", task1, NULL, 0, 0, 0);
rtdm_task_init_cpuid(&stask2, "task2", task2, NULL, 1, 0, 0);
return 0;
}
static int
__latency_init(void)
{
/* XXX check option ranges here */
/* register a proc entry */
#ifdef CONFIG_PROC_FS
create_proc_read_entry("rtai/latency_calibrate", /* name */
0, /* default mode */
NULL, /* parent dir */
proc_read, /* function */
NULL /* client data */
);
#endif
rtf_create(DEBUG_FIFO, 16000); /* create a fifo length: 16000 bytes */
rt_linux_use_fpu(use_fpu); /* declare if we use the FPU */
rt_task_init( /* create our measuring task */
&thread, /* poiter to our RT_TASK */
fun, /* implementation of the task */
0, /* we could transfer data -> task */
3000, /* stack size */
0, /* priority */
use_fpu, /* do we use the FPU? */
0 /* signal? XXX */
);
rt_set_runnable_on_cpus( /* select on which CPUs the task is */
&thread, /* allowed to run */
RUN_ON_CPUS
);
/* Test if we have to start the timer */
if (start_timer || (start_timer = !rt_is_hard_timer_running())) {
if (timer_mode) {
rt_set_periodic_mode();
} else {
rt_set_oneshot_mode();
}
rt_assign_irq_to_cpu(TIMER_8254_IRQ, TIMER_TO_CPU);
period_counts = start_rt_timer(nano2count(period));
} else {
period_counts = nano2count(period);
}
loops = (1000000000*avrgtime)/period;
/* Calculate the start time for the task. */
/* We set this to "now plus 10 periods" */
expected = rt_get_time() + 10 * period_counts;
rt_task_make_periodic(&thread, expected, period_counts);
return 0;
}
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;
}
