int main(int argc, char* argv[])
{
// Perform auto-init of rt_print buffers if the task doesn't do so
rt_print_auto_init(1);
// Lock memory : avoid memory swapping for this program
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_printf("starting tasks\n");
int res = rt_sem_create(&semGlobal, "a", 0, S_PRIO);
if(res < 0) rt_printf("Failed to create semaphore; error: %d: %s", res, strerror(-res));
rt_task_create(&task1, "t1", 0, 10, 0);
rt_task_create(&task2, "t2", 0, 20, 0);
rt_task_create(&task3, "t3", 0, 30, 0);
rt_task_create(&task4, "t4", 0, 40, 0);
rt_task_create(&task5, "t5", 0, 50, 0);
int a1 = 1;
int a2 = 2;
int a3 = 3;
int a4 = 4;
int a5 = 5;
rt_task_start(&task1, &task, &a1);
rt_task_start(&task2, &task, &a2);
rt_task_start(&task3, &task, &a3);
rt_task_start(&task4, &task, &a4);
rt_task_start(&task5, &task, &a5);
rt_sem_broadcast(&semGlobal);
}
int main(int argc, char* argv[])
{
signal(SIGTERM, catch_signal);
//signal(SIGINT, catch_signal);
int statusA, statusG, statusF, mutexacc, mutexgyro, i,j;
logIndex = 0;
// enable rt_task_print
rt_print_auto_init(1);
/* Avoids memory swapping for this program */
mlockall(MCL_CURRENT|MCL_FUTURE);
// Create mutexs
mutexgyro = rt_mutex_create(&mutex_gyro,NULL);
if(mutexgyro!=0){
fprintf(stderr, "Unable to create gyroscope mutex! Exiting...\n");
exit(EXIT_FAILURE);
}
mutexacc = rt_mutex_create(&mutex_acc,NULL);
if(mutexacc!=0){
fprintf(stderr, "Unable to create accelorometer mutex! Exiting...\n");
exit(EXIT_FAILURE);
}
isRunning = 1;
/*
* Arguments: &task, name, stack size (0=default), priority,
* mode (FPU, start suspended, ...)
*/
statusA = rt_task_create(&accThread, NULL, 0, 0, T_JOINABLE);
statusG = rt_task_create(&gyroThread, NULL, 0, 0, T_JOINABLE);
statusF = rt_task_create(&fusThread, NULL, 0, 0, T_JOINABLE);
/*
* Arguments: &task, task function, function argument
*/
statusA = rt_task_start(&accThread, &accelerometer, NULL);
statusG = rt_task_start(&gyroThread, &gyroscope, NULL);
statusF = rt_task_start(&fusThread, &sensor_fusion, NULL);
// threads in infinite loop, therefore this prevents the main from finishing
// (and killing its threads)
statusA = rt_task_join(&gyroThread);
statusF = rt_task_join(&fusThread);
statusG = rt_task_join(&accThread);
printlog[logIndex] = 4000;
for (i = 0; i < 50; i++) {
printf("Fusion%d: %d\n", i, printlog[i]);
}
rt_mutex_delete(&mutex_acc);
rt_mutex_delete(&mutex_gyro);
}
int main(){
rt_print_auto_init(1);
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_task_shadow(NULL, "main", 5, T_CPU(0)|T_JOINABLE);
#ifdef mutex
rt_mutex_create(&a, "Mutex");
rt_mutex_create(&b, "b");
#endif
rt_task_create(&task1, "Task1", 0, 1, T_CPU(0)|T_JOINABLE);
rt_task_create(&task2, "Task2", 0, 2, T_CPU(0)|T_JOINABLE);
rt_task_start(&task1, &semWait1, NULL);
rt_task_start(&task2, &semWait2, NULL);
rt_printf("sync \n");
rt_task_join(&task1);
rt_task_join(&task2);
#ifdef mutex
rt_mutex_delete(&a);
rt_mutex_delete(&b);
#endif
}
void startup(){
rt_queue_create(&rqueue, "rQueue", QUEUE_SIZE, 40, Q_FIFO);
rt_queue_create(&lqueue, "lQueue", QUEUE_SIZE, 40, Q_FIFO);
//rt_sem_create(&rsem, "rsem", 0, S_FIFO);
//&task, name, stack size (0 - default), priority, mode
rt_task_create(&rEnc_task, "rEnc Task", 0, 50, 0);
//&task, task function, function argument
rt_task_start(&rEnc_task, &rEnc, 0);
//&task, name, stack size (0 - default), priority, mode
rt_task_create(&lEnc_task, "lEnc Task", 0, 50, 0);
//&task, task function, function argument
rt_task_start(&lEnc_task, &lEnc, 0);
//&task, name, stack size (0 - default), priority, mode
rt_task_create(&Odo_task, "Odo Task", 0, 60, 0);
//&task, task function, function argument
rt_task_start(&Odo_task, &Odo, 0);
//rt_sem_broadcast(&rsem);
}
//startup code
void startup(){
int err = 0;
// semaphore to sync task startup on
err = rt_sem_create(&mysync,"MySemaphore",1,S_FIFO);
if(err < 0) rt_printf("Failed to create semaphore; error: %d: %s", err, strerror(-err));
err = 0;
// set timing to ns
rt_timer_set_mode(BASEPERIOD);
err = rt_task_create(&highP, "high", 0, HIGH, 0);
if(err < 0) rt_printf("Failed to create task high; error: %d: %s", err, strerror(-err));
err = 0;
err = rt_task_start(&highP, &prioHigh, 0);
if(err < 0) rt_printf("Failed to start task high; error: %d: %s", err, strerror(-err));
err = 0;
err = rt_task_create(&midP, "mid", 0, MID, 0);
if(err < 0) rt_printf("Failed to create task medium; error: %d: %s", err, strerror(-err));
err = 0;
err = rt_task_start(&midP, &prioMid, 0);
if(err < 0) rt_printf("Failed to start task medium; error: %d: %s", err, strerror(-err));
err = 0;
err = rt_task_create(&lowP, "low", 0, LOW, 0);
if(err < 0) rt_printf("Failed to create task low; error: %d: %s", err, strerror(-err));
err = 0;
err = rt_task_start(&lowP, &prioLow, 0);
if(err < 0) rt_printf("Failed to start task low; error: %d: %s", err, strerror(-err));
err = 0;
}
int main(int argc, char *const argv[])
{
int ret;
traceobj_init(&trobj, argv[0], 0);
ret = rt_sem_create(&sem, "SEMA", 0, S_FIFO);
traceobj_check(&trobj, ret, 0);
ret = rt_task_create(&t_rr1, "rr_task_1", 0, 10, 0);
traceobj_check(&trobj, ret, 0);
ret = rt_task_start(&t_rr1, rr_task, "t1");
traceobj_check(&trobj, ret, 0);
ret = rt_task_create(&t_rr2, "rr_task_2", 0, 10, 0);
traceobj_check(&trobj, ret, 0);
ret = rt_task_start(&t_rr2, rr_task, "t2");
traceobj_check(&trobj, ret, 0);
ret = rt_sem_broadcast(&sem);
traceobj_check(&trobj, ret, 0);
traceobj_join(&trobj);
exit(0);
}
//startup code
void startup()
{
rt_intr_create(&keypress, NULL, KEYBOARD_IRQ, I_PROPAGATE);
rt_task_create(&key_isr, NULL,0,50,0);
rt_task_start(&key_isr, &key_handler, NULL);
// Higher priority
rt_task_create(&dummy, NULL,0,53,0);
rt_task_start(&dummy, &dummy_task, NULL);
}
ECRTData::ECRTData() {
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_mutex_create(&(this->mutex), NULL);
rt_mutex_create(&(this->mutexBuffer), NULL);
rt_cond_create(&(this->freeCond), NULL);
rt_task_create(&(this->ecThread), NULL, 0, 99, T_JOINABLE);
rt_task_create(&(this->frThread), NULL, 0, 99, T_JOINABLE);
rt_task_create(&(this->statusThread), NULL, 0, 99, T_JOINABLE);
rt_task_create(&(this->supervisorThread), NULL, 0, 99, T_JOINABLE);
}
void startup(){
// rt_task_create(&rMotor_task, "rMotor Task", 0, 50, 0);
// rt_task_create(&lMotor_task, "lMotor Task", 0, 50, 0);
//rt_task_create(&rMotor_stop_task, "rMotor Stop Task", 0, 51, 0);
//rt_task_create(&lMotor_stop_task, "lMotor Stop Task", 0, 51, 0);
rt_task_create(&rMotor_task, "rMotor Task", 0, 50, 0);
rt_task_create(&lMotor_task, "lMotor Task", 0, 50, 0);
// rt_task_start(&rMotor_stop_task, &rMotor_stop, 0);
//rt_task_start(&lMotor_stop_task, &lMotor_stop, 0);
rt_task_start(&rMotor_task, &rMotor, 0);
rt_task_start(&lMotor_task, &lMotor, 0);
}
//startup code
void startup()
{
int i;
char str[10] ;
// semaphore to sync task startup on
rt_sem_create(&mysync,"MySemaphore",0,S_FIFO);
// set timing to ns
rt_timer_set_mode(BASEPERIOD);
for(i=0; i < NTASKS; i++) {
rt_printf("start task : %d\n",i);
sprintf(str,"task%d",i);
rt_task_create(&demo_task[i], str, 0, 50, 0);
rt_task_start(&demo_task[i], &demo, &i);
}
// assign priorities to tasks
// (or in creation use 50+i)
rt_task_set_priority(&demo_task[0],LOW);
rt_task_set_priority(&demo_task[1],MID);
rt_task_set_priority(&demo_task[2],MID);
rt_printf("wake up all tasks\n");
rt_sem_broadcast(&mysync);
}
int main(int argc, char **argv) {
char task_name[TASKS][16];
RT_TASK task[TASKS];
rt_print_auto_init(1);
mlockall(MCL_CURRENT|MCL_FUTURE);
for(int i = 0; i < TASKS; i++) {
snprintf(task_name[i], 16, "Lab5Task-%d", i);
if (rt_task_create(&task[i], task_name[i], 0, 50 - (i*2), T_JOINABLE) != 0) {
exit(-1);
}
}
for (int i = 0; i < TASKS; i++) {
rt_printf("Starting task %s\n", task_name[i]);
rt_task_start(&task[i], &task_body, NULL);
}
rt_printf("All tasks started\n");
for(int i = 0; i < TASKS; i++) {
rt_task_join(&task[i]);
}
rt_printf("All tasks stopped, shared_resource = %d\n", shared_resource);
}
int rt_task_create(RT_TASK *task, const char *name,
int stksize, int prio, int mode)
{
int ret, susp, cpus, cpu;
cpu_set_t cpuset;
susp = mode & T_SUSP;
cpus = mode & T_CPUMASK;
ret = __CURRENT(rt_task_create(task, name, stksize, prio,
mode & ~(T_SUSP|T_CPUMASK|T_LOCK)));
if (ret)
return ret;
if (cpus) {
CPU_ZERO(&cpuset);
for (cpu = 0, cpus >>= 24;
cpus && cpu < 8; cpu++, cpus >>= 1) {
if (cpus & 1)
CPU_SET(cpu, &cpuset);
}
ret = rt_task_set_affinity(task, &cpuset);
if (ret) {
rt_task_delete(task);
return ret;
}
}
return susp ? rt_task_suspend(task) : 0;
}
int main (int argc, char *argv[])
{
static char *messages[] = { "hello", "world", NULL };
int n, len;
void *msg;
mlockall(MCL_CURRENT|MCL_FUTURE);
err = rt_task_create(&task_desc,
"MyTaskName",
TASK_STKSZ,
TASK_PRIO,
TASK_MODE);
if (!err)
rt_task_start(&task_desc,&task_body,NULL);
/* ... */
for (n = 0; messages[n] != NULL; n++)
{
len = strlen(messages[n]) + 1;
/* Get a message block of the right size. */
msg = rt_queue_alloc(&q_desc,len);
if (!msg)
/* No memory available. */
fail();
strcpy(msg,messages[n]);
rt_queue_send(&q_desc,msg,len,Q_NORMAL);
}
rt_task_delete(&task_desc);
}
RealtimeController::RealtimeController()
{
// lukitaan ohjelman nykyinen ja tuleva muisti niin että se pysyy RAM:ssa kokoajan
mlockall(MCL_CURRENT | MCL_FUTURE);
int xenoError = 0;
// luodaan task-handle reaaliaikasäikeelle
// antamalla T_FPU | T_JOINABLE saattaisi olla mahdollista käyttää
// mittausarvoja doubleina Voltteina koko ohjelmassa
xenoError = rt_task_create(&task_desc, NULL, 0, 99, T_JOINABLE);
xenoError = rt_pipe_create(&pipe_desc, NULL, 0, 0);
if(xenoError != 0)
qDebug("rt init error");
// käynnistetään säie
rt_task_start(&task_desc, &realtimeLoop, NULL);
// luodaan pipe reaaliaikasäikeen kanssa kommunikointiin
pipefd = open("/dev/rtp0", O_RDWR, 0);
if (pipefd < 0)
qDebug("Creating pipe failed");
// pysäytetään säätö oletuksena
stop();
}
int RT::OS::createTask(RT::OS::Task *task,void *(*entry)(void *),void *arg,int prio) {
int retval = 0;
xenomai_task_t *t = new xenomai_task_t;
int priority = 99;
#ifdef DEBUG_RT
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_sigaction = rt_switch_warning;
sa.sa_flags = SA_SIGINFO;
sigaction(SIGDEBUG, &sa, NULL);
#endif
// Invert priority, default prio=0 but max priority for xenomai task is 99
if ((prio >=0) && (prio <=99))
priority -= prio;
if ((retval = rt_task_create(&t->task,"RTXI RT Thread",0,priority,T_FPU|T_JOINABLE))) {
ERROR_MSG("RT::OS::createTask : failed to create task\n");
return retval;
}
t->period = -1;
*task = t;
pthread_setspecific(is_rt_key,reinterpret_cast<const void *>(t));
if ((retval = rt_task_start(&t->task,reinterpret_cast<void(*)(void *)>(entry),arg))) {
ERROR_MSG("RT::OS::createTask : failed to start task\n");
return retval;
}
return 0;
}
int main (int argc, char *argv[])
{
// Enable the on-board GPIO
wiringPiSetup ();
// rt print
rt_print_auto_init(1);
// turn off paging
mlockall(MCL_CURRENT|MCL_FUTURE);
#ifdef DEBUG
rt_printf ("SecureRT - Test\n");
delay(1000);
#endif /*DEBUG*/
// setup pins
pinMode (OUTPUT_PIN, OUTPUT);
pinMode (INPUT_PIN, INPUT);
int err;
// create task
err = rt_task_create(&task_desc,
"SRT_task",
TASK_STKSZ,
TASK_PRIO,
TASK_MODE);
if (!err)
rt_task_start(&task_desc,&task_body,NULL);
while(1){
//wait for rt_task
}
return(0);
}
int main (int argc, char * argv[]){
rt_print_auto_init(1);
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_sem_create(&semGlobal1,"semaphore1",1,S_FIFO);
rt_sem_create(&semGlobal2,"semaphore2",0,S_FIFO);
rt_task_create(&t1,"taskOne",0,10,0);
rt_task_create(&t2,"taskTwo",0,10,0);
rt_task_start(&t1,&taskOne,NULL);
rt_task_start(&t2,&taskTwo,NULL);
//rt_printf("end program by CTRL-C\n");
//pause();
}
int main (int argc, char **argv)
{
int err;
signal(SIGXCPU, warn_upon_switch);
err = rt_task_create(&task,"mytask",0,1,T_FPU);
if (err)
{
fprintf(stderr,"failed to create task, code %d\n",err);
return 0;
}
err = rt_task_start(&task,&task_body,NULL);
if (err)
{
fprintf(stderr,"failed to start task, code %d\n",err);
return 0;
}
pause();
return 0;
}
int main (int argc, char *argv[]) {
int err;
mlockall(MCL_CURRENT|MCL_FUTURE);
/* Version With 4 param only on userSpace */
err = rt_intr_create(&intr_desc,"MyIrq",70,0);
if (err != 0){
printf("rt_intr_create : error\n");
return 1;
}
err = rt_task_create(&server_desc,
"MyIrqServer",
TASK_STKSZ,
TASK_PRIO,
TASK_MODE);
if (err == 0)
rt_task_start(&server_desc,&irq_server,NULL);
else{
printf("rt_task_start : error\n");
return 1;
}
getchar();
cleanup();
return 0;
}
/**
* Create the CAN Receiver Task
* @param fd0 CAN port
* @param *ReceiveLoop_task CAN receiver task
* @param *ReceiveLoop_task_proc CAN receiver function
*/
void CreateReceiveTask(CAN_PORT fd0, TASK_HANDLE *ReceiveLoop_task, void* ReceiveLoop_task_proc)
{
int ret;
static int id = 0;
char taskname[32];
snprintf(taskname, sizeof(taskname), "canloop%d-%d", id, current->pid);
id++;
/* create ReceiveLoop_task */
ret = rt_task_create(ReceiveLoop_task,taskname,0,50,0); /* T_JOINABLE only in user space */
if (ret) {
printk("Failed to create ReceiveLoop_task number %d, code %d\n", id, ret);
return;
}
/* periodic task for Xenomai kernel realtime */
rt_task_set_periodic(ReceiveLoop_task, 0, 1 * 1000 * 1000); /* 1ms */
/* start ReceiveLoop_task */
ret = rt_task_start(ReceiveLoop_task, ReceiveLoop_task_proc,(void*)fd0);
if (ret) {
printk("Failed to start ReceiveLoop_task number %d, code %d\n", id, ret);
return;
}
rt_sem_v(&control_task);
}
void startup(){
stepInitializzator();
rt_sem_create(&readDone, "readSem", 0, S_PRIO);
rt_sem_create(&executionDone, "executionSem", 0, S_PRIO);
rt_sem_create(&writeDone, "writeSem", 0, S_PRIO);
rt_task_create(&task, "readerTask", 0, 99, 0);
rt_task_start(&task, &reader, NULL);
rt_task_create(&task, "executorTask", 0, 98, 0);
rt_task_start(&task, &executor, NULL);
rt_task_create(&task, "writerTask", 0, 97, 0);
rt_task_start(&task, &writer, NULL);
}
int main(int argc, char* argv[])
{
char str[10] ;
// Perform auto-init of rt_print buffers if the task doesn't do so
rt_print_auto_init(1);
// Lock memory : avoid memory swapping for this program
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_printf("start task\n");
/*
* Arguments: &task,
* name,
* stack size (0=default),
* priority,
* mode (FPU, start suspended, ...)
*/
sprintf(str,"hello");
rt_task_create(&demo_task, str, 0, 50, 0);
/*
* Arguments: &task,
* task function,
* function argument
*/
rt_task_start(&demo_task, &demo, 0);
}
/**
* Create the Timer Task
* @param _init_callback
*/
void StartTimerLoop(CO_Data* d, TimerCallback_t _init_callback)
{
int ret = 0;
stop_timer = 0;
init_callback = _init_callback;
callback_od = d;
char taskname[32];
snprintf(taskname, sizeof(taskname), "timerloop-%d", current->pid);
/* create timerloop_task */
ret = rt_task_create(&timerloop_task, taskname, 0, 50, 0); /* T_JOINABLE only in user space */
if (ret) {
printk("Failed to create timerloop_task, code %d\n",ret);
return;
}
/* start timerloop_task */
ret = rt_task_start(&timerloop_task,&timerloop_task_proc,NULL);
if (ret) {
printk("Failed to start timerloop_task, code %u\n",ret);
goto error;
}
return;
error:
cleanup_all();
}
int main ()
{
io_init();
RT_TASK test[3];
mlockall(MCL_CURRENT|MCL_FUTURE);
char name[10];
long i;
for (i = 1; i <= 3; i++) {
sprintf(name, "test%lu", i);
rt_task_create(&test[i-1], name, 0, i, T_CPU(1)|T_JOINABLE);
rt_task_start(&test[i-1], &periodicTest, (void*) i);
}
pthread_t disturbances[10];
for (i = 0; i < 10; i++) {
pthread_create(&disturbances[i], NULL, disturbance, NULL);
}
for (i = 0; i < 10; i++) {
pthread_join(disturbances[i], NULL);
}
wait_for_ctrl_c();
return 0;
}
void initMotor(OUT_MOTOR* motor, char * n1, char* n2, char * file, int pinPWM, int pinIN1, int pinIN2, int pinSTBY, double vitesse){
motor->cap = fopen(file,"r");
motor->pinSTBY = pinSTBY;
motor->pinIN1 = pinIN1;
motor->pinIN2= pinIN2;
motor->pinPWM=pinPWM;
INP_GPIO(pinIN1);
INP_GPIO(pinIN2);
INP_GPIO(pinSTBY);
INP_GPIO(pinPWM);
OUT_GPIO(pinIN1);
OUT_GPIO(pinIN2);
OUT_GPIO(pinSTBY);
OUT_GPIO(pinPWM);
GPIO_SET = 1 << pinSTBY;
GPIO_CLR = 1 << pinIN1 | 1 << pinIN2 | 1<< pinPWM;
motor->vitesse=vitesse;
int err = rt_task_create(&(motor->task),n1, TASK_STKSZ, TASK_PRIO, TASK_MODE);
err |= rt_alarm_create(&(motor->alarm),n2);
err |= rt_task_set_periodic(&(motor->task), TM_NOW, PERIODE_MOTOR);
if (!err) {
rt_task_start(&(motor->task),&taskMotor,motor);
}
}
int main(void)
{
RT_TASK main_tcb;
RT_TASK tcb;
mqd_t mq;
int i;
mlockall(MCL_CURRENT | MCL_FUTURE);
fprintf(stderr, "Checking select service with posix message queues\n");
rt_task_shadow(&main_tcb, NULL, 0, 0);
mq = mq_open("/select_test_mq", O_RDWR | O_CREAT | O_NONBLOCK, 0, NULL);
check_unix(mq == -1 ? -1 : 0);
check_native(rt_task_create(&tcb, "select_test", 0, 1, T_JOINABLE));
check_native(rt_task_start(&tcb, task, (void *)(long)mq));
alarm(30);
for(i = 0; i < sizeof(tunes) / sizeof(tunes[0]); i++) {
check_unix(mq_send(mq, tunes[i], strlen(tunes[i]) + 1, 0));
sleep(1);
}
check_native(rt_task_join(&tcb));
fprintf(stderr, "select service with posix message queues: success\n");
return EXIT_SUCCESS;
}
void assignmentA(int period_us, int ndisturbance)
{
printf("Starting Assignment A!\n");
period_ns = period_us * 1000;
RT_TASK rt[N_RT];
pthread_t ts[ndisturbance];
char *names[N_RT] = { "thread_a", "thread_b", "thread_c" };
int channels[N_RT] = { CHANNEL_A, CHANNEL_B, CHANNEL_C };
mlockall(MCL_CURRENT | MCL_FUTURE);
int i;
for (i = 0; i < ndisturbance; i++)
{
pthread_create(&ts[i], 0, disturbanceInTheForce, NULL);
}
for (i = 0; i < N_RT; i++)
{
rt_task_create(&rt[i], names[i], 0, 99, 0);
rt_task_start(&rt[i], responseHandlerPeriodic, &channels[i]);
}
while (1);
}
bool RTROSMotorSettingService::motorSet(rt_dynamixel_msgs::MotorSettingRequest &req,
rt_dynamixel_msgs::MotorSettingResponse &res)
{
for(int i=0; i<4; i++)
{
dxlDevice[i].bControlLoopEnable = false;
}
for(int i=0; i<4; i++)
{
while(dxlDevice[i].bControlLoopProcessing) {}
}
RT_TASK rttMotorSetTask;
rt_task_create(&rttMotorSetTask,"dxl motorset service",0,7,T_JOINABLE);
motorResponse.result = -1;
motorRequest = req;
rt_task_start(&rttMotorSetTask, &motor_set_proc, (void*)this);
rt_task_join(&rttMotorSetTask);
rt_task_delete(&rttMotorSetTask);
res = motorResponse;
//res.result = req.mode;
for(int i=0; i<4; i++)
{
dxlDevice[i].bControlLoopEnable = true;
}
return true;
}
int main(int argc, char* argv[]) {
// Create semaphores
rt_sem_create(&sem_dec, "increment semaphore", 0, S_FIFO);
rt_sem_create(&sem_inc, "decrement semaphore", 1, S_FIFO);
// Create tasks
rt_task_create(&t1, "task1", 0, 1, 0);
rt_task_create(&t2, "task2", 0, 1, 0);
rt_task_start(&t1, &taskOne, 0);
rt_task_start(&t2, &taskTwo, 0);
// Clean up the semaphores
rt_sem_delete(&sem_dec);
rt_sem_delete(&sem_inc);
return 0;
}
int main(int argc, char* argv[])
{
char str[10] ;
int num1 = 1;
int num2 = 2;
int num3 = 3;
int num4 = 4;
int num5 = 5;
// Perform auto-init of rt_print buffers if the task doesn't do so
rt_print_auto_init(1);
// Lock memory : avoid memory swapping for this program
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_printf("start 5 tasks\n");
/*
* Arguments: &task,
* name,
* stack size (0=default),
* priority,
* mode (FPU, start suspended, ...)
*/
sprintf(str,"task1");
rt_task_create(&demo_task1, str, 0, 50, 0);
sprintf(str,"task2");
rt_task_create(&demo_task2, str, 0, 51, 0);
sprintf(str,"task3");
rt_task_create(&demo_task3, str, 0, 52, 0);
sprintf(str,"task4");
rt_task_create(&demo_task4, str, 0, 53, 0);
sprintf(str,"task5");
rt_task_create(&demo_task5, str, 0, 54, 0);
/*
* Arguments: &task,
* task function,
* function argument
*/
rt_task_start(&demo_task1, &demo, &num1);
rt_task_start(&demo_task2, &demo, &num2);
rt_task_start(&demo_task3, &demo, &num3);
rt_task_start(&demo_task4, &demo, &num4);
rt_task_start(&demo_task5, &demo, &num5);
}
