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;
}
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);
}
}
void initServoMotor(OUT_SERVO_MOTOR * servo, int pin, int angle){
servo->angle=angle;
servo->pin=pin;
INP_GPIO(pin);
OUT_GPIO(pin);
int err = rt_task_create(&(servo->task), "task", TASK_STKSZ, TASK_PRIO, TASK_MODE);
err |= rt_alarm_create(&(servo->alarm),"alarm");
err |= rt_task_set_periodic(&(servo->task), TM_NOW, PERIODE_SERVO_MOTOR);
if (!err) {
rt_task_start(&(servo->task),&taskServo,servo);
}
}
int rt_alarm_create(RT_ALARM *alarm, const char *name)
{
struct trank_alarm_wait *aw;
pthread_mutexattr_t mattr;
pthread_condattr_t cattr;
int ret;
aw = xnmalloc(sizeof(*aw));
if (aw == NULL)
return -ENOMEM;
aw->alarm_pulses = 0;
pthread_mutexattr_init(&mattr);
pthread_mutexattr_settype(&mattr, mutex_type_attribute);
pthread_mutexattr_setprotocol(&mattr, PTHREAD_PRIO_INHERIT);
pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_PRIVATE);
ret = __bt(-__RT(pthread_mutex_init(&aw->lock, &mattr)));
pthread_mutexattr_destroy(&mattr);
if (ret)
goto fail_lock;
pthread_condattr_init(&cattr);
pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_PRIVATE);
ret = __bt(-pthread_cond_init(&aw->event, &cattr));
pthread_condattr_destroy(&cattr);
if (ret)
goto fail_cond;
ret = __CURRENT(rt_alarm_create(alarm, name, trank_alarm_handler, aw));
if (ret)
goto fail_alarm;
return 0;
fail_alarm:
__RT(pthread_cond_destroy(&aw->event));
fail_cond:
__RT(pthread_mutex_destroy(&aw->lock));
fail_lock:
xnfree(aw);
return ret;
}
int main(int argc, char *const argv[])
{
int ret;
traceobj_init(&trobj, argv[0], sizeof(tseq) / sizeof(int));
ret = rt_alarm_create(&alrm, "ALARM", alarm_handler, &alrm);
traceobj_check(&trobj, ret, 0);
ret = rt_task_spawn(&t_main, "main_task", 0, 50, 0, main_task, NULL);
traceobj_check(&trobj, ret, 0);
traceobj_mark(&trobj, 8);
traceobj_join(&trobj);
traceobj_verify(&trobj, tseq, sizeof(tseq) / sizeof(int));
exit(0);
}
int main(int argc, char *argv[]) {
setup_gpio_address();
INP_GPIO(GPIO_PIN);
OUT_GPIO(GPIO_PIN);
mlockall(MCL_CURRENT|MCL_FUTURE);
//servo1 = open("/sys/class/gpio/gpio18/value",O_WRONLY);
int err = rt_task_create(&task_desc, "MiseA1", TASK_STKSZ, TASK_PRIO, TASK_MODE);
err |= rt_alarm_create(&alarm_desc,"MiseA0");
err |= rt_task_set_periodic(&task_desc, TM_NOW, 20000000);
if (!err) {
rt_task_start(&task_desc,&task_body,NULL);
}
pause();
return 0;
}
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;
}
