1

#include <stdio.h>

     2

#include <string.h>

     3

#include <time.h>

     4

#include <signal.h>

     5

#include <stdlib.h>

     6

#include <pthread.h> 

     7

     8

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

     9

{

    10

    return __sync_val_compare_and_swap(atomicvar, compared, exchange);

    11

}

    12

    13

//long AtomicExchange(long* atomicvar,long exchange)

    14

//{

    15

//    return __sync_lock_test_and_set(atomicvar, exchange);

    16

//}

    17

    18

void PLC_GetTime(IEC_TIME *CURRENT_TIME)

    19

{

    20

    clock_gettime(CLOCK_REALTIME, CURRENT_TIME);

    21

}

    22

    23

void PLC_timer_notify(sigval_t val)

    24

{

    25

    PLC_GetTime(&__CURRENT_TIME);

    26

    __run();

    27

}

    28

    29

timer_t PLC_timer;

    30

    31

void PLC_SetTimer(long long next, long long period)

    32

{

    33

    struct itimerspec timerValues;

    34

	/*

    35

	printf("SetTimer(%lld,%lld)\n",next, period);

    36

	*/

    37

    memset (&timerValues, 0, sizeof (struct itimerspec));

    38

	{

    39

#ifdef __lldiv_t_defined

    40

		lldiv_t nxt_div = lldiv(next, 1000000000);

    41

		lldiv_t period_div = lldiv(period, 1000000000);

    42

	    timerValues.it_value.tv_sec = nxt_div.quot;

    43

	    timerValues.it_value.tv_nsec = nxt_div.rem;

    44

	    timerValues.it_interval.tv_sec = period_div.quot;

    45

	    timerValues.it_interval.tv_nsec = period_div.rem;

    46

#else

    47

	    timerValues.it_value.tv_sec = next / 1000000000;

    48

	    timerValues.it_value.tv_nsec = next % 1000000000;

    49

	    timerValues.it_interval.tv_sec = period / 1000000000;

    50

	    timerValues.it_interval.tv_nsec = period % 1000000000;

    51

#endif

    52

	}	

    53

    timer_settime (PLC_timer, 0, &timerValues, NULL);

    54

}

    55

//

    56

void catch_signal(int sig)

    57

{

    58

//  signal(SIGTERM, catch_signal);

    59

  signal(SIGINT, catch_signal);

    60

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

    61

  exit(0);

    62

}

    63

    64

    65

static int __debug_tick;

    66

    67

static pthread_mutex_t wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    68

static pthread_mutex_t debug_mutex = PTHREAD_MUTEX_INITIALIZER;

    69

    70

int startPLC(int argc,char **argv)

    71

{

    72

    struct sigevent sigev;

    73

    /* Translate PLC's microseconds to Ttick nanoseconds */

    74

    Ttick = 1000000 * maxval(common_ticktime__,1);

    75

    76

    memset (&sigev, 0, sizeof (struct sigevent));

    77

    sigev.sigev_value.sival_int = 0;

    78

    sigev.sigev_notify = SIGEV_THREAD;

    79

    sigev.sigev_notify_attributes = NULL;

    80

    sigev.sigev_notify_function = PLC_timer_notify;

    81

    82

    pthread_mutex_lock(&wait_mutex);

    83

    84

    timer_create (CLOCK_REALTIME, &sigev, &PLC_timer);

    85

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

    86

        PLC_SetTimer(Ttick,Ttick);

    87

    88

        /* install signal handler for manual break */

    89

//        signal(SIGTERM, catch_signal);

    90

        signal(SIGINT, catch_signal);

    91

    }else{

    92

        return 1;

    93

    }

    94

    return 0;

    95

}

    96

    97

int TryEnterDebugSection(void)

    98

{

    99

    return pthread_mutex_trylock(&debug_mutex) == 0;

   100

}

   101

   102

void LeaveDebugSection(void)

   103

{

   104

    pthread_mutex_unlock(&debug_mutex);

   105

}

   106

   107

int stopPLC()

   108

{

   109

    /* Stop the PLC */

   110

    PLC_SetTimer(0,0);

   111

    timer_delete (PLC_timer);

   112

    __cleanup();

   113

    __debug_tick = -1;

   114

    pthread_mutex_unlock(&wait_mutex);

   115

}

   116

   117

extern int __tick;

   118

/* from plc_debugger.c */

   119

int WaitDebugData()

   120

{

   121

    /* Wait signal from PLC thread */

   122

    pthread_mutex_lock(&wait_mutex);

   123

    return __debug_tick;

   124

}

   125

   126

/* Called by PLC thread when debug_publish finished

   127

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

   128

void InitiateDebugTransfer()

   129

{

   130

    /* Leave debugger section */

   131

    pthread_mutex_unlock(&debug_mutex);

   132

    /* remember tick */

   133

    __debug_tick = __tick;

   134

    /* signal debugger thread it can read data */

   135

    pthread_mutex_unlock(&wait_mutex);

   136

}

   137

   138

void suspendDebug()

   139

{

   140

    __DEBUG = 0;

   141

    /* Prevent PLC to enter debug code */

   142

    pthread_mutex_lock(&debug_mutex);

   143

}

   144

   145

void resumeDebug()

   146

{

   147

    __DEBUG = 1;

   148

    /* Let PLC enter debug code */

   149

    pthread_mutex_unlock(&debug_mutex);

   150

}

   151