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(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 speed_exit(void) {
if (!running) {
goto err_not_running;
}
running = 0;
rt_task_delete(&task_hard);
rt_task_delete(&task_soft);
rt_queue_delete(&queue);
rt_mutex_delete(&mutex_average);
rt_mutex_delete(&mutex_instant);
rt_intr_disable(&intr);
rt_intr_delete(&intr);
fclose(ostream);
/* START DEBUG DEBUG DEBUG */
{
FILE * fp = fopen("average", "w");
fprintf(fp, "%f\n", average);
fclose(fp);
}
/* STOP DEBUG DEBUG DEBUG */
return 0;
err_not_running:
return -1;
}
ECRTData::~ECRTData() {
rt_task_delete(&(this->supervisorThread));
rt_task_delete(&(this->statusThread));
rt_task_delete(&(this->frThread));
rt_task_delete(&(this->ecThread));
rt_cond_delete(&(this->freeCond));
rt_mutex_delete(&(this->mutexBuffer));
rt_mutex_delete(&(this->mutex));
}
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(){
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;
}
~mutex_impl() {
int ret = rt_mutex_delete(&m);
if (ret != 0) {
// Don't throw exceptions from a dtor!
logMessage("thread::detail::mutex_impl::%s: Could not delete RT_MUTEX: (%d) %s")
% __func__ % -ret % strerror(-ret);
}
}
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++;
}
}
osStatus osMutexDelete (osMutexId mutex_id)
{
rt_err_t result;
result = rt_mutex_delete(mutex_id);
if (result == RT_EOK)
return osOK;
else
return osErrorOS;
}
/**
* Clean all Semaphores, mutex, condition variable and main task
*/
void TimerCleanup(void)
{
rt_sem_delete(&CanFestival_mutex);
rt_mutex_delete(&condition_mutex);
rt_cond_delete(&timer_set);
rt_sem_delete(&control_task);
/* normally this will fail with a non-periodic task that has already ended at this time */
if (rt_task_suspend(&timerloop_task) != 0){
printk("Failed to join with Timerloop task\n");
}
rt_task_delete(&timerloop_task);
}
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 ff_del_syncobj(_SYNC_t m)
{
rt_mutex_delete(m);
return RT_TRUE;
}
void catch_signal(int sig)
{
rt_mutex_delete(&mutex_acc);
rt_mutex_delete(&mutex_gyro);
}
int main(int argc, char* argv[])
{
int semDonnee;
int semObs;
int mutDonnee;
int mutObs;
/*initialize random seed*/
srand(time(NULL));
mutDonnee = rt_mutex_create(&mutex_donnee,"mutexDonnee");
mutObs = rt_mutex_create(&mutex_obs,"mutexObstacle");
semDonnee = rt_sem_create(&sem_donnee,"Semaphore Donnee",SEM_INIT,SEM_MODE);
semObs = rt_sem_create(&sem_obs,"Semaphore Obstacle",SEM_INIT,SEM_MODE);
/* Avoids memory swapping for this program */
mlockall(MCL_CURRENT|MCL_FUTURE);
gettimeofday(&tim, NULL);
start = tim.tv_sec+(tim.tv_usec/1000000.0);
/*
* Arguments: &task,
* name,
* stack size (0=default),
* priority,
* mode (FPU, start suspended, ...)
*/
rt_task_create(&sensorTaskt, "sensor", 0, 99, 0);
rt_task_create(&computationTaskt, "computation", 0, 99, 0);
rt_task_create(&printTaskt, "print", 0, 99, 0);
/*
* Arguments: &task,
* task function,
* function argument
*/
rt_task_start(&sensorTaskt, &sensorTask, NULL);
rt_task_start(&computationTaskt, &computationTask, NULL);
rt_task_start(&printTaskt, &printTask, NULL);
pause();
rt_task_delete(&sensorTask);
rt_task_delete(&computationTask);
rt_task_delete(&printTask);
rt_sem_delete(&sem_donnee);
rt_sem_delete(&sem_obs);
rt_mutex_delete(&mutex_donnee);
rt_mutex_delete(&mutex_obs);
obstacle* temp1 = obstacleList;
obstacle* temp2;
while(temp1->nxt != NULL){
temp2 = temp1->nxt;
free(temp1);
temp1=temp2;
}
free(temp1);
}
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;
}
int main(int argc, char **argv)
{
char tempname[] = "/tmp/sigdebug-XXXXXX";
char buf[BUFSIZ], dev[BUFSIZ];
RT_TASK main_task, rt_task;
long int start, trash, end;
unsigned char *mayday, *p;
struct sigaction sa;
int old_wd_value;
char r, w, x, s;
int tmp_fd, d;
FILE *maps;
int err;
rt_print_auto_init(1);
if (argc < 2 || strcmp(argv[1], "--skip-watchdog") != 0) {
wd = fopen("/sys/module/xeno_nucleus/parameters/"
"watchdog_timeout", "w+");
if (!wd) {
fprintf(stderr, "FAILURE: no watchdog available and "
"--skip-watchdog not specified\n");
exit(EXIT_FAILURE);
}
err = fscanf(wd, "%d", &old_wd_value);
check("get watchdog", err, 1);
err = fprintf(wd, "2");
check("set watchdog", err, 1);
fflush(wd);
}
maps = fopen("/proc/self/maps", "r");
if (maps == NULL) {
perror("open /proc/self/maps");
exit(EXIT_FAILURE);
}
while (fgets(buf, sizeof(buf), maps)) {
if (sscanf(buf, "%lx-%lx %c%c%c%c %lx %x:%x %d%s\n",
&start, &end, &r, &w, &x, &s, &trash,
&d, &d, &d, dev) == 11
&& r == 'r' && x == 'x'
&& !strcmp(dev, "/dev/rtheap") && end - start == 4096) {
printf("mayday page starting at 0x%lx [%s]\n"
"mayday code:", start, dev);
mayday = (unsigned char *)start;
for (p = mayday; p < mayday + 32; p++)
printf(" %.2x", *p);
printf("\n");
}
}
fclose(maps);
sigemptyset(&sa.sa_mask);
sa.sa_sigaction = sigdebug_handler;
sa.sa_flags = SA_SIGINFO;
sigaction(SIGDEBUG, &sa, NULL);
sa.sa_sigaction = dummy_handler;
sigaction(SIGUSR1, &sa, NULL);
printf("mlockall\n");
munlockall();
setup_checkdebug(SIGDEBUG_NOMLOCK);
err = rt_task_shadow(&main_task, "main_task", 0, 0);
check("rt_task_shadow", err, -EINTR);
check_sigdebug_received("SIGDEBUG_NOMLOCK");
mlockall(MCL_CURRENT | MCL_FUTURE);
errno = 0;
tmp_fd = mkstemp(tempname);
check_no_error("mkstemp", -errno);
unlink(tempname);
check_no_error("unlink", -errno);
mem = mmap(NULL, 1, PROT_READ | PROT_WRITE, MAP_SHARED, tmp_fd, 0);
check_no_error("mmap", -errno);
err = write(tmp_fd, "X", 1);
check("write", err, 1);
err = rt_task_shadow(&main_task, "main_task", 0, 0);
check_no_error("rt_task_shadow", err);
err = rt_mutex_create(&prio_invert, "prio_invert");
check_no_error("rt_mutex_create", err);
err = rt_mutex_acquire(&prio_invert, TM_INFINITE);
check_no_error("rt_mutex_acquire", err);
err = rt_sem_create(&send_signal, "send_signal", 0, S_PRIO);
check_no_error("rt_sem_create", err);
err = rt_task_spawn(&rt_task, "rt_task", 0, 1, T_WARNSW | T_JOINABLE,
rt_task_body, NULL);
check_no_error("rt_task_spawn", err);
err = rt_sem_p(&send_signal, TM_INFINITE);
check_no_error("rt_sem_signal", err);
pthread_kill(rt_task_thread, SIGUSR1);
rt_task_sleep(rt_timer_ns2ticks(20000000LL));
err = rt_mutex_release(&prio_invert);
check_no_error("rt_mutex_release", err);
err = rt_task_join(&rt_task);
check_no_error("rt_task_join", err);
err = rt_mutex_delete(&prio_invert);
check_no_error("rt_mutex_delete", err);
err = rt_sem_delete(&send_signal);
check_no_error("rt_sem_delete", err);
if (wd) {
fprintf(wd, "%d", old_wd_value);
fclose(wd);
}
fprintf(stderr, "Test OK\n");
return 0;
}
static void rt_thread_entry1(void* parameter)
{
rt_err_t result;
rt_tick_t tick;
/* 1. staic mutex demo */
/* 试图持有互斥量，最大等待10个OS Tick后返回 */
rt_kprintf("thread1 try to get static mutex, wait 10 ticks.\n");
/* 获得当前的OS Tick */
tick = rt_tick_get();
result = rt_mutex_take(&static_mutex, 10);
if (result == -RT_ETIMEOUT)
{
/* 超时后判断是否刚好是10个OS Tick */
if (rt_tick_get() - tick != 10)
{
rt_mutex_detach(&static_mutex);
return;
}
rt_kprintf("thread1 take static mutex timeout\n");
}
else
{
/* 线程2持有互斥量，且在相当长的时间后才会释放互斥量，
* 因此10个tick后线程1不可能获得 */
rt_kprintf("thread1 take a static mutex, failed.\n");
rt_mutex_detach(&static_mutex);
return;
}
/* 永久等待方式持有互斥量 */
rt_kprintf("thread1 try to get static mutex, wait forever.\n");
result = rt_mutex_take(&static_mutex, RT_WAITING_FOREVER);
if (result != RT_EOK)
{
/* 不成功则测试失败 */
rt_kprintf("thread1 take a static mutex, failed.\n");
rt_mutex_detach(&static_mutex);
return;
}
rt_kprintf("thread1 take a staic mutex, done.\n");
/* 脱离互斥量对象 */
rt_mutex_detach(&static_mutex);
/* 2. dynamic mutex test */
/* 试图持有互斥量，最大等待10个OS Tick后返回 */
rt_kprintf("thread1 try to get dynamic mutex, wait 10 ticks.\n");
tick = rt_tick_get();
result = rt_mutex_take(dynamic_mutex, 10);
if (result == -RT_ETIMEOUT)
{
/* 超时后判断是否刚好是10个OS Tick */
if (rt_tick_get() - tick != 10)
{
rt_mutex_delete(dynamic_mutex);
return;
}
rt_kprintf("thread1 take dynamic mutex timeout\n");
}
else
{
/* 线程2持有互斥量，且在相当长的时间后才会释放互斥量，
* 因此10个tick后线程1不可能获得 */
rt_kprintf("thread1 take a dynamic mutex, failed.\n");
rt_mutex_delete(dynamic_mutex);
return;
}
/* 永久等待方式持有互斥量 */
rt_kprintf("thread1 try to get dynamic mutex, wait forever.\n");
result = rt_mutex_take(dynamic_mutex, RT_WAITING_FOREVER);
if (result != RT_EOK)
{
/* 不成功则测试失败 */
rt_kprintf("thread1 take a dynamic mutex, failed.\n");
rt_mutex_delete(dynamic_mutex);
return;
}
rt_kprintf("thread1 take a dynamic mutex, done.\n");
/* 删除互斥量对象 */
rt_mutex_delete(dynamic_mutex);
}
int main(void)
{
unsigned long long before;
RT_ALARM nalrm;
RT_BUFFER nbuf;
RT_COND ncond;
RT_EVENT nevt;
RT_HEAP nheap;
RT_MUTEX nmtx;
RT_PIPE npipe;
RT_QUEUE nq;
RT_SEM nsem;
RT_TASK ntsk;
int failed = 0;
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_print_auto_init(1);
rt_fprintf(stderr, "Checking for leaks in native skin services\n");
before = get_used();
check_native(rt_alarm_create(&nalrm, NULL));
check_native(rt_alarm_delete(&nalrm));
check_used("alarm", before, failed);
before = get_used();
check_native(rt_buffer_create(&nbuf, NULL, 16384, B_PRIO));
check_native(rt_buffer_delete(&nbuf));
check_used("buffer", before, failed);
before = get_used();
check_native(rt_cond_create(&ncond, NULL));
check_native(rt_cond_delete(&ncond));
check_used("cond", before, failed);
before = get_used();
check_native(rt_event_create(&nevt, NULL, 0, EV_PRIO));
check_native(rt_event_delete(&nevt));
check_used("event", before, failed);
before = get_used();
check_native(rt_heap_create(&nheap, "heap", 16384, H_PRIO | H_SHARED));
check_native(rt_heap_delete(&nheap));
check_used("heap", before, failed);
before = get_used();
check_native(rt_mutex_create(&nmtx, NULL));
check_native(rt_mutex_delete(&nmtx));
check_used("mutex", before, failed);
before = get_used();
check_native(rt_pipe_create(&npipe, NULL, P_MINOR_AUTO, 0));
check_native(rt_pipe_delete(&npipe));
check_used("pipe", before, failed);
before = get_used();
check_native(rt_queue_create(&nq, "queue", 16384, Q_UNLIMITED, Q_PRIO));
check_native(rt_queue_delete(&nq));
check_used("queue", before, failed);
before = get_used();
check_native(rt_sem_create(&nsem, NULL, 0, S_PRIO));
check_native(rt_sem_delete(&nsem));
check_used("sem", before, failed);
before = get_used();
check_native(rt_task_spawn(&ntsk, NULL, 0, 1, T_JOINABLE, empty, NULL));
check_native(rt_task_join(&ntsk));
sleep(1); /* Leave some time for xnheap
* deferred free */
check_used("task", before, failed);
return failed ? EXIT_FAILURE : EXIT_SUCCESS;
}
/* Task objects cleanup */
void hit_task_cleanup_objects(){
if(hit_task_mutex_created){
hit_task_mutex_created = 0;
rt_mutex_delete(&hit_task_mutex);
}
}
/** Delete a semaphore
* @param mutex the mutex to delete
*/
void sys_mutex_free(sys_mutex_t *mutex)
{
RT_DEBUG_NOT_IN_INTERRUPT;
rt_mutex_delete(*mutex);
}
// Supprime toutes les tâches créées par game_init
int end_game(void)
{
err = rt_task_delete(&refresh_task);
if (err != 0) {
printk("delete refresh task failed: %d\n", err);
return -1;
}
err = rt_task_delete(&move_task);
if (err != 0) {
printk("delete move task failed: %d\n", err);
return -1;
}
err = rt_task_delete(&ennemi_task);
if (err != 0) {
printk("delete move task failed: %d\n", err);
return -1;
}
err = rt_task_delete(&shots_impacts_task);
if (err != 0) {
printk("delete shots_impacts task failed: %d\n", err);
return -1;
}
err = rt_task_delete(&missile_ennemi_task);
if (err != 0) {
printk("delete shots_impacts task failed: %d\n", err);
return -1;
}
err = rt_task_delete(&switch_events_task);
if (err != 0) {
printk("delete switch_events task failed: %d\n", err);
return -1;
}
err = rt_task_delete(&gift_task);
if (err != 0) {
printk("delete gift task failed: %d\n", err);
return -1;
}
err = rt_mutex_delete(&mutex_ennemi);
if (err != 0) {
printk("delete mutex ennemi failed: %d\n", err);
return -1;
}
err = rt_mutex_delete(&mutex_shots);
if (err != 0) {
printk("delete mutex shots failed: %d\n", err);
return -1;
}
err = rt_mutex_delete(&mutex_score);
if (err != 0) {
printk("delete mutex score failed: %d\n", err);
return -1;
}
return 0;
}
