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

#include <locale.h>

    12

    13

/* provided by POUS.C */

    14

extern unsigned long long common_ticktime__;

    15

    16

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

    17

{

    18

    return __sync_val_compare_and_swap(atomicvar, compared, exchange);

    19

}

    20

    21

void PLC_GetTime(IEC_TIME *CURRENT_TIME)

    22

{

    23

    clock_gettime(CLOCK_REALTIME, CURRENT_TIME);

    24

}

    25

    26

void PLC_timer_notify(sigval_t val)

    27

{

    28

    PLC_GetTime(&__CURRENT_TIME);

    29

    __run();

    30

}

    31

    32

timer_t PLC_timer;

    33

    34

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

    35

{

    36

    struct itimerspec timerValues;

    37

	/*

    38

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

    39

	*/

    40

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

    41

	{

    42

#ifdef __lldiv_t_defined

    43

		lldiv_t nxt_div = lldiv(next, 1000000000);

    44

		lldiv_t period_div = lldiv(period, 1000000000);

    45

	    timerValues.it_value.tv_sec = nxt_div.quot;

    46

	    timerValues.it_value.tv_nsec = nxt_div.rem;

    47

	    timerValues.it_interval.tv_sec = period_div.quot;

    48

	    timerValues.it_interval.tv_nsec = period_div.rem;

    49

#else

    50

	    timerValues.it_value.tv_sec = next / 1000000000;

    51

	    timerValues.it_value.tv_nsec = next % 1000000000;

    52

	    timerValues.it_interval.tv_sec = period / 1000000000;

    53

	    timerValues.it_interval.tv_nsec = period % 1000000000;

    54

#endif

    55

	}

    56

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

    57

}

    58

//

    59

void catch_signal(int sig)

    60

{

    61

//  signal(SIGTERM, catch_signal);

    62

  signal(SIGINT, catch_signal);

    63

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

    64

  exit(0);

    65

}

    66

    67

    68

static unsigned long __debug_tick;

    69

    70

static pthread_mutex_t python_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    71

static pthread_mutex_t python_mutex = PTHREAD_MUTEX_INITIALIZER;

    72

static pthread_mutex_t debug_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    73

static pthread_mutex_t debug_mutex = PTHREAD_MUTEX_INITIALIZER;

    74

    75

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

    76

int startPLC(int argc,char **argv)

    77

{

    78

    struct sigevent sigev;

    79

    setlocale(LC_NUMERIC, "C");

    80

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

    81

    Ttick = common_ticktime__?common_ticktime__:1000000;

    82

    83

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

    84

    sigev.sigev_value.sival_int = 0;

    85

    sigev.sigev_notify = SIGEV_THREAD;

    86

    sigev.sigev_notify_attributes = NULL;

    87

    sigev.sigev_notify_function = PLC_timer_notify;

    88

    89

    pthread_mutex_init(&debug_wait_mutex, NULL);

    90

    pthread_mutex_init(&debug_mutex, NULL);

    91

    pthread_mutex_init(&python_wait_mutex, NULL);

    92

    pthread_mutex_init(&python_mutex, NULL);

    93

    94

    pthread_mutex_lock(&debug_wait_mutex);

    95

    pthread_mutex_lock(&python_wait_mutex);

    96

    97

    timer_create (CLOCK_REALTIME, &sigev, &PLC_timer);

    98

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

    99

        PLC_SetTimer(Ttick,Ttick);

   100

   101

        /* install signal handler for manual break */

   102

        signal(SIGINT, catch_signal);

   103

    }else{

   104

        return 1;

   105

    }

   106

    return 0;

   107

}

   108

   109

int TryEnterDebugSection(void)

   110

{

   111

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

   112

        /* Only enter if debug active */

   113

        if(__DEBUG){

   114

            return 1;

   115

        }

   116

        pthread_mutex_unlock(&debug_mutex);

   117

    }

   118

    return 0;

   119

}

   120

   121

void LeaveDebugSection(void)

   122

{

   123

    pthread_mutex_unlock(&debug_mutex);

   124

}

   125

   126

int stopPLC()

   127

{

   128

    /* Stop the PLC */

   129

    PLC_SetTimer(0,0);

   130

    timer_delete (PLC_timer);

   131

    __cleanup();

   132

    pthread_mutex_destroy(&debug_wait_mutex);

   133

    pthread_mutex_destroy(&debug_mutex);

   134

    pthread_mutex_destroy(&python_wait_mutex);

   135

    pthread_mutex_destroy(&python_mutex);

   136

    return 0;

   137

}

   138

   139

extern unsigned long __tick;

   140

   141

int WaitDebugData(unsigned long *tick)

   142

{

   143

    *tick = __debug_tick;

   144

    /* Wait signal from PLC thread */

   145

    return pthread_mutex_lock(&debug_wait_mutex);

   146

}

   147

   148

/* Called by PLC thread when debug_publish finished

   149

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

   150

void InitiateDebugTransfer()

   151

{

   152

    /* remember tick */

   153

    __debug_tick = __tick;

   154

    /* signal debugger thread it can read data */

   155

    pthread_mutex_unlock(&debug_wait_mutex);

   156

}

   157

   158

void suspendDebug(int disable)

   159

{

   160

    /* Prevent PLC to enter debug code */

   161

    pthread_mutex_lock(&debug_mutex);

   162

    /*__DEBUG is protected by this mutex */

   163

    __DEBUG = !disable;

   164

    if (disable)

   165

    	pthread_mutex_unlock(&debug_mutex);

   166

}

   167

   168

void resumeDebug(void)

   169

{

   170

    __DEBUG = 1;

   171

    /* Let PLC enter debug code */

   172

    pthread_mutex_unlock(&debug_mutex);

   173

}

   174

   175

/* from plc_python.c */

   176

int WaitPythonCommands(void)

   177

{

   178

    /* Wait signal from PLC thread */

   179

    return pthread_mutex_lock(&python_wait_mutex);

   180

}

   181

   182

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

   183

void UnBlockPythonCommands(void)

   184

{

   185

    /* signal debugger thread it can read data */

   186

    pthread_mutex_unlock(&python_wait_mutex);

   187

}

   188

   189

int TryLockPython(void)

   190

{

   191

    return pthread_mutex_trylock(&python_mutex) == 0;

   192

}

   193

   194

void UnLockPython(void)

   195

{

   196

    pthread_mutex_unlock(&python_mutex);

   197

}

   198

   199

void LockPython(void)

   200

{

   201

    pthread_mutex_lock(&python_mutex);

   202

}

   203

   204

int CheckRetainBuffer(void)

   205

{

   206

	return 1;

   207

}

   208

   209

void Retain(unsigned int offset, unsigned int count, void *p)

   210

{

   211

}

   212

   213

void Remind(unsigned int offset, unsigned int count, void *p)

   214

{

   215

}