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_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[])
{
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(){
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) {
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(int argc, char * argv[])
{
RT_TASK task;
RTIME period;
int err;
int fd;
int zero = 0;
fd = open("/dev/cpu_dma_latency", O_WRONLY);
if (fd >= 0) {
write(fd, &zero, sizeof(zero));
// don't close the file before process termination.
}
if ((argc != 2)
|| (sscanf(argv[1], "%llu", &period) != 1)) {
fprintf(stderr, "usage: %s period_us\n", argv[0]);
exit(EXIT_FAILURE);
}
mlockall(MCL_CURRENT|MCL_FUTURE);
err = rt_task_spawn(& task, NULL, 0, 99,
T_JOINABLE, periodic_task, & period);
if (err != 0) {
fprintf(stderr, "rt_task_spaw: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
rt_task_join(& task);
return 0;
}
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[])
{
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(void)
{
RT_TASK main_tcb;
RT_TASK tcb;
mqd_t mq;
int i;
mlockall(MCL_CURRENT | MCL_FUTURE);
fprintf(stderr, "Checking select service with posix message queues\n");
rt_task_shadow(&main_tcb, NULL, 0, 0);
mq = mq_open("/select_test_mq", O_RDWR | O_CREAT | O_NONBLOCK, 0, NULL);
check_unix(mq == -1 ? -1 : 0);
check_native(rt_task_create(&tcb, "select_test", 0, 1, T_JOINABLE));
check_native(rt_task_start(&tcb, task, (void *)(long)mq));
alarm(30);
for(i = 0; i < sizeof(tunes) / sizeof(tunes[0]); i++) {
check_unix(mq_send(mq, tunes[i], strlen(tunes[i]) + 1, 0));
sleep(1);
}
check_native(rt_task_join(&tcb));
fprintf(stderr, "select service with posix message queues: success\n");
return EXIT_SUCCESS;
}
bool RTROSMotorSettingService::motorSet(rt_dynamixel_msgs::MotorSettingRequest &req,
rt_dynamixel_msgs::MotorSettingResponse &res)
{
for(int i=0; i<4; i++)
{
dxlDevice[i].bControlLoopEnable = false;
}
for(int i=0; i<4; i++)
{
while(dxlDevice[i].bControlLoopProcessing) {}
}
RT_TASK rttMotorSetTask;
rt_task_create(&rttMotorSetTask,"dxl motorset service",0,7,T_JOINABLE);
motorResponse.result = -1;
motorRequest = req;
rt_task_start(&rttMotorSetTask, &motor_set_proc, (void*)this);
rt_task_join(&rttMotorSetTask);
rt_task_delete(&rttMotorSetTask);
res = motorResponse;
//res.result = req.mode;
for(int i=0; i<4; i++)
{
dxlDevice[i].bControlLoopEnable = true;
}
return true;
}
INTERNAL_QUAL void rtos_task_delete(RTOS_TASK* mytask) {
if ( rt_task_join(&(mytask->xenotask)) != 0 ) {
log(Error) << "Failed to join with thread " << mytask->name << endlog();
}
rt_task_delete(&(mytask->xenotask));
free(mytask->name);
mytask->name = NULL;
}
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;
};
RealtimeController::~RealtimeController()
{
// signaloidaan säikeelle että sen pitää sammuttaa itsensä
if(write(pipefd, "theEnd", sizeof("theEnd")) < 0)
qDebug("error %d : %s\n", -errno, strerror(-errno));
// odotetaan kunnes säie on sammunut, erillistä deleteä EI saa tehdä
rt_task_join(&task_desc);
// vapautetaan pipen resurssit
rt_pipe_delete(&pipe_desc);
}
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++;
}
}
TEST(JitterTest, Loop) {
int i;
Loop* worker = new Loop[n_worker];
ASSERT_EQ(/* Avoids memory swapping for this program */
mlockall(MCL_CURRENT|MCL_FUTURE)
, 0);
if(g_outfn) {
ASSERT_TRUE(g_outf = fopen(g_outfn, "w"));
ASSERT_GE(fprintf(g_outf, "worker.id,loop,period[ms],work[us],jitter[us]\n")
, 0);
}
pthread_t print_thread;
pthread_attr_t attr;
struct sched_param sched_param;
pthread_attr_init(&attr);
sched_param.sched_priority = sched_get_priority_min(SCHED_OTHER);
pthread_attr_setschedparam(&attr, &sched_param);
pthread_create(&print_thread, &attr, printloop, (void*)worker);
abs_start = rt_timer_read();/* get the current time that the threads
can base their scheduling on */
ASSERT_GT(abs_start, 0);
signal(SIGXCPU, warn_upon_switch);
/* create the threads to do the timing */
for(i = 0; i < n_worker; i++) {
sprintf(worker[i].name, "Worker%d", i);
ASSERT_EQ(rt_task_create(&worker[i].thread, worker[i].name
, 0 /* default stack size*/
, 1 /* 0 is the lowest priority */
, T_FPU | T_JOINABLE)
, 0);
worker[i].id = i;
ASSERT_EQ(rt_task_start(&worker[i].thread, &workloop, (void*)&worker[i])
, 0);
}
sleep(duration); /* Sleep for the defined test duration */
log_info("Shutting down.");
bTesting = 0;/* signal the worker threads to exit then wait for them */
for (i = 0 ; i < n_worker ; ++i) {
EXPECT_EQ(rt_task_join(&worker[i].thread), 0);
}
EXPECT_EQ(pthread_join(print_thread, NULL), 0);
delete[] worker;
if(g_outf) {
fclose(g_outf); g_outf = NULL;
}
}
int main (int argc, char **argv)
{
signal(SIGINT, cleanup_upon_sig);
signal(SIGTERM, cleanup_upon_sig);
signal(SIGHUP, cleanup_upon_sig);
signal(SIGALRM, cleanup_upon_sig);
rt_task_create(&display_task, "dsptsk", 0, 97, 0);
rt_task_start(&display_task, &display, NULL);
pause();
rt_task_join("dsptsk");
return 0;
}
int stopPLC()
{
/* Stop the PLC */
PLC_shutdown = 1;
/* Wait until PLC task stops */
rt_task_join(&PLC_task);
PLC_cleanup_all();
__cleanup();
__debug_tick = -1;
return 0;
}
int main() {
mlockall(MCL_CURRENT|MCL_FUTURE);
RT_TASK low, high, sync;
rt_task_create(&low, "low", 0, 0, T_CPU(1)|T_JOINABLE);
rt_task_create(&high, "high", 0, 1, 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_task_start(&low, &wait, NULL);
rt_task_start(&high, &wait, NULL);
rt_task_start(&sync, &syncFunc, NULL);
rt_task_join(&low);
rt_task_join(&high);
rt_task_join(&sync);
rt_sem_delete(&sem);
return 0;
}
int main(void)
{
int err;
RT_TASK task, task2;
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_print_auto_init(1);
if (((err = rt_task_spawn( & task,"HELLO",0,99,T_JOINABLE,hello,NULL)) != 0 )) {
fprintf(stderr, "rt_task_spawn : %s\n",strerror(-err));
exit(EXIT_FAILURE);
}
if (((err = rt_task_spawn( & task2,"HELLO2",0,98,T_JOINABLE,hello2,NULL)) != 0 )) {
fprintf(stderr, "rt_task_spawn : %s\n",strerror(-err));
exit(EXIT_FAILURE);
}
rt_task_join( & task );
rt_task_join( & task2);
return 0;
}
int _rtapi_task_delete_hook(task_data *task, int task_id) {
int retval = 0;
if ((retval = rt_task_delete( &ostask_array[task_id] )) < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,"ERROR: rt_task_delete(%d) failed: %d %s\n",
task_id, retval, strerror(-retval));
return retval;
}
// actually wait for the thread to exit
if ((retval = rt_task_join( &ostask_array[task_id] )) < 0)
rtapi_print_msg(RTAPI_MSG_ERR,"ERROR: rt_task_join(%d) failed: %d %s\n",
task_id, retval, strerror(-retval));
return retval;
}
int main(int argc, char *argv[])
{
int i, err;
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
mlockall(MCL_CURRENT | MCL_FUTURE);
can_handle = CAN_Open(HW_PCI, 1);
CAN_Init(can_handle, CAN_BAUD_1M, CAN_INIT_TYPE_EX);
printf("Status = %i\n", CAN_Status(can_handle));
for (i = 0; i < 5; i++) {
can_msg[i].MSGTYPE = MSGTYPE_EXTENDED;
can_msg[i].LEN = 8;
printf("Frame = %08lx %02x %02x %02x %02x %02x %02x %02x %02x, "
"Time diff = %llu ns\n",
(unsigned long) (can_msg[i].ID = i*13),
can_msg[i].DATA[0] = i*6,
can_msg[i].DATA[1] = i*7,
can_msg[i].DATA[2] = i*8,
can_msg[i].DATA[3] = i*9,
can_msg[i].DATA[4] = i*10,
can_msg[i].DATA[5] = i*11,
can_msg[i].DATA[6] = i*12,
can_msg[i].DATA[7] = i*13,
i == 0 ? 0 : (unsigned long long) TIME_DIFF
);
}
err = rt_task_create(&test_task, "test", 0, 99, T_JOINABLE);
if (err) {
printf("receivetest: Failed to create rt task, code %d\n",
errno);
return err;
}
rt_task_start(&test_task, test, NULL);
if (err) {
printf("receivetest: Failed to start rt task, code %d\n",
errno);
return errno;
}
rt_task_join(&test_task);
CAN_Close(can_handle);
return 0;
}
int main()
{
int i=0;
int err=0;
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
mlockall(MCL_CURRENT | MCL_FUTURE);
can_handle = CAN_Open(HW_PCI, 1);
CAN_Init(can_handle, CAN_BAUD_1M, CAN_INIT_TYPE_EX);
printf("Status = %i\n", CAN_Status(can_handle));
err=rt_task_create(&test_task, "test", 0, 99, T_JOINABLE);
if (err) {
printf("receivetest: Failed to create rt task, code %d\n",errno);
return err;
}
rt_task_start(&test_task, test, NULL);
if (err) {
printf("receivetest: Failed to start rt task, code %d\n",errno);
return errno;
}
rt_task_join(&test_task);
for (i = 0; i < 5; i++)
{
printf(
"Frame = %08lx %02x %02x %02x %02x %02x %02x %02x %02x, Time diff = %llu ns\n",
(unsigned long) can_msg[i].Msg.ID,
can_msg[i].Msg.DATA[0],
can_msg[i].Msg.DATA[1],
can_msg[i].Msg.DATA[2],
can_msg[i].Msg.DATA[3],
can_msg[i].Msg.DATA[4],
can_msg[i].Msg.DATA[5],
can_msg[i].Msg.DATA[6],
can_msg[i].Msg.DATA[7],
i == 0 ? 0 :
(can_msg[i].dwTime*(unsigned long long)1000+can_msg[i].wUsec)*1000-
(can_msg[i-1].dwTime*(unsigned long long)1000+can_msg[i-1].wUsec)*1000
);
}
CAN_Close(can_handle);
return 0;
}
//startup code
void startup()
{
//begin task
rt_printf("Creating timertask...\n");
rt_task_create(&timertask,"timertask",0,50,T_JOINABLE);
rt_printf("Setting period...\n");
rt_task_set_periodic(&timertask,TM_NOW,PERIOD);
rt_task_start(&timertask,&timer,NULL);
/* debug code
int i;
for(i = 0;i<MEASUREMENTS;i++)
{
rt_printf("%d\t%u\n",i,exec_times[i]);
}
*/
rt_task_join(&timertask);
compute_differences();
write_RTIMES("time_diff.csv",MEASUREMENTS-1,exec_diff);
}
int main()
{
RT_TASK task;
// bloque la memoire virtuelle pour ne pas avoir de swap
mlockall(MCL_CURRENT|MCL_FUTURE);
//
rt_print_auto_init(1);
// spawn : cree et lance la tache : equiv rt_task_create + rt_task_start
if (rt_task_spawn(& task, NULL, 0, 99,
T_JOINABLE, fonction_periodique, NULL) != 0) {
fprintf(stderr, "Impossible de creer la tache\n");
exit(EXIT_FAILURE);
}
rt_task_join(& task);
return 0;
}
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);
}
bool EcMaster::reset() throw(EcError)
{
if (m_useDC)
{
for (int i = 0; i < m_drivers.size(); i++)
m_drivers[i] -> setDC(false, m_cycleTime, 0);
}
taskFinished = true;
//Wait on the termination of task.
rt_task_join (task);
// delete the periodic task
rt_task_delete(task);
bool success = switchState (EC_STATE_INIT);
if (!success)
throw(EcError(EcError::FAIL_SWITCHING_STATE_INIT));
for (unsigned int i = 0; i < m_drivers.size(); i++)
delete m_drivers[i];
m_drivers.resize(0);
#ifdef HRT
delete[] outputBuf;
delete[] inputBuf;
#endif
delete[] m_ecPort;
delete task;
for (size_t i = 0; i < 4096; i++)
m_IOmap[i] = 0;
ec_close();
rt_printf("Master reseted!!! \n");
return true;
}
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(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;
}
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;
}
int main(int argc, char **argv)
{
printf("%s\n","Created Model");
int serversock, clientsock;
size_t clientlen;
struct sockaddr_in server_addr, client_addr, view_addr[2];
unsigned int port;
unsigned int view_port;
char *portNum;
mlockall(MCL_CURRENT | MCL_FUTURE);
signal(SIGKILL, cleanup);
if(argc < 1){
usage(*argv);
exit(0);
}
int c;
while((c = getopt(argc, argv, "p:b:v:")) != -1){
switch(c){char data[1024];
case 'p':
port = atoi(strdup(optarg));
break;
case 'v':
view_port = atoi(strdup(optarg));
break;
/* many potential super fast speeds can be achieved */
case 'b':
ballThreadSpeed = atoi(optarg) > 0 ?
atoi(optarg) : BTHREAD_RATIO;
break;
default:
usage(*argv);
exit(0);
break;
}
}
mThreadPid = getpid();
initializePong();
/* if(rt_task_create(&ballThread, "ball_Thread" ,4096, 99, 0))
rt_err("rt_task_create()");
if(rt_task_create(&recvThread[0], "Recv_Thread", 4096, 99, T_JOINABLE))
rt_err("rt_task_create()");
if(rt_task_create(&recvThread[1], "Recv2_Thread", 4096, 99, T_JOINABLE))
rt_err("rt_task_create()");
*/
/* task creation */
char temp_ball_Thread[1000];
char temp_Recv_Thread[1000];
char temp_Recv2_Thread[1000];
sprintf(temp_ball_Thread,"BallThread%d",port);
sprintf(temp_Recv_Thread,"RecvThread%d",port);
sprintf(temp_Recv2_Thread,"RecvThread2%d",port);
if(rt_task_create(&ballThread, temp_ball_Thread ,4096, 99, 0))
rt_err("rt_task_create()");
if(rt_task_create(&recvThread[0], temp_Recv_Thread, 4096, 99, T_JOINABLE))
rt_err("rt_task_create()");
if(rt_task_create(&recvThread[1], temp_Recv2_Thread, 4096, 99, T_JOINABLE))
rt_err("rt_task_create()");
/* creation of mutexes for buffer */
unsigned int i = 0;
for(; i < 3; i++){
char buf[8];
sprintf(buf, "Mutex %d %d", i, port);
if(rt_mutex_create(&txMutex[i], buf))
rt_err("rt_mutex_create()");
}
char temp_start_mutex[1000];
sprintf(temp_start_mutex,"AutoStartMutex%d",port);
if(rt_mutex_create(&autoStart, temp_start_mutex))
rt_err("rt_mutex_create()");
i = 0;
/* socket creation and structure initialization*/
if ((serversock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
errx(EXIT_FAILURE, "socket()", strerror(-errno));
int yes = 1;
if(setsockopt(serversock,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1){
perror("Setsockopt");
exit(1);
}
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(port); /* server port */
if (bind(serversock, (struct sockaddr *) &server_addr,
sizeof(server_addr)) < 0){
close(serversock);
errx(EXIT_FAILURE, "bind():", strerror(errno));
}
/* listens for Game Controller only*/
if (listen(serversock, 1) < 0)
errx(EXIT_FAILURE, "listen():", strerror(-errno));
int viewSocket;
if ((viewSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
rt_err("socket()");
/* connection loop */
printf("Waiting for connections ...\n");
while(true){
char *currClient;
clientlen = sizeof(struct sockaddr_in);
clientsock = accept(serversock,
(struct sockaddr *)&client_addr, (socklen_t *)&clientlen);
currClient = (char *)inet_ntoa(client_addr.sin_addr);
if(i > 1 || (i < 1 && !issuedStart)){ //game in play by force or 2 players
close(clientsock);
fprintf(stderr, "rejecting %s "
"only 2 clients allowed!\n", currClient);
continue;
}
//spawn the receive thread for simulator
player_t players[2];
players[i].socket = clientsock;
players[i].vsocket = viewSocket;
players[i].addr = client_addr;
if(rt_task_start(&recvThread[i], recv_data, (void *)&players[i]))
rt_err("rt_task_start()");
i++;
viewMode++;
/* 1st player connected */
if(i == 1){
initSock = clientsock;
/* spawn task to countdown */
if(rt_task_spawn(&alarmTask, "AutoStart", 4096, 99, 0,
alarm_handler, (void *)viewSocket))
rt_err("rt_task_spawn()");
/* start the ball thread and it handles further movement */
if(rt_task_start(&ballThread, run,(void*)viewSocket))
rt_err("rt_task_start()");
printf("1 Player Connected ...\n");
/* now need to connect to the view */
memset(&view_addr[0], 0, sizeof(view_addr[0]));
view_addr[0].sin_family = AF_INET;
view_addr[0].sin_addr.s_addr = inet_addr(currClient);
view_addr[0].sin_port = htons(view_port);
/* Establish connection to view */
if (connect(viewSocket,(struct sockaddr *) &view_addr[0], sizeof(view_addr[0])) < 0)
rt_err("connect()");
}
/* the case when both players start before one-shot alarm */
if(i == 2){
/*Now need to connect the second view if there is one*/
if ((viewSocket2= socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
rt_err("socket()");/*2 View mode case*/
memset(&view_addr[1], 0, sizeof(view_addr[1]));
view_addr[1].sin_family = AF_INET;
view_addr[1].sin_addr.s_addr = inet_addr(currClient);
view_addr[1].sin_port = htons(view_port);
if (connect(viewSocket2,(struct sockaddr *) &view_addr[1], sizeof(view_addr[1])) < 0)
rt_err("connect()2");
rt_mutex_acquire(&autoStart, TM_INFINITE);
issuedStart = false;
rt_mutex_release(&autoStart);
rt_task_resume(&recvThread[0]);
rt_task_resume(&recvThread[1]);
}
}
//join on receive
rt_task_join(&recvThread[0]);
rt_task_join(&recvThread[1]);
return 0;
}
