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);
}
int main() {
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_print_auto_init(1);
RT_TASK low, med, high, sync;
rt_task_create(&low, "low", 0, 10, T_CPU(1)|T_JOINABLE);
rt_task_create(&med, "med", 0, 20, T_CPU(1)|T_JOINABLE);
rt_task_create(&high, "high", 0, 30, T_CPU(1)|T_JOINABLE);
rt_task_create(&sync, "sync", 0, 99, T_CPU(1)|T_JOINABLE);
rt_sem_create(&sem, "sem", 0, S_PRIO);
rt_sem_create(&resourceSem, "resourceSem", 1, S_PRIO);
rt_mutex_create(&resourceMutex, "resourceMutex");
rt_task_start(&low, &lowFunc, NULL);
rt_task_start(&med, &medFunc, NULL);
rt_task_start(&high, &highFunc, NULL);
rt_task_start(&sync, &syncFunc, NULL);
rt_task_join(&low);
rt_task_join(&med);
rt_task_join(&high);
rt_task_join(&sync);
rt_sem_delete(&sem);
rt_sem_delete(&resourceSem);
rt_mutex_delete(&resourceMutex);
return 0;
}
int main(int argc, char**argv) {
printf("#################################\n");
printf("# DE STIJL PROJECT #\n");
printf("#################################\n");
//signal(SIGTERM, catch_signal);
//signal(SIGINT, catch_signal);
/* Avoids memory swapping for this program */
mlockall(MCL_CURRENT | MCL_FUTURE);
/* For printing, please use rt_print_auto_init() and rt_printf () in rtdk.h
* (The Real-Time printing library). rt_printf() is the same as printf()
* except that it does not leave the primary mode, meaning that it is a
* cheaper, faster version of printf() that avoids the use of system calls
* and locks, instead using a local ring buffer per real-time thread along
* with a process-based non-RT thread that periodically forwards the
* contents to the output stream. main() must call rt_print_auto_init(1)
* before any calls to rt_printf(). If you forget this part, you won't see
* anything printed.
*/
rt_print_auto_init(1);
initStruct();
startTasks();
pause();
deleteTasks();
return 0;
}
void init_xenomai() {
/* Avoids memory swapping for this program */
mlockall(MCL_CURRENT|MCL_FUTURE);
/* Perform auto-init of rt_print buffers if the task doesn't do so */
rt_print_auto_init(1);
}
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
}
int main(){
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_print_auto_init(1);
rt_sem_create(&semaphore, "sem", 1, S_PRIO);
rt_sem_create(&synca, "sync", 0, S_PRIO);
rt_mutex_create(&mutex, "mutex");
RT_TASK L, M, H;
rt_task_shadow(NULL, "main", 4, T_CPU(1)|T_JOINABLE);
rt_task_create(&L, "low", 0, 1, T_CPU(1)|T_JOINABLE);
rt_task_create(&M, "medium", 0, 2, T_CPU(1)|T_JOINABLE);
rt_task_create(&H, "high", 0, 3, T_CPU(1)|T_JOINABLE);
rt_task_start(&L, &low, (void*) 0);
rt_task_start(&M, &medium, (void*) 0);
rt_task_start(&H, &high, (void*) 0);
usleep(100000);
rt_printf("RELEASING SYNC\n");
rt_sem_broadcast(&synca);
rt_task_join(&L);
rt_task_join(&M);
rt_task_join(&H);
rt_sem_delete(&synca);
rt_sem_delete(&semaphore);
rt_mutex_delete(&mutex);
return 0;
}
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[])
{
// 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_TASK task;
RTIME periode;
int err;
int fd;
int zero = 0;
fd = open("/dev/cpu_dma_latency", O_WRONLY);
if (fd >= 0) {
write(fd, & zero, sizeof(zero));
// ne pas fermer le fichier avant la fin du processus
}
if ((argc != 2) || (sscanf(argv[1], "%llu", & periode) != 1)) {
fprintf(stderr, "usage: %s periode_en_us\n", argv[0]);
exit(EXIT_FAILURE);
}
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_print_auto_init(1);
if ((err = rt_task_spawn(& task, NULL, 0, 99,
T_JOINABLE, fonction_periodique, & periode)) != 0) {
fprintf(stderr, "rt_task_spaw: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
rt_task_join(& task);
return 0;
}
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(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 main(void)
{
int err;
int i;
RT_TASK task[NB_TACHES];
char nom_tache[80];
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_print_auto_init(1);
if ((err = rt_alarm_create(& alarme, "Ex01")) != 0) {
fprintf(stderr, "rt_alarm_create(): %s\n",
strerror(-err));
exit(EXIT_FAILURE);
}
for (i = 0; i < NB_TACHES-1; i++) {
snprintf(nom_tache, 80, "Alarme-%d\n", i+1);
if ((err = rt_task_spawn(& (task[i]), nom_tache, 0,
90-NB_TACHES + i, T_JOINABLE,
fonction_thread, (void *) (i+1))) != 0) {
fprintf(stderr, "rt_task_spawn: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
}
if ((err = rt_alarm_start(& alarme, TM_NOW, 1000000000)) != 0) {
fprintf(stderr, "rt_alarm_start: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
for (i = 0; i < NB_TACHES; i ++)
rt_task_join(& task[i]);
return 0;
}
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");
/*
* Arguments: &task,
* name,
* stack size (0=default),
* priority,
* mode (FPU, start suspended, ...)
*/
rt_task_create(&task1, "t1", 0, 50, 0);
rt_task_create(&task2, "t2", 0, 50, 0);
rt_task_create(&task3, "t3", 0, 50, 0);
rt_task_create(&task4, "t4", 0, 50, 0);
rt_task_create(&task5, "t5", 0, 50, 0);
/*
* Arguments: &task,
* task function,
* function argument
*/
rt_task_start(&task1, &task, 0);
rt_task_start(&task2, &task, 0);
rt_task_start(&task3, &task, 0);
rt_task_start(&task4, &task, 0);
rt_task_start(&task5, &task, 0);
}
int main(int argc, char* argv[])
{
rt_print_auto_init(1);
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_task_create(&task, NULL, 0, 50, 0);
rt_task_start(&task, &taskf, NULL);
sleep(2);
}
void initializeXenomaiEnv(void) {
// Catch signals
signal(SIGTERM, catch_signal);
signal(SIGINT, catch_signal);
/* Avoids memory swapping for this program */
mlockall(MCL_CURRENT | MCL_FUTURE);
// Initialize rdtk to use rt_printf
rt_print_auto_init(1);
}
int main(int argc, char **argv)
{
struct sched_param rtparam = { .sched_priority = 42 };
pthread_attr_t rtattr, regattr;
sigset_t mask, oldmask;
mlockall(MCL_CURRENT | MCL_FUTURE);
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
signal(SIGINT, cleanup_upon_sig);
sigaddset(&mask, SIGTERM);
signal(SIGTERM, cleanup_upon_sig);
sigaddset(&mask, SIGHUP);
signal(SIGHUP, cleanup_upon_sig);
pthread_sigmask(SIG_BLOCK, &mask, &oldmask);
/*
* This is a real-time compatible printf() package from
* Xenomai's RT Development Kit (RTDK), that does NOT cause
* any transition to secondary (i.e. non real-time) mode when
* writing output.
*/
rt_print_auto_init(1);
pthread_attr_init(&rtattr);
pthread_attr_setdetachstate(&rtattr, PTHREAD_CREATE_JOINABLE);
pthread_attr_setinheritsched(&rtattr, PTHREAD_EXPLICIT_SCHED);
pthread_attr_setschedpolicy(&rtattr, SCHED_FIFO);
pthread_attr_setschedparam(&rtattr, &rtparam);
/* Both real-time threads have the same attribute set. */
errno = pthread_create(&rt1, &rtattr, &realtime_thread1, NULL);
if (errno)
fail("pthread_create");
errno = pthread_create(&rt2, &rtattr, &realtime_thread2, NULL);
if (errno)
fail("pthread_create");
pthread_attr_init(®attr);
pthread_attr_setdetachstate(®attr, PTHREAD_CREATE_JOINABLE);
pthread_attr_setinheritsched(®attr, PTHREAD_EXPLICIT_SCHED);
pthread_attr_setschedpolicy(®attr, SCHED_OTHER);
errno = pthread_create(&nrt, ®attr, ®ular_thread, NULL);
if (errno)
fail("pthread_create");
sigsuspend(&oldmask);
return 0;
}
int main (int argc, char * argv[]){
char str[10];
int i;
rt_print_auto_init(1);
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_printf("[Main]:start task\n");
for(i=0;i<5;i++){
sprintf(str,"Task-%d",i);
rt_task_create(&demo_task,str,10,50,0);
rt_task_start(&demo_task,&demo,&i);
}
}
int main(int argc,char *argv[]) {
int retval = 0;
/* Initialize rtdk */
#ifdef _RTUTILS_H
rt_print_auto_init(1);
#endif
/* Try to Exit Cleanly on Signals */
parentThread = getpid();
signal(SIGINT,signal_handler);
signal(SIGABRT,signal_handler);
signal(SIGSEGV,signal_handler);
/* Handle Command-Line Options */
cli_options_t cli_options;
if (!parse_cli_options(argc,argv,&cli_options))
return -EINVAL;
/* Find Configuration File */
std::string config_file;
if (cli_options.config_file.length())
config_file = cli_options.config_file;
else if (getenv("RTXI_CONF"))
config_file = getenv("RTXI_CONF");
else
config_file = "/etc/rtxi.conf";
/************************************************************
* Create Main System Components *
* *
* These need to be created early because they should have *
* Settings::IDs of 0 and 1. *
************************************************************/
/* Create GUI Objects */
QApplication *app = new QApplication(argc,argv);
app->connect(app,SIGNAL(lastWindowClosed()),app,SLOT(quit()));
MainWindow::getInstance()->showMaximized();
CmdLine::getInstance();
RT::System::getInstance();
IO::Connector::getInstance();
/* Bootstrap the System */
Settings::Manager::getInstance()->load(config_file);
retval = app->exec();
Plugin::Manager::getInstance()->unloadAll();
return retval;
}
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);
/* Avoids memory swapping for this program */
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_task_create(&task, "task", 0, 50, 0);
rt_task_start(&task, &keyboard_handler, 0);
rt_printf("CRTL+C to stop\n");
pause();
}
int main(int argc, char **argv)
{
struct sched_param svparam = {.sched_priority = 71 };
struct sched_param clparam = {.sched_priority = 70 };
pthread_attr_t svattr, clattr;
sigset_t mask, oldmask;
mlockall(MCL_CURRENT | MCL_FUTURE);
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
signal(SIGINT, cleanup_upon_sig);
sigaddset(&mask, SIGTERM);
signal(SIGTERM, cleanup_upon_sig);
sigaddset(&mask, SIGHUP);
signal(SIGHUP, cleanup_upon_sig);
pthread_sigmask(SIG_BLOCK, &mask, &oldmask);
/*
* This is a real-time compatible printf() package from
* Xenomai's RT Development Kit (RTDK), that does NOT cause
* any transition to secondary mode.
*/
rt_print_auto_init(1);
pthread_attr_init(&svattr);
pthread_attr_setdetachstate(&svattr, PTHREAD_CREATE_JOINABLE);
pthread_attr_setinheritsched(&svattr, PTHREAD_EXPLICIT_SCHED);
pthread_attr_setschedpolicy(&svattr, SCHED_FIFO);
pthread_attr_setschedparam(&svattr, &svparam);
errno = pthread_create(&svtid, &svattr, &server, NULL);
if (errno)
fail("pthread_create");
pthread_attr_init(&clattr);
pthread_attr_setdetachstate(&clattr, PTHREAD_CREATE_JOINABLE);
pthread_attr_setinheritsched(&clattr, PTHREAD_EXPLICIT_SCHED);
pthread_attr_setschedpolicy(&clattr, SCHED_FIFO);
pthread_attr_setschedparam(&clattr, &clparam);
errno = pthread_create(&cltid, &clattr, &client, NULL);
if (errno)
fail("pthread_create");
sigsuspend(&oldmask);
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[])
{
char str[10];
int err;
rt_print_auto_init(1);
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_printf("start task\n");
sprintf(str, "hello");
//rt_task_create(&demo_task, str, 0, 50, 0);
//rt_task_start(&demo_task, &demo, 0);
err = rt_task_spawn(&demo_task, str, TASK_STKSZ, TASK_PRIO, TASK_MODE, &demo, NULL);
if(!err)rt_task_delete(&demo_task);
printf("task finished\n");
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);
}
int init(int& argc, char** argv, const std::string& name, uint32_t options)
{
ros::init(argc, argv, name, options);
node_name = name;
srand(time(NULL));
signal(SIGINT, rtros_signal_handler);
signal(SIGXCPU, sigxcpu_handler);
rt_print_auto_init(1);
rt_event_create(&recv_data_msg_event, "recv_data_msg_event", 0, EV_PRIO);
return rt_task_shadow(&main_shadow_task, name.c_str(), 0, 0);
}
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);
/* Avoids memory swapping for this program */
mlockall(MCL_CURRENT|MCL_FUTURE);
/* create the two tasks */
rt_task_create(&t1, "task1", 0, 1, 0);
rt_task_create(&t2, "task2", 0, 1, 0);
/* start the two tasks */
rt_task_start(&t1, &taskOne, 0);
rt_task_start(&t2, &taskTwo, 0);
return 0;
}
int main(void)
{
int err;
RT_TASK task;
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_print_auto_init(1);
if ((err = rt_task_shadow(& task, "Hello World 02",
99, T_JOINABLE)) != 0) {
fprintf(stderr, "rt_task_shadow: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
while (1) {
rt_printf("Hello World 02\n");
rt_task_sleep(1000000000LL); // 1 sec.
}
return 0;
}
int main(){
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_print_auto_init(1);
rt_sem_create(&semA, "A", 1, S_FIFO | S_PRIO);
rt_sem_create(&semB, "B", 1, S_FIFO | S_PRIO);
rt_sem_create(&syncsem, "ss", 0, S_FIFO);
RT_TASK tasks[3];
rt_task_create(tasks, "C", 0, 99, T_CPU(0)|T_JOINABLE);
//rt_task_create(&(tasks[1]), "B", 0, 50, T_CPU(0));
rt_task_create(tasks+2, "D", 0, 33, T_CPU(0));
rt_task_start(&(tasks[0]),&task_H,(void*)'H');
//rt_task_start(&(tasks[1]),&task_M,(void*)'M');
rt_task_start(&(tasks[2]),&task_L,(void*)'L');
rt_task_shadow(NULL, "main", 0, 0);
rt_task_sleep_ms(200);
rt_sem_broadcast(&syncsem);
//rt_task_sleep_ms(2000);
rt_task_join(tasks);
rt_task_join(tasks+2);
rt_sem_delete(&semA);
rt_sem_delete(&semB);
/*
pthread_t disturbance[10];
for (i=0; i<10; i++){
pthread_create(&(disturbance[i]),NULL,&busy_wait,NULL);
}
for (i=0; i<10; i++){
pthread_join(disturbance[i],NULL);
}
*/
return 0;
};
int main(int argc, char **argv)
{
mlockall(MCL_CURRENT|MCL_FUTURE); //lock current mem alloc and future mem alloc main mem
rt_print_auto_init(1); //hvis vi trenger printf
rt_sem_create(&xenomai_semaphore, "Vaarsemafor", SEM_INIT_COUNT, SEM_MODE);
rt_sem_create(&resource_semaphore, "ressursemafor", SEM_RES_INIT_COUNT, SEM_MODE);
rt_mutex_create(&resMut,"Resource control mutex");
rt_task_create(&taskLow, "task L", AUT0_STCK_SIZE, 50, SINGLE_CORE_MODE);
rt_task_create(&taskMed, "task M", AUT0_STCK_SIZE, 75, SINGLE_CORE_MODE);
rt_task_create(&taskHigh, "task H", AUT0_STCK_SIZE, 99, SINGLE_CORE_MODE);
rt_task_shadow (NULL, "main", 99,SINGLE_CORE_MODE);
rt_task_start(&taskLow, &taskL, NULL);
rt_task_start(&taskMed, &taskM, NULL);
rt_task_start(&taskHigh, &taskH, NULL);
rt_printf("Started program\n");
rt_task_sleep(ONE_SEC);
rt_printf("One second passed\n");
rt_sem_broadcast(&xenomai_semaphore);
while(1){
rt_task_sleep(100000);
}
rt_sem_delete(&xenomai_semaphore);
rt_sem_delete(&resource_semaphore);
rt_mutex_delete(&resMut);
return 0;
}
int main(int argc, char* argv[])
{
rt_print_auto_init(1);
signal(SIGTERM, catch_signal);
signal(SIGINT, catch_signal);
mlockall(MCL_CURRENT|MCL_FUTURE);
done=1;
int flag=0;
while (flag<sizeQ){
gyroQ[flag]=rand()%366;
flag++;
}
int err =rt_mutex_create(&a,"MyMutex");//creating mutex
err =rt_mutex_create(&g,NULL);
rt_task_create(&Accelerometer,NULL , 0, 0, T_JOINABLE);
rt_task_create(&gyroscope, NULL, 0, 0, T_JOINABLE);
rt_task_create(&fusion, NULL, 0, 0, T_JOINABLE);
rt_task_start(&gyroscope, &gyro,NULL);
rt_task_start(&Accelerometer, &Acc, NULL);
rt_task_start(&fusion, &fusionT, NULL);
rt_task_join(&gyroscope);
rt_task_join(&Accelerometer);
rt_task_join(&fusion);
rt_task_delete(&gyroscope);
rt_task_delete(&Accelerometer);
rt_task_delete(&fusion);
rt_mutex_delete(&a);
rt_mutex_delete(&g);
flag=0;
while (flag<sizeFinal){//print out result
rt_printf("Result%d: %d\n",flag,finalNum[flag]);
flag++;
}
}
int main(int argc, char* argv[])
{
char str[10] ;
int i;
rt_print_auto_init(1);
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_printf("start task\n");
rt_sem_create(&sem, "sem", 0, S_FIFO);
for (i=0; i<5; i++)
{
sprintf(str, "hello-%d", i);
rt_task_create(&task[i], str, 0, 50+i, 0);
rt_task_start(&task[i], &demo, &i);
}
// rt_sem_v(&sem);
rt_sem_broadcast(&sem);
}
