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

extern unsigned long long 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

    struct timespec tmp;

    23

    clock_gettime(CLOCK_REALTIME, &tmp);

    24

    CURRENT_TIME->tv_sec = tmp.tv_sec;

    25

    CURRENT_TIME->tv_nsec = tmp.tv_nsec;

    26

}

    27

    28

void PLC_timer_notify(sigval_t val)

    29

{

    30

    PLC_GetTime(&__CURRENT_TIME);

    31

    __run();

    32

}

    33

    34

timer_t PLC_timer;

    35

    36

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

    37

{

    38

    struct itimerspec timerValues;

    39

	/*

    40

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

    41

	*/

    42

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

    43

	{

    44

#ifdef __lldiv_t_defined

    45

		lldiv_t nxt_div = lldiv(next, 1000000000);

    46

		lldiv_t period_div = lldiv(period, 1000000000);

    47

	    timerValues.it_value.tv_sec = nxt_div.quot;

    48

	    timerValues.it_value.tv_nsec = nxt_div.rem;

    49

	    timerValues.it_interval.tv_sec = period_div.quot;

    50

	    timerValues.it_interval.tv_nsec = period_div.rem;

    51

#else

    52

	    timerValues.it_value.tv_sec = next / 1000000000;

    53

	    timerValues.it_value.tv_nsec = next % 1000000000;

    54

	    timerValues.it_interval.tv_sec = period / 1000000000;

    55

	    timerValues.it_interval.tv_nsec = period % 1000000000;

    56

#endif

    57

	}

    58

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

    59

}

    60

//

    61

void catch_signal(int sig)

    62

{

    63

//  signal(SIGTERM, catch_signal);

    64

  signal(SIGINT, catch_signal);

    65

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

    66

  exit(0);

    67

}

    68

    69

    70

static unsigned long __debug_tick;

    71

    72

static pthread_mutex_t python_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    73

static pthread_mutex_t python_mutex = PTHREAD_MUTEX_INITIALIZER;

    74

static pthread_mutex_t debug_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    75

static pthread_mutex_t debug_mutex = PTHREAD_MUTEX_INITIALIZER;

    76

    77

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

    78

int startPLC(int argc,char **argv)

    79

{

    80

    struct sigevent sigev;

    81

    setlocale(LC_NUMERIC, "C");

    82

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

    83

    Ttick = common_ticktime__?common_ticktime__:1000000;

    84

    85

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

    86

    sigev.sigev_value.sival_int = 0;

    87

    sigev.sigev_notify = SIGEV_THREAD;

    88

    sigev.sigev_notify_attributes = NULL;

    89

    sigev.sigev_notify_function = PLC_timer_notify;

    90

    91

    pthread_mutex_init(&debug_wait_mutex, NULL);

    92

    pthread_mutex_init(&debug_mutex, NULL);

    93

    pthread_mutex_init(&python_wait_mutex, NULL);

    94

    pthread_mutex_init(&python_mutex, NULL);

    95

    96

    pthread_mutex_lock(&debug_wait_mutex);

    97

    pthread_mutex_lock(&python_wait_mutex);

    98

    99

    timer_create (CLOCK_REALTIME, &sigev, &PLC_timer);

   100

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

   101

        PLC_SetTimer(Ttick,Ttick);

   102

   103

        /* install signal handler for manual break */

   104

        signal(SIGINT, catch_signal);

   105

    }else{

   106

        return 1;

   107

    }

   108

    return 0;

   109

}

   110

   111

int TryEnterDebugSection(void)

   112

{

   113

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

   114

        /* Only enter if debug active */

   115

        if(__DEBUG){

   116

            return 1;

   117

        }

   118

        pthread_mutex_unlock(&debug_mutex);

   119

    }

   120

    return 0;

   121

}

   122

   123

void LeaveDebugSection(void)

   124

{

   125

    pthread_mutex_unlock(&debug_mutex);

   126

}

   127

   128

int stopPLC()

   129

{

   130

    /* Stop the PLC */

   131

    PLC_SetTimer(0,0);

   132

    timer_delete (PLC_timer);

   133

    __cleanup();

   134

    pthread_mutex_destroy(&debug_wait_mutex);

   135

    pthread_mutex_destroy(&debug_mutex);

   136

    pthread_mutex_destroy(&python_wait_mutex);

   137

    pthread_mutex_destroy(&python_mutex);

   138

    return 0;

   139

}

   140

   141

extern unsigned long __tick;

   142

   143

int WaitDebugData(unsigned long *tick)

   144

{

   145

    int res;

   146

    /* Wait signal from PLC thread */

   147

    res = pthread_mutex_lock(&debug_wait_mutex);

   148

    *tick = __debug_tick;

   149

    return res;

   150

}

   151

   152

/* Called by PLC thread when debug_publish finished

   153

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

   154

void InitiateDebugTransfer()

   155

{

   156

    /* remember tick */

   157

    __debug_tick = __tick;

   158

    /* signal debugger thread it can read data */

   159

    pthread_mutex_unlock(&debug_wait_mutex);

   160

}

   161

   162

int suspendDebug(int disable)

   163

{

   164

    /* Prevent PLC to enter debug code */

   165

    pthread_mutex_lock(&debug_mutex);

   166

    /*__DEBUG is protected by this mutex */

   167

    __DEBUG = !disable;

   168

    if (disable)

   169

    	pthread_mutex_unlock(&debug_mutex);

   170

    return 0;

   171

}

   172

   173

void resumeDebug(void)

   174

{

   175

    __DEBUG = 1;

   176

    /* Let PLC enter debug code */

   177

    pthread_mutex_unlock(&debug_mutex);

   178

}

   179

   180

/* from plc_python.c */

   181

int WaitPythonCommands(void)

   182

{

   183

    /* Wait signal from PLC thread */

   184

    return pthread_mutex_lock(&python_wait_mutex);

   185

}

   186

   187

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

   188

void UnBlockPythonCommands(void)

   189

{

   190

    /* signal debugger thread it can read data */

   191

    pthread_mutex_unlock(&python_wait_mutex);

   192

}

   193

   194

int TryLockPython(void)

   195

{

   196

    return pthread_mutex_trylock(&python_mutex) == 0;

   197

}

   198

   199

void UnLockPython(void)

   200

{

   201

    pthread_mutex_unlock(&python_mutex);

   202

}

   203

   204

void LockPython(void)

   205

{

   206

    pthread_mutex_lock(&python_mutex);

   207

}

   208

   209

int CheckRetainBuffer(void)

   210

{

   211

	return 1;

   212

}

   213

   214

void ValidateRetainBuffer(void)

   215

{

   216

}

   217

   218

void InValidateRetainBuffer(void)

   219

{

   220

}

   221

   222

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

   223

{

   224

}

   225

   226

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

   227

{

   228

}