1

/**

     2

 * Linux 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

    12

/* provided by POUS.C */

    13

extern int common_ticktime__;

    14

    15

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

    16

{

    17

    return __sync_val_compare_and_swap(atomicvar, compared, exchange);

    18

}

    19

    20

void PLC_GetTime(IEC_TIME *CURRENT_TIME)

    21

{

    22

    clock_gettime(CLOCK_REALTIME, CURRENT_TIME);

    23

}

    24

    25

void PLC_timer_notify(sigval_t val)

    26

{

    27

    PLC_GetTime(&__CURRENT_TIME);

    28

    __run();

    29

}

    30

    31

timer_t PLC_timer;

    32

    33

void PLC_SetTimer(long long next, long long period)

    34

{

    35

    struct itimerspec timerValues;

    36

	/*

    37

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

    38

	*/

    39

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

    40

	{

    41

#ifdef __lldiv_t_defined

    42

		lldiv_t nxt_div = lldiv(next, 1000000000);

    43

		lldiv_t period_div = lldiv(period, 1000000000);

    44

	    timerValues.it_value.tv_sec = nxt_div.quot;

    45

	    timerValues.it_value.tv_nsec = nxt_div.rem;

    46

	    timerValues.it_interval.tv_sec = period_div.quot;

    47

	    timerValues.it_interval.tv_nsec = period_div.rem;

    48

#else

    49

	    timerValues.it_value.tv_sec = next / 1000000000;

    50

	    timerValues.it_value.tv_nsec = next % 1000000000;

    51

	    timerValues.it_interval.tv_sec = period / 1000000000;

    52

	    timerValues.it_interval.tv_nsec = period % 1000000000;

    53

#endif

    54

	}

    55

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

    56

}

    57

//

    58

void catch_signal(int sig)

    59

{

    60

//  signal(SIGTERM, catch_signal);

    61

  signal(SIGINT, catch_signal);

    62

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

    63

  exit(0);

    64

}

    65

    66

    67

static unsigned long __debug_tick;

    68

    69

static pthread_mutex_t python_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    70

static pthread_mutex_t python_mutex = PTHREAD_MUTEX_INITIALIZER;

    71

static pthread_mutex_t debug_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    72

static pthread_mutex_t debug_mutex = PTHREAD_MUTEX_INITIALIZER;

    73

    74

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

    75

int startPLC(int argc,char **argv)

    76

{

    77

    struct sigevent sigev;

    78

    /* Define Ttick to 1ms if common_ticktime not defined */

    79

    Ttick = common_ticktime__?common_ticktime__:1000000;

    80

    81

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

    82

    sigev.sigev_value.sival_int = 0;

    83

    sigev.sigev_notify = SIGEV_THREAD;

    84

    sigev.sigev_notify_attributes = NULL;

    85

    sigev.sigev_notify_function = PLC_timer_notify;

    86

    87

    pthread_mutex_init(&debug_wait_mutex, NULL);

    88

    pthread_mutex_init(&python_wait_mutex, NULL);

    89

    90

    pthread_mutex_lock(&debug_wait_mutex);

    91

    pthread_mutex_lock(&python_wait_mutex);

    92

    93

    timer_create (CLOCK_REALTIME, &sigev, &PLC_timer);

    94

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

    95

        PLC_SetTimer(Ttick,Ttick);

    96

    97

        /* install signal handler for manual break */

    98

//        signal(SIGTERM, catch_signal);

    99

        signal(SIGINT, catch_signal);

   100

   101

        pthread_mutex_trylock(&debug_mutex);

   102

    }else{

   103

        return 1;

   104

    }

   105

    return 0;

   106

}

   107

   108

int TryEnterDebugSection(void)

   109

{

   110

    return pthread_mutex_trylock(&debug_mutex) == 0;

   111

}

   112

   113

void LeaveDebugSection(void)

   114

{

   115

    pthread_mutex_unlock(&debug_mutex);

   116

}

   117

   118

int stopPLC()

   119

{

   120

    /* Stop the PLC */

   121

    PLC_SetTimer(0,0);

   122

    timer_delete (PLC_timer);

   123

    __cleanup();

   124

    __debug_tick = -1;

   125

    pthread_mutex_unlock(&debug_mutex);

   126

    pthread_mutex_unlock(&debug_wait_mutex);

   127

    pthread_mutex_destroy(&debug_wait_mutex);

   128

    pthread_mutex_unlock(&python_wait_mutex);

   129

    pthread_mutex_destroy(&python_wait_mutex);

   130

    return 0;

   131

}

   132

   133

extern unsigned long __tick;

   134

/* from plc_debugger.c */

   135

unsigned long WaitDebugData()

   136

{

   137

    /* Wait signal from PLC thread */

   138

    if(pthread_mutex_lock(&debug_wait_mutex)) return -1;

   139

    return __debug_tick;

   140

}

   141

   142

/* Called by PLC thread when debug_publish finished

   143

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

   144

void InitiateDebugTransfer()

   145

{

   146

    /* remember tick */

   147

    __debug_tick = __tick;

   148

    /* signal debugger thread it can read data */

   149

    pthread_mutex_unlock(&debug_wait_mutex);

   150

}

   151

   152

void suspendDebug(void)

   153

{

   154

    __DEBUG = 0;

   155

    /* Prevent PLC to enter debug code */

   156

    pthread_mutex_lock(&debug_mutex);

   157

}

   158

   159

void resumeDebug(void)

   160

{

   161

    __DEBUG = 1;

   162

    /* Let PLC enter debug code */

   163

    pthread_mutex_unlock(&debug_mutex);

   164

}

   165

   166

/* from plc_python.c */

   167

int WaitPythonCommands(void)

   168

{

   169

    /* Wait signal from PLC thread */

   170

    return pthread_mutex_lock(&python_wait_mutex);

   171

}

   172

   173

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

   174

void UnBlockPythonCommands(void)

   175

{

   176

    /* signal debugger thread it can read data */

   177

    pthread_mutex_unlock(&python_wait_mutex);

   178

}

   179

   180

int TryLockPython(void)

   181

{

   182

    return pthread_mutex_trylock(&python_mutex) == 0;

   183

}

   184

   185

void UnLockPython(void)

   186

{

   187

    pthread_mutex_unlock(&python_mutex);

   188

}

   189

   190

void LockPython(void)

   191

{

   192

    pthread_mutex_lock(&python_mutex);

   193

}