1 /**

     2  * Mac OSX specific code

     3  **/

     4 

     5 #include <stdio.h>

     6 #include <string.h>

     7 #include <time.h>

     8 #include <signal.h>

     9 #include <stdlib.h>

    10 #include <pthread.h>

    11 #include <locale.h>

    12 #include <semaphore.h>

    13 #include <dispatch/dispatch.h>

    14 

    15 static sem_t Run_PLC;

    16 

    17 long AtomicCompareExchange(long *atomicvar, long compared, long exchange)

    18 {

    19     return __sync_val_compare_and_swap(atomicvar, compared, exchange);

    20 }

    21 

    22 long long AtomicCompareExchange64(long long *atomicvar, long long compared,

    23                                   long long exchange)

    24 {

    25     return __sync_val_compare_and_swap(atomicvar, compared, exchange);

    26 }

    27 

    28 void PLC_GetTime(IEC_TIME * CURRENT_TIME)

    29 {

    30     struct timespec tmp;

    31     clock_gettime(CLOCK_REALTIME, &tmp);

    32     CURRENT_TIME->tv_sec = tmp.tv_sec;

    33     CURRENT_TIME->tv_nsec = tmp.tv_nsec;

    34 }

    35 

    36 dispatch_queue_t queue;

    37 dispatch_source_t PLC_timer;

    38 

    39 static inline void PLC_timer_cancel(void *arg)

    40 {

    41     dispatch_release(PLC_timer);

    42     dispatch_release(queue);

    43     exit(0);

    44 }

    45 

    46 static inline void PLC_timer_notify(void *arg)

    47 {

    48     PLC_GetTime(&__CURRENT_TIME);

    49     sem_post(&Run_PLC);

    50 }

    51 

    52 void PLC_SetTimer(unsigned long long next, unsigned long long period)

    53 {

    54     if (next == period && next == 0) {

    55         dispatch_suspend(PLC_timer);

    56     } else {

    57         dispatch_time_t start;

    58         start = dispatch_time(DISPATCH_TIME_NOW, next);

    59         dispatch_source_set_timer(PLC_timer, start, period, 0);

    60         dispatch_resume(PLC_timer);

    61     }

    62 }

    63 

    64 void catch_signal(int sig)

    65 {

    66     signal(SIGINT, catch_signal);

    67     printf("Got Signal %d\n", sig);

    68     dispatch_source_cancel(PLC_timer);

    69     exit(0);

    70 }

    71 

    72 static unsigned long __debug_tick;

    73 

    74 pthread_t PLC_thread;

    75 static pthread_mutex_t python_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    76 static pthread_mutex_t python_mutex = PTHREAD_MUTEX_INITIALIZER;

    77 static pthread_mutex_t debug_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    78 static pthread_mutex_t debug_mutex = PTHREAD_MUTEX_INITIALIZER;

    79 

    80 int PLC_shutdown = 0;

    81 

    82 int ForceSaveRetainReq(void)

    83 {

    84     return PLC_shutdown;

    85 }

    86 

    87 void PLC_thread_proc(void *arg)

    88 {

    89     while (!PLC_shutdown) {

    90         sem_wait(&Run_PLC);

    91         __run();

    92     }

    93     pthread_exit(0);

    94 }

    95 

    96 #define maxval(a,b) ((a>b)?a:b)

    97 int startPLC(int argc, char **argv)

    98 {

    99     setlocale(LC_NUMERIC, "C");

   100 

   101     PLC_shutdown = 0;

   102 

   103     sem_init(&Run_PLC, 0, 0);

   104 

   105     pthread_create(&PLC_thread, NULL, (void *)&PLC_thread_proc, NULL);

   106 

   107     pthread_mutex_init(&debug_wait_mutex, NULL);

   108     pthread_mutex_init(&debug_mutex, NULL);

   109     pthread_mutex_init(&python_wait_mutex, NULL);

   110     pthread_mutex_init(&python_mutex, NULL);

   111 

   112     pthread_mutex_lock(&debug_wait_mutex);

   113     pthread_mutex_lock(&python_wait_mutex);

   114 

   115     queue = dispatch_queue_create("timerQueue", 0);

   116     PLC_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);

   117 

   118     dispatch_set_context(PLC_timer, &PLC_timer);

   119     dispatch_source_set_event_handler_f(PLC_timer, PLC_timer_notify);

   120     dispatch_source_set_cancel_handler_f(PLC_timer, PLC_timer_cancel);

   121 

   122     if (__init(argc, argv) == 0) {

   123         PLC_SetTimer(common_ticktime__, common_ticktime__);

   124 

   125         /* install signal handler for manual break */

   126         signal(SIGINT, catch_signal);

   127     } else {

   128         return 1;

   129     }

   130     return 0;

   131 }

   132 

   133 int TryEnterDebugSection(void)

   134 {

   135     if (pthread_mutex_trylock(&debug_mutex) == 0) {

   136         /* Only enter if debug active */

   137         if (__DEBUG) {

   138             return 1;

   139         }

   140         pthread_mutex_unlock(&debug_mutex);

   141     }

   142     return 0;

   143 }

   144 

   145 void LeaveDebugSection(void)

   146 {

   147     pthread_mutex_unlock(&debug_mutex);

   148 }

   149 

   150 int stopPLC()

   151 {

   152     /* Stop the PLC */

   153     PLC_shutdown = 1;

   154     sem_post(&Run_PLC);

   155     PLC_SetTimer(0, 0);

   156     pthread_join(PLC_thread, NULL);

   157     sem_destroy(&Run_PLC);

   158     dispatch_source_cancel(PLC_timer);

   159     __cleanup();

   160     pthread_mutex_destroy(&debug_wait_mutex);

   161     pthread_mutex_destroy(&debug_mutex);

   162     pthread_mutex_destroy(&python_wait_mutex);

   163     pthread_mutex_destroy(&python_mutex);

   164     return 0;

   165 }

   166 

   167 extern unsigned long __tick;

   168 

   169 int WaitDebugData(unsigned long *tick)

   170 {

   171     int res;

   172     if (PLC_shutdown)

   173         return 1;

   174     /* Wait signal from PLC thread */

   175     res = pthread_mutex_lock(&debug_wait_mutex);

   176     *tick = __debug_tick;

   177     return res;

   178 }

   179 

   180 /* Called by PLC thread when debug_publish finished

   181  * This is supposed to unlock debugger thread in WaitDebugData*/

   182 void InitiateDebugTransfer()

   183 {

   184     /* remember tick */

   185     __debug_tick = __tick;

   186     /* signal debugger thread it can read data */

   187     pthread_mutex_unlock(&debug_wait_mutex);

   188 }

   189 

   190 int suspendDebug(int disable)

   191 {

   192     /* Prevent PLC to enter debug code */

   193     pthread_mutex_lock(&debug_mutex);

   194     /*__DEBUG is protected by this mutex */

   195     __DEBUG = !disable;

   196     if (disable)

   197         pthread_mutex_unlock(&debug_mutex);

   198     return 0;

   199 }

   200 

   201 void resumeDebug(void)

   202 {

   203     __DEBUG = 1;

   204     /* Let PLC enter debug code */

   205     pthread_mutex_unlock(&debug_mutex);

   206 }

   207 

   208 /* from plc_python.c */

   209 int WaitPythonCommands(void)

   210 {

   211     /* Wait signal from PLC thread */

   212     return pthread_mutex_lock(&python_wait_mutex);

   213 }

   214 

   215 /* Called by PLC thread on each new python command*/

   216 void UnBlockPythonCommands(void)

   217 {

   218     /* signal python thread it can read data */

   219     pthread_mutex_unlock(&python_wait_mutex);

   220 }

   221 

   222 int TryLockPython(void)

   223 {

   224     return pthread_mutex_trylock(&python_mutex) == 0;

   225 }

   226 

   227 void UnLockPython(void)

   228 {

   229     pthread_mutex_unlock(&python_mutex);

   230 }

   231 

   232 void LockPython(void)

   233 {

   234     pthread_mutex_lock(&python_mutex);

   235 }

   236 

   237 struct RT_to_nRT_signal_s {

   238     pthread_cond_t WakeCond;

   239     pthread_mutex_t WakeCondLock;

   240 };

   241 

   242 typedef struct RT_to_nRT_signal_s RT_to_nRT_signal_t;

   243 

   244 #define _LogAndReturnNull(text) \

   245     {\

   246     	char mstr[256] = text " for ";\

   247         strncat(mstr, name, 255);\

   248         LogMessage(LOG_CRITICAL, mstr, strlen(mstr));\

   249         return NULL;\

   250     }

   251 

   252 void *create_RT_to_nRT_signal(char *name)

   253 {

   254     RT_to_nRT_signal_t *sig =

   255         (RT_to_nRT_signal_t *) malloc(sizeof(RT_to_nRT_signal_t));

   256 

   257     if (!sig)

   258         _LogAndReturnNull("Failed allocating memory for RT_to_nRT signal");

   259 

   260     pthread_cond_init(&sig->WakeCond, NULL);

   261     pthread_mutex_init(&sig->WakeCondLock, NULL);

   262 

   263     return (void *)sig;

   264 }

   265 

   266 void delete_RT_to_nRT_signal(void *handle)

   267 {

   268     RT_to_nRT_signal_t *sig = (RT_to_nRT_signal_t *) handle;

   269 

   270     pthread_cond_destroy(&sig->WakeCond);

   271     pthread_mutex_destroy(&sig->WakeCondLock);

   272 

   273     free(sig);

   274 }

   275 

   276 int wait_RT_to_nRT_signal(void *handle)

   277 {

   278     int ret;

   279     RT_to_nRT_signal_t *sig = (RT_to_nRT_signal_t *) handle;

   280     pthread_mutex_lock(&sig->WakeCondLock);

   281     ret = pthread_cond_wait(&sig->WakeCond, &sig->WakeCondLock);

   282     pthread_mutex_unlock(&sig->WakeCondLock);

   283     return ret;

   284 }

   285 

   286 int unblock_RT_to_nRT_signal(void *handle)

   287 {

   288     RT_to_nRT_signal_t *sig = (RT_to_nRT_signal_t *) handle;

   289     return pthread_cond_signal(&sig->WakeCond);

   290 }

   291 

   292 void nRT_reschedule(void)

   293 {

   294     sched_yield();

   295 }