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

    struct timespec tmp;

    24

    clock_gettime(CLOCK_REALTIME, &tmp);

    25

    CURRENT_TIME->tv_sec = tmp.tv_sec;

    26

    CURRENT_TIME->tv_nsec = tmp.tv_nsec;

    27

}

    28

    29

void PLC_timer_notify(sigval_t val)

    30

{

    31

    PLC_GetTime(&__CURRENT_TIME);

    32

    __run();

    33

}

    34

    35

timer_t PLC_timer;

    36

    37

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

    38

{

    39

    struct itimerspec timerValues;

    40

	/*

    41

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

    42

	*/

    43

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

    44

	{

    45

#ifdef __lldiv_t_defined

    46

		lldiv_t nxt_div = lldiv(next, 1000000000);

    47

		lldiv_t period_div = lldiv(period, 1000000000);

    48

	    timerValues.it_value.tv_sec = nxt_div.quot;

    49

	    timerValues.it_value.tv_nsec = nxt_div.rem;

    50

	    timerValues.it_interval.tv_sec = period_div.quot;

    51

	    timerValues.it_interval.tv_nsec = period_div.rem;

    52

#else

    53

	    timerValues.it_value.tv_sec = next / 1000000000;

    54

	    timerValues.it_value.tv_nsec = next % 1000000000;

    55

	    timerValues.it_interval.tv_sec = period / 1000000000;

    56

	    timerValues.it_interval.tv_nsec = period % 1000000000;

    57

#endif

    58

	}

    59

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

    60

}

    61

//

    62

void catch_signal(int sig)

    63

{

    64

//  signal(SIGTERM, catch_signal);

    65

  signal(SIGINT, catch_signal);

    66

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

    67

  exit(0);

    68

}

    69

    70

    71

static unsigned long __debug_tick;

    72

    73

static pthread_mutex_t python_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    74

static pthread_mutex_t python_mutex = PTHREAD_MUTEX_INITIALIZER;

    75

static pthread_mutex_t debug_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    76

static pthread_mutex_t debug_mutex = PTHREAD_MUTEX_INITIALIZER;

    77

    78

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

    79

int startPLC(int argc,char **argv)

    80

{

    81

    struct sigevent sigev;

    82

    setlocale(LC_NUMERIC, "C");

    83

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

    84

    Ttick = common_ticktime__?common_ticktime__:1000000;

    85

    86

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

    87

    sigev.sigev_value.sival_int = 0;

    88

    sigev.sigev_notify = SIGEV_THREAD;

    89

    sigev.sigev_notify_attributes = NULL;

    90

    sigev.sigev_notify_function = PLC_timer_notify;

    91

    92

    pthread_mutex_init(&debug_wait_mutex, NULL);

    93

    pthread_mutex_init(&debug_mutex, NULL);

    94

    pthread_mutex_init(&python_wait_mutex, NULL);

    95

    pthread_mutex_init(&python_mutex, NULL);

    96

    97

    pthread_mutex_lock(&debug_wait_mutex);

    98

    pthread_mutex_lock(&python_wait_mutex);

    99

   100

    timer_create (CLOCK_REALTIME, &sigev, &PLC_timer);

   101

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

   102

        PLC_SetTimer(Ttick,Ttick);

   103

   104

        /* install signal handler for manual break */

   105

        signal(SIGINT, catch_signal);

   106

    }else{

   107

        return 1;

   108

    }

   109

    return 0;

   110

}

   111

   112

int TryEnterDebugSection(void)

   113

{

   114

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

   115

        /* Only enter if debug active */

   116

        if(__DEBUG){

   117

            return 1;

   118

        }

   119

        pthread_mutex_unlock(&debug_mutex);

   120

    }

   121

    return 0;

   122

}

   123

   124

void LeaveDebugSection(void)

   125

{

   126

    pthread_mutex_unlock(&debug_mutex);

   127

}

   128

   129

int stopPLC()

   130

{

   131

    /* Stop the PLC */

   132

    PLC_SetTimer(0,0);

   133

    timer_delete (PLC_timer);

   134

    __cleanup();

   135

    pthread_mutex_destroy(&debug_wait_mutex);

   136

    pthread_mutex_destroy(&debug_mutex);

   137

    pthread_mutex_destroy(&python_wait_mutex);

   138

    pthread_mutex_destroy(&python_mutex);

   139

    return 0;

   140

}

   141

   142

extern unsigned long __tick;

   143

   144

int WaitDebugData(unsigned long *tick)

   145

{

   146

    *tick = __debug_tick;

   147

    /* Wait signal from PLC thread */

   148

    return pthread_mutex_lock(&debug_wait_mutex);

   149

}

   150

   151

/* Called by PLC thread when debug_publish finished

   152

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

   153

void InitiateDebugTransfer()

   154

{

   155

    /* remember tick */

   156

    __debug_tick = __tick;

   157

    /* signal debugger thread it can read data */

   158

    pthread_mutex_unlock(&debug_wait_mutex);

   159

}

   160

   161

void suspendDebug(int disable)

   162

{

   163

    /* Prevent PLC to enter debug code */

   164

    pthread_mutex_lock(&debug_mutex);

   165

    /*__DEBUG is protected by this mutex */

   166

    __DEBUG = !disable;

   167

    if (disable)

   168

    	pthread_mutex_unlock(&debug_mutex);

   169

}

   170

   171

void resumeDebug(void)

   172

{

   173

    __DEBUG = 1;

   174

    /* Let PLC enter debug code */

   175

    pthread_mutex_unlock(&debug_mutex);

   176

}

   177

   178

/* from plc_python.c */

   179

int WaitPythonCommands(void)

   180

{

   181

    /* Wait signal from PLC thread */

   182

    return pthread_mutex_lock(&python_wait_mutex);

   183

}

   184

   185

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

   186

void UnBlockPythonCommands(void)

   187

{

   188

    /* signal debugger thread it can read data */

   189

    pthread_mutex_unlock(&python_wait_mutex);

   190

}

   191

   192

int TryLockPython(void)

   193

{

   194

    return pthread_mutex_trylock(&python_mutex) == 0;

   195

}

   196

   197

void UnLockPython(void)

   198

{

   199

    pthread_mutex_unlock(&python_mutex);

   200

}

   201

   202

void LockPython(void)

   203

{

   204

    pthread_mutex_lock(&python_mutex);

   205

}

   206

   207

int CheckRetainBuffer(void)

   208

{

   209

	return 1;

   210

}

   211

   212

void ValidateRetainBuffer(void)

   213

{

   214

}

   215

   216

void InValidateRetainBuffer(void)

   217

{

   218

}

   219

   220

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

   221

{

   222

}

   223

   224

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

   225

{

   226

}