fosi.h
Go to the documentation of this file.
00001 /***************************************************************************
00002   tag: Peter Soetens  Mon Jun 10 14:43:39 CEST 2002  fosi.h
00003 
00004                         fosi.h -  description
00005                            -------------------
00006     begin                : Mon June 10 2002
00007     copyright            : (C) 2002 Peter Soetens
00008     email                : peter.soetens@mech.kuleuven.ac.be
00009 
00010  ***************************************************************************
00011  *                                                                         *
00012  *   This program is free software; you can redistribute it and/or modify  *
00013  *   it under the terms of the GNU General Public License as published by  *
00014  *   the Free Software Foundation; either version 2 of the License, or     *
00015  *   (at your option) any later version.                                   *
00016  *                                                                         *
00017  ***************************************************************************/
00018 
00019 
00026 #ifndef __FOSI_H
00027 #define __FOSI_H
00028 
00029 #ifndef _GNU_SOURCE
00030 #define _GNU_SOURCE   // use all Posix features (and then some).
00031 #endif
00032 
00033 
00034 #ifndef _XOPEN_SOURCE
00035 #define _XOPEN_SOURCE 600   // use all Posix98 features.
00036 #endif
00037 
00038 #define HAVE_FOSI_API
00039 
00040 #include <stdio.h>
00041 #include <stdlib.h>
00042 #include <stdarg.h>
00043 #include <sys/types.h>
00044 #include <sched.h>
00045 #include <assert.h>
00046 #include <limits.h>
00047 #include <float.h>
00048 #include "../oro_limits.h"
00049 
00050 #ifdef __cplusplus
00051 extern "C" {
00052 #endif
00053 
00054 #include "../../rtt-config.h"
00055 #if !defined(OROBLD_OS_AGNOSTIC) || defined(OROBLD_OS_LXRT_INTERNAL) // define the latter to include nevertheless the RTAI header files
00056 
00057         // force inlining if internal and internal to avoid an extra indirection.
00058         // otherwise, the inlining is selected by the user in his rtai configuration
00059 #if defined(OROBLD_OS_LXRT_INTERNAL)
00060 #define CONFIG_RTAI_LXRT_INLINE 1
00061 #endif
00062 
00063 // include custom redirect-like include
00064 #include <rtai_config.h>
00065 #include <rtai_lxrt.h>
00066 #include <rtai_sem.h>
00067 
00068         // Finally, define the types we use :
00069         typedef RT_TASK RTOS_RTAI_TASK;
00070         typedef SEM     RTOS_RTAI_SEM;
00071         typedef CND     RTOS_RTAI_CND;
00072 
00073 #else // AGNOSTIC
00074 
00075         // For PeriodicTask.cxx :
00076         // we need to define the types without the headers,
00077         // this is RTAI version dependent.
00078     // v3.x :
00079         typedef struct oro_lxrt_t {
00080                 int opaque;
00081         } __LXRT_HANDLE_STRUCT;
00082 
00083     typedef __LXRT_HANDLE_STRUCT RTOS_RTAI_TASK;
00084     typedef __LXRT_HANDLE_STRUCT RTOS_RTAI_SEM;
00085     typedef __LXRT_HANDLE_STRUCT RTOS_RTAI_CND;
00086 #endif // OROBLD_OS_AGNOSTIC // for RTAI header files.
00087 
00088         // this is required because the rtos_sem_init function takes a pointer to RTOS_SEM,
00089         // which contains a pointer to the real RTAI sem.
00090         typedef struct oro_rtai_sem_t {
00091                 RTOS_RTAI_SEM* sem;
00092         } rt_sem_t;
00093 
00094     // this is required because the rtos_cond_init function takes a pointer to RTOS_COND,
00095     // which contains a pointer to the real RTAI cond
00096     typedef struct oro_rtai_cond_t {
00097         RTOS_RTAI_CND* cond;
00098     } rt_cond_t;
00099 
00100 #define __LXRT_USERSPACE__
00101 
00102 
00103   typedef rt_sem_t rt_mutex_t;
00104   typedef rt_sem_t rt_rec_mutex_t;
00105 
00106         // Time Related
00107 
00108         typedef long long NANO_TIME;
00109         typedef long long TICK_TIME;
00110         typedef struct timespec TIME_SPEC;
00111 
00112         typedef struct {
00113                 pthread_t thread;
00114                 char * name;
00115                 int priority;
00116 
00117                 RTOS_RTAI_TASK* rtaitask;
00118         } RTOS_TASK;
00119 
00120     static const TICK_TIME InfiniteTicks = LLONG_MAX;
00121     static const NANO_TIME InfiniteNSecs = LLONG_MAX;
00122     static const double    InfiniteSeconds = DBL_MAX;
00123 
00124 #define SCHED_LXRT_HARD 0 
00125 #define SCHED_LXRT_SOFT 1 
00126 #define ORO_SCHED_RT    0 
00127 #define ORO_SCHED_OTHER 1 
00132 // rtai undef cfr boost::graph library adjacency_list.hpp:443
00133 #undef DS
00134 #undef OEL
00135 #undef VL
00136 #undef VP
00137 #undef EP
00138 #undef GP
00139 #undef EL
00140 
00141 #ifndef OROBLD_OS_AGNOSTIC
00142 
00143         // hrt is in ticks
00144 inline TIME_SPEC ticks2timespec(TICK_TIME hrt)
00145 {
00146         TIME_SPEC timevl;
00147         timevl.tv_sec = nano2count(hrt) / 1000000000LL;
00148         timevl.tv_nsec = nano2count(hrt) % 1000000000LL;
00149         return timevl;
00150 }
00151 
00152 // turn this on to have maximum detection of valid system calls.
00153 #ifdef OROSEM_OS_LXRT_CHECK
00154 #define CHK_LXRT_CALL() do { if(rt_buddy() == 0) { \
00155         printf("LXRT NOT INITIALISED IN THIS THREAD pid=%d,\n\
00156     BUT TRIES TO INVOKE LXRT FUNCTION >>%s<< ANYWAY\n", getpid(), __FUNCTION__ );\
00157         assert( rt_buddy() != 0 ); }\
00158         } while(0)
00159 #define CHK_LXRT_PTR(ptr) do { if(ptr == 0) { \
00160         printf("TRIED TO PASS NULL POINTER TO LXRT IN THREAD pid=%d,\n\
00161     IN TRYING TO INVOKE LXRT FUNCTION >>%s<<\n", getpid(), __FUNCTION__ );\
00162         assert( ptr != 0 ); }\
00163         } while(0)
00164 #else
00165 #define CHK_LXRT_CALL()
00166 #define CHK_LXRT_PTR( a )
00167 #endif
00168 
00169 inline NANO_TIME rtos_get_time_ns(void) { return rt_get_time_ns(); }
00170 
00171 inline TICK_TIME rtos_get_time_ticks(void) { return rt_get_time(); }
00172 
00173 inline TICK_TIME ticksPerSec(void) { return nano2count( 1000 * 1000 * 1000 ); }
00174 
00175         inline TICK_TIME nano2ticks(NANO_TIME t) { return nano2count(t); }
00176         inline NANO_TIME ticks2nano(TICK_TIME t) { return count2nano(t); }
00177 
00178 inline int rtos_nanosleep(const TIME_SPEC *rqtp, TIME_SPEC *rmtp)
00179 {
00180     CHK_LXRT_CALL();
00181     nanosleep(rqtp,rmtp); // rtai 24.1.9
00182     return 0;
00183 }
00184 
00185     static inline int rtos_sem_init(rt_sem_t* m, int value )
00186     {
00187         CHK_LXRT_CALL();
00188                 // store the pointer in m->opaque...
00189         m->sem = rt_sem_init( rt_get_name(0) , value);
00190                 return m->sem == 0 ? -1 : 0;
00191     }
00192 
00193     static inline int rtos_sem_destroy(rt_sem_t* m )
00194     {
00195         CHK_LXRT_CALL();
00196         return rt_sem_delete( m->sem );
00197     }
00198 
00199     static inline int rtos_sem_signal(rt_sem_t* m )
00200     {
00201         CHK_LXRT_CALL();
00202         return rt_sem_signal( m->sem );
00203     }
00204 
00205     static inline int rtos_sem_wait(rt_sem_t* m )
00206     {
00207         CHK_LXRT_CALL();
00208         return rt_sem_wait( m->sem );
00209     }
00210 
00211     static inline int rtos_sem_trywait(rt_sem_t* m )
00212     {
00213         CHK_LXRT_CALL();
00214         return rt_sem_wait_if(m->sem);
00215     }
00216 
00217     static inline int rtos_sem_value(rt_sem_t* m )
00218     {
00219         CHK_LXRT_CALL();
00220         return rt_sem_count(m->sem);
00221     }
00222 
00223     static inline int rtos_sem_wait_timed(rt_sem_t* m, NANO_TIME delay )
00224     {
00225         int ret;
00226         CHK_LXRT_CALL();
00227         ret = rt_sem_wait_timed(m->sem, nano2count(delay) ) ;
00228 #if defined(CONFIG_RTAI_VERSION_MINOR) && defined(CONFIG_RTAI_VERSION_MAJOR)
00229 #  if CONFIG_RTAI_VERSION_MAJOR == 3 && CONFIG_RTAI_VERSION_MINOR > 3
00230         return (ret == RTE_TIMOUT) ? -1 : 0;
00231 #  else
00232         return (ret == SEM_TIMOUT) ? -1 : 0;
00233 #  endif
00234 #else
00235         return (ret == SEM_TIMOUT) ? -1 : 0;
00236 #endif
00237     }
00238 
00239     static inline int rtos_sem_wait_until(rt_sem_t* m, NANO_TIME when )
00240     {
00241         int ret;
00242         CHK_LXRT_CALL();
00243         ret = rt_sem_wait_until(m->sem, nano2count(when) ) ;
00244 #if defined(CONFIG_RTAI_VERSION_MINOR) && defined(CONFIG_RTAI_VERSION_MAJOR)
00245 #  if CONFIG_RTAI_VERSION_MAJOR == 3 && CONFIG_RTAI_VERSION_MINOR > 3
00246         return (ret == RTE_TIMOUT) ? -1 : 0;
00247 #  else
00248         return (ret == SEM_TIMOUT) ? -1 : 0;
00249 #  endif
00250 #else
00251         return (ret == SEM_TIMOUT) ? -1 : 0;
00252 #endif
00253     }
00254 
00255     static inline int rtos_mutex_init(rt_mutex_t* m)
00256     {
00257         CHK_LXRT_CALL();
00258         m->sem = rt_typed_sem_init( rt_get_name(0),1, BIN_SEM | PRIO_Q);
00259         return m->sem == 0 ? -1 : 0;
00260     }
00261 
00262     static inline int rtos_mutex_destroy(rt_mutex_t* m )
00263     {
00264         CHK_LXRT_CALL();
00265         return rt_sem_delete(m->sem);
00266     }
00267 
00268     static inline int rtos_mutex_rec_init(rt_rec_mutex_t* m)
00269     {
00270         CHK_LXRT_CALL();
00271         // RES_SEM is PRIO_Q anyhow.
00272         m->sem = rt_typed_sem_init( rt_get_name(0), 1, RES_SEM);
00273         return m->sem == 0 ? -1 : 0;
00274     }
00275 
00276     static inline int rtos_mutex_rec_destroy(rt_rec_mutex_t* m )
00277     {
00278         CHK_LXRT_CALL();
00279         return rt_sem_delete(m->sem);
00280     }
00281 
00282     static inline int rtos_mutex_lock( rt_mutex_t* m)
00283     {
00284         CHK_LXRT_CALL();
00285         return rt_sem_wait(m->sem);
00286     }
00287 
00288     static inline int rtos_mutex_rec_lock( rt_rec_mutex_t* m)
00289     {
00290         CHK_LXRT_CALL();
00291         return rt_sem_wait(m->sem);
00292     }
00293 
00294     static inline int rtos_mutex_trylock( rt_mutex_t* m)
00295     {
00296         CHK_LXRT_CALL();
00297         return rt_sem_wait_if(m->sem) > 0 ? 0 : -EAGAIN;
00298     }
00299 
00300     static inline int rtos_mutex_rec_trylock( rt_rec_mutex_t* m)
00301     {
00302         CHK_LXRT_CALL();
00303         return rt_sem_wait_if(m->sem) > 0 ? 0 : -EAGAIN;
00304     }
00305 
00306     static inline int rtos_mutex_lock_until( rt_mutex_t* m, NANO_TIME abs_time)
00307     {
00308         CHK_LXRT_CALL();
00309         return rt_sem_wait_until(m->sem, nano2count(abs_time)) < SEM_TIMOUT ? 0 : -EAGAIN;
00310     }
00311 
00312     static inline int rtos_mutex_rec_lock_until( rt_rec_mutex_t* m, NANO_TIME abs_time)
00313     {
00314         CHK_LXRT_CALL();
00315         return rt_sem_wait_until(m->sem, nano2count(abs_time)) < SEM_TIMOUT ? 0 : -EAGAIN;
00316     }
00317 
00318 
00319     static inline int rtos_mutex_unlock( rt_mutex_t* m)
00320     {
00321         CHK_LXRT_CALL();
00322         return rt_sem_signal(m->sem);
00323     }
00324 
00325     static inline int rtos_mutex_rec_unlock( rt_rec_mutex_t* m)
00326     {
00327         CHK_LXRT_CALL();
00328         return rt_sem_signal(m->sem);
00329     }
00330 
00331     static inline int rtos_cond_init(rt_cond_t *cond)
00332     {
00333         CHK_LXRT_CALL();
00334         cond->cond = rt_cond_init(0);
00335         return cond->cond == 0 ? -1 : 0;
00336     }
00337 
00338     static inline int rtos_cond_destroy(rt_cond_t *cond)
00339     {
00340         CHK_LXRT_CALL();
00341         return rt_cond_delete(cond->cond);
00342     }
00343 
00344     static inline int rtos_cond_wait(rt_cond_t *cond, rt_mutex_t *mutex)
00345     {
00346         CHK_LXRT_CALL();
00347         int ret = rt_cond_wait(cond->cond, mutex->sem );
00348         if (ret == 0)
00349             return 0;
00350         return -1;
00351     }
00352 
00353     static inline int rtos_cond_timedwait(rt_cond_t *cond, rt_mutex_t *mutex, NANO_TIME abstime)
00354     {
00355         CHK_LXRT_CALL();
00356         int ret = rt_cond_wait_until(cond->cond, mutex->sem, nano2count(abs_time) );
00357         if (ret == 0)
00358             return 0;
00359         if ( ret == SEM_TIMOUT )
00360             return ETIMEOUT;
00361         return -1;
00362     }
00363 
00364     static inline int rtos_cond_broadcast(rt_cond_t *cond)
00365     {
00366         CHK_LXRT_CALL();
00367         return rt_cond_broadcast(cond->cond);
00368     }
00369 inline
00370 int rtos_printf(const char *fmt, ...)
00371 {
00372     va_list list;
00373     char printkbuf [2000];
00374     printkbuf[0] = '\0';
00375     va_start (list, fmt);
00376     vsprintf(printkbuf, fmt, list);
00377     va_end (list);
00378     // XXX revert to print to screen when debugging is over
00379     return rtai_print_to_screen(printkbuf);
00380     //return printf(printkbuf);
00381 }
00382 
00383 #else  // OSBLD_OS_AGNOSTIC
00384 
00389 TIME_SPEC ticks2timespec(TICK_TIME hrt);
00390 
00391 NANO_TIME rtos_get_time_ns(void);
00392 
00393 TICK_TIME rtos_get_time_ticks(void);
00394 
00395 TICK_TIME ticksPerSec(void);
00396 
00397 TICK_TIME nano2ticks(NANO_TIME t);
00398 
00399 NANO_TIME ticks2nano(TICK_TIME t);
00400 
00401 int rtos_nanosleep(const TIME_SPEC *rqtp, TIME_SPEC *rmtp) ;
00402 
00403 int rtos_mutex_init(rt_mutex_t* m);
00404 
00405 int rtos_mutex_destroy(rt_mutex_t* m );
00406 
00407 int rtos_mutex_rec_init(rt_mutex_t* m);
00408 
00409 int rtos_mutex_rec_destroy(rt_mutex_t* m );
00410 
00411 int rtos_mutex_lock( rt_mutex_t* m);
00412 
00413 int rtos_mutex_trylock( rt_mutex_t* m);
00414 
00415 int rtos_mutex_lock_until( rt_mutex_t* m, NANO_TIME abs_time);
00416 
00417 int rtos_mutex_rec_lock_until( rt_mutex_t* m, NANO_TIME abs_time);
00418 
00419 int rtos_mutex_unlock( rt_mutex_t* m);
00420 
00421 int rtos_mutex_rec_lock( rt_rec_mutex_t* m);
00422 
00423 int rtos_mutex_rec_trylock( rt_rec_mutex_t* m);
00424 
00425 int rtos_mutex_rec_unlock( rt_rec_mutex_t* m);
00426 
00427 int rtos_printf(const char *fmt, ...);
00428 
00429 int rtos_sem_init(rt_sem_t* m, int value );
00430 int rtos_sem_destroy(rt_sem_t* m );
00431 int rtos_sem_signal(rt_sem_t* m );
00432 int rtos_sem_wait(rt_sem_t* m );
00433 int rtos_sem_trywait(rt_sem_t* m );
00434 int rtos_sem_value(rt_sem_t* m );
00435 int rtos_sem_wait_timed(rt_sem_t* m, NANO_TIME delay );
00436 int rtos_sem_wait_until(rt_sem_t* m, NANO_TIME when );
00437 
00438 int rtos_cond_init(rt_cond_t *cond);
00439 int rtos_cond_destroy(rt_cond_t *cond);
00440 int rtos_cond_wait(rt_cond_t *cond, rt_mutex_t *mutex);
00441 int rtos_cond_timedwait(rt_cond_t *cond, rt_mutex_t *mutex, NANO_TIME abs_time);
00442 int rtos_cond_broadcast(rt_cond_t *cond);
00443 
00444 #endif // OSBLD_OS_AGNOSTIC
00445 
00446 static inline void rtos_enable_rt_warning()
00447 {
00448 }
00449 
00450 static inline void rtos_disable_rt_warning()
00451 {
00452 }
00453 
00454 #ifdef __cplusplus
00455 }
00456 #endif
00457 
00458 #endif


rtt
Author(s): RTT Developers
autogenerated on Thu Jan 2 2014 11:35:21