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 *signalSan(void *arg) { RT_TASK *Task_3; unsigned long Task_3_name = nam2num("TSK_3") + i++; time_t aclock; time_t clockNow; int timeEx, begin_3; int count = 0; struct tm *newtime; Task_3 = rt_task_init(Task_3_name, 0, 0, 0); // if(!(Task_3 = rt_task_init_schmod(Task_3_name,3,0,0,SCHED_FIFO,1))) { // printf("CANNOT INIT HANDLER TASK > Task 3 <\n"); // exit(1); // } rt_allow_nonroot_hrt(); rt_make_hard_real_time(); rt_task_make_periodic(Task_3, rt_get_time(), sampling * 30); rt_change_prio(Task_3, 3); begin_3 = begin; while (count < 20) { rt_sem_wait(rMutex); time(&aclock); // Pega tempo em segundos. newtime = localtime(&aclock); printf(" Signal 3 =======> %s", asctime(newtime)); sleep(1); time(&aclock); // Pega tempo em segundos. newtime = localtime(&aclock); printf(" Signal 3 after Sleep =======> %s", asctime(newtime)); timeEx = 3600 * newtime->tm_hour + 60 * newtime->tm_min + newtime->tm_sec; if( (timeEx - begin_3) > 15 ) printf(" Time Failure of the Signal 3\n"); else printf(" Time Correct of the Signal 3\n"); begin_3 = timeEx + (15 - (timeEx-begin)%15); rt_sem_signal(rMutex); rt_task_wait_period(); count++; } rt_make_soft_real_time(); rt_task_delete(Task_3); return 0; }
INTERNAL_QUAL int rtos_task_set_priority(RTOS_TASK * mytask, int priority) { int rv; if (mytask->rtaitask == 0) return -1; // returns the *old* priority. rv = rt_change_prio( mytask->rtaitask, priority); if (rv == mytask->priority) { mytask->priority = priority; return 0; } return -1; }
void *signalIchi(void *arg) { RT_TASK *Task_1; unsigned long Task_1_name = nam2num("TSK_1") + i++; time_t aclock; time_t clockNow; int timeEx; int begin_1; int count = 0; struct tm *newtime, *timeNow; Task_1 = rt_task_init(Task_1_name, 0, 0, 0); // if(!(Task_1 = rt_task_init_schmod(Task_1_name,2,0,0,SCHED_FIFO,1))) { // printf("CANNOT INIT HANDLER TASK > Task 1 <\n"); // exit(1); // } /** * Allows a non root user to use the Linux POSIX soft real time process management and memory * lock functions, and allows it to do any input-output operation from user space. * * Only the process itself can use this functions, it is not possible to impose the related * transition from another process. */ rt_allow_nonroot_hrt(); rt_make_hard_real_time(); rt_task_make_periodic(Task_1, rt_get_time(), sampling * 16); rt_change_prio(Task_1, 2); begin_1 = begin; while (count < 20) { time(&aclock); // Pega tempo em segundos. newtime = localtime(&aclock); rt_sem_wait(rMutex); printf(" Signal 1 =======> %s", asctime(newtime)); sleep(1); time(&aclock); // Pega tempo em segundos. newtime = localtime(&aclock); printf(" Signal 1 after Sleep =======> %s", asctime(newtime)); timeEx = 3600 * newtime->tm_hour + 60 * newtime->tm_min + newtime->tm_sec; if( (timeEx - begin_1) > 8 ) printf(" Time Failure of the Signal 1\n"); else printf(" Time Correct of the Signal 1\n"); begin_1 = timeEx + (8 - (timeEx-begin)%8); rt_sem_signal(rMutex); rt_task_wait_period(); count++; } rt_make_soft_real_time(); rt_task_delete(Task_1); return 0; }
void *init_task(void *arg) { RT_TASK *Task; struct thread_param *config = (struct thread_param*) arg; int idTask = config->idTask; unsigned long pidTask = 0; unsigned int cpuFrequencyAtual = 0; // KHz RTIME Tinicio; RTIME Tperiodo = 0; // unidade -> counts double Tperiodo_s = 0.0; int prioridade = config->prioridade; // clock_t begin, end; // double time_spent; struct timeval tv1, tv2; if(!(Task = rt_thread_init(idTask, prioridade, 0, SCHED_FIFO, CPU_ALLOWED))) { printf("[ERRO] Não foi possível criar a tarefa [%d].\n", idTask); exit(1); } Tinicio = start_timeline; Tperiodo = config->periodo; Tperiodo_s = count2nano(Tperiodo)/1000000000.0; rt_allow_nonroot_hrt(); rt_task_make_periodic(Task, Tinicio, Tperiodo); rt_change_prio(Task, prioridade); if(config->deadline > 0) rt_set_deadline(Task, config->deadline); pidTask = rt_cfg_get_pid(Task); printf("[TASK %2d] [%lu] Criada com Sucesso =============== PERIODO => %llu count => %.2f segundos \n", idTask, pidTask, Tperiodo, Tperiodo_s); cpuFrequencyAtual = rt_cfg_cpufreq_get(CPUID_RTAI); printf("[TASK %2d] [%lu] Curr Freq: %8d Khz\n", idTask, pidTask, cpuFrequencyAtual); //TODO: TEMPO DE COMPUTACAO - OPCAO 1 // begin = clock(); // rt_cfg_set_cpu_frequency(Task, (int) config->cpuFrequencyMin); // end = clock(); // // time_spent = (double)(end - begin) / CLOCKS_PER_SEC; // printf("[TASK %2d] [%lu] SET_FREQUENCY(%8d Khz);\n", idTask, pidTask, config->cpuFrequencyMin); // cpuFrequencyAtual = rt_cfg_cpufreq_get(CPUID_RTAI); // printf("[TASK %2d] [%lu] Curr Freq: %8d Khz\n", idTask, pidTask, cpuFrequencyAtual); // printf("[TASK %2d] [%lu] TEMPO DE COMPUTACAO SET FREQUENCY - USERSPACE => %.100f segundos\n", idTask, pidTask, time_spent); //TODO: TEMPO DE COMPUTACAO - OPCAO 2 gettimeofday(&tv1, NULL); rt_cfg_set_cpu_frequency(Task, (int) config->cpuFrequencyMin); gettimeofday(&tv2, NULL); printf("[TASK %2d] [%lu] SET_FREQUENCY(%8d Khz);\n", idTask, pidTask, config->cpuFrequencyMin); cpuFrequencyAtual = rt_cfg_cpufreq_get(CPUID_RTAI); printf("[TASK %2d] [%lu] Curr Freq: %8d Khz\n", idTask, pidTask, cpuFrequencyAtual); printf("[TASK %2d] [%lu] TEMPO DE COMPUTACAO SET FREQUENCY - USERSPACE => %.50f segundos\n", idTask, pidTask, (double) (tv2.tv_usec - tv1.tv_usec) / 1000000 + (double) (tv2.tv_sec - tv1.tv_sec)); rt_task_delete(Task); return 0; }