static inline void tbx_receive_core(TBX *tbx, void *msg, int *msg_size, unsigned char type, unsigned char *lock)
{
char *temp;
temp = msg;
if (type == TYPE_BROADCAST) {
if (*tbx->bcbadr == TYPE_NONE) {
tbxget(tbx, (char **)(&temp), *msg_size);
if (tbx->waiting_nr > 0) {
memcpy((char*)(tbx->bcbadr+sizeof(type)), msg, *msg_size);
*tbx->bcbadr = TYPE_BROADCAST;
*lock = 1;
} else {
rt_sem_broadcast(&(tbx->bcbsmx));
}
*msg_size = 0;
} else {
memcpy(msg, (char*)(tbx->bcbadr+sizeof(type)), *msg_size);
*msg_size = 0;
if (tbx->waiting_nr == 0) {
*tbx->bcbadr = TYPE_NONE;
rt_sem_broadcast(&(tbx->bcbsmx));
} else {
*lock = 1;
}
}
} else {
*msg_size = tbxget(tbx, (char **)(&temp), *msg_size);
}
}
static void event(void *cookie)
{
int err;
err = rt_task_set_periodic(NULL,
TM_NOW,
rt_timer_ns2ticks(sampling_period));
if (err) {
warning("failed to enter periodic timing (%s)\n",
symerror(err));
return;
}
for (;;) {
err = rt_task_wait_period(NULL);
if (err) {
if (err != -ETIMEDOUT)
exit(EXIT_FAILURE);
late++;
}
switch_count++;
err = rt_sem_broadcast(&switch_sem);
switch_tsc = rt_timer_tsc();
if (err) {
if (err != -EIDRM && err != -EINVAL)
warning("failed to broadcast semaphore (%s)\n",
symerror(err));
break;
}
}
}
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 *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);
}
void event(void *cookie)
{
int err;
err = rt_task_set_periodic(NULL,
TM_NOW,
rt_timer_ns2ticks(sampling_period));
if (err) {
fprintf(stderr,"switch: failed to set periodic, code %d\n", err);
return;
}
for (;;) {
err = rt_task_wait_period(NULL);
if (err) {
if (err != -ETIMEDOUT) {
/* Timer stopped. */
exit(EXIT_FAILURE);
}
}
switch_count++;
switch_tsc = rt_timer_tsc();
rt_sem_broadcast(&switch_sem);
}
}
//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);
}
void cleanRosBlock(unsigned int num) {
SEM *sem;
rt_shm_free(nam2num(rosBlockConfigs[num].shmName));
sem = (SEM*)rt_get_adr(nam2num(rosBlockConfigs[num].semName));
rt_sem_broadcast(sem);
rt_sem_delete(sem);
}
int main(){
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[])
{
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);
}
//startup code
void startup()
{
int i;
char str[10] ;
// semaphore to sync task startup on
rt_sem_create(&mysync,"MySemaphore",0,S_FIFO);
// change to period mode because round robin does not work
// in one shot mode
rt_timer_set_mode(BASEPERIOD);// set tick period
for(i=0; i < NTASKS; i++) {
rt_printf("start task : %d\n",i);
sprintf(str,"task%d",i);
if(i<NTASKS-1){rt_task_create(&demo_task[i], str, 0, 50, 0);}
else{rt_task_create(&demo_task[i],str,0,80,0);}
rt_task_start(&demo_task[i], &demo, &i);
}
rt_printf("wake up all tasks\n");
rt_sem_broadcast(&mysync);
}
int main(int argc, char* argv[])
{
char str[10] ;
int i;
// 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);
/* create semaphore */
rt_sem_create(&semGlobal,"semaphore",0,S_PRIO);
rt_printf("start task\n");
for (i=0; i<5; i++)
{
/*
* Arguments: &task,
* name,
* stack size (0=default),
* priority,
* mode (FPU, start suspended, ...)
*/
sprintf(str,"hello-%d",i);
rt_task_create(&demo_task, str, 0, 50+i, 0);
/*
* Arguments: &task,
* task function,
* function argument
*/
rt_task_start(&demo_task, &demo, &i);
}
rt_sem_broadcast(&semGlobal);
}
int main(int argc, char **argv) {
char task_name[TASKS][16];
RT_TASK task[TASKS];
rt_print_auto_init(1);
if(rt_sem_create(&sem, "Semaphore", 0, S_PRIO) != 0) {
exit(-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, 10 + (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");
rt_sem_broadcast(&sem);
for(int i = 0; i < TASKS; i++) {
rt_task_join(&task[i]);
}
rt_printf("All tasks shutted down\n");
rt_sem_delete(&sem);
}
void syncFunc() {
sleep(1);
rt_sem_broadcast(&sem);
sleep(1);
}
int main(void){
/* 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);
/* Make main a Real-Time thread */
if(rt_task_shadow(NULL, NULL, RT_MAIN_PRI, T_CPU(CPU_ID) ) != SUCCESS){
printf("RT Thread main failed to be created!\n");
exit(1);
}else{
/* print success */
rt_printf("RT Thread main initiated successfully \n");
}
/* Create semaphore for synchronized start */
if(rt_sem_create(&sync_sem, "sync_start", 0, S_PRIO) != SUCCESS){
rt_printf("sync semaphore failed to be created \n");
exit(1);
}
/* Create Barrier */
#ifdef semaphore
if(rt_sem_create(&sem, "Barrier_sem", 0, S_PRIO) != SUCCESS){
rt_printf("Barrier_sem failed to be created \n");
exit(1);
}
#endif
#ifdef mutex
if(rt_mutex_create(&mut, "Barrier_mut") != SUCCESS){
rt_printf("Barrier_mut failed to be created \n");
exit(1);
}
#endif
/* Initialize Real-Time threads */
int* id;
int i;
RT_TASK rt_threads[N_RT_THREADS];
for(i=0; i<N_RT_THREADS; i++){
/* Give the new thread the channel to respond to by argument */
int *method = malloc(sizeof(int));
*method = USE_METHOD;
/* Create new thread */
if(rt_task_create(&rt_threads[i], NULL, 0, RT_THREADS_PRI[i], T_CPU(CPU_ID)|T_JOINABLE) != SUCCESS){
rt_printf("RT Thread %i failed to be created!\n", i);
exit(1);
}
/* Execute task */
if(rt_task_start(&rt_threads[i], RT_FUNC[i], id) != SUCCESS){
rt_printf("RT Thread %i failed to start!\n", (void*) i);
exit(1);
}
/* print success */
rt_printf("RT Thread %i initiated successfully \n", i);
}
/* Wait untill all threads have been blocked, restart them */
rt_task_sleep(SLEEP_DELAY);
if(rt_sem_broadcast(&sync_sem)!= SUCCESS){
rt_printf("main thread failed to broadcast on BARRIER semaphore \n");
exit(1);
}
rt_task_sleep(SLEEP_DELAY);
/* Wait for all threads to terminate */
for(i=0; i<N_RT_THREADS; i++){
rt_task_join(&rt_threads[i]);
}
/* Clean up */
rt_sem_delete(&sem);
rt_sem_delete(&sync_sem);
rt_mutex_delete(&mut);
return 0;
}
