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

#include <semaphore.h>

    13

    14

static sem_t Run_PLC;

    15

    16

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

    17

{

    18

    return __sync_val_compare_and_swap(atomicvar, compared, exchange);

    19

}

    20

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

    21

{

    22

    return __sync_val_compare_and_swap(atomicvar, compared, exchange);

    23

}

    24

    25

void PLC_GetTime(IEC_TIME *CURRENT_TIME)

    26

{

    27

    struct timespec tmp;

    28

    clock_gettime(CLOCK_REALTIME, &tmp);

    29

    CURRENT_TIME->tv_sec = tmp.tv_sec;

    30

    CURRENT_TIME->tv_nsec = tmp.tv_nsec;

    31

}

    32

    33

void PLC_timer_notify(sigval_t val)

    34

{

    35

    PLC_GetTime(&__CURRENT_TIME);

    36

    sem_post(&Run_PLC);

    37

}

    38

    39

timer_t PLC_timer;

    40

    41

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

    42

{

    43

    struct itimerspec timerValues;

    44

	/*

    45

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

    46

	*/

    47

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

    48

	{

    49

#ifdef __lldiv_t_defined

    50

		lldiv_t nxt_div = lldiv(next, 1000000000);

    51

		lldiv_t period_div = lldiv(period, 1000000000);

    52

	    timerValues.it_value.tv_sec = nxt_div.quot;

    53

	    timerValues.it_value.tv_nsec = nxt_div.rem;

    54

	    timerValues.it_interval.tv_sec = period_div.quot;

    55

	    timerValues.it_interval.tv_nsec = period_div.rem;

    56

#else

    57

	    timerValues.it_value.tv_sec = next / 1000000000;

    58

	    timerValues.it_value.tv_nsec = next % 1000000000;

    59

	    timerValues.it_interval.tv_sec = period / 1000000000;

    60

	    timerValues.it_interval.tv_nsec = period % 1000000000;

    61

#endif

    62

	}

    63

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

    64

}

    65

//

    66

void catch_signal(int sig)

    67

{

    68

//  signal(SIGTERM, catch_signal);

    69

  signal(SIGINT, catch_signal);

    70

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

    71

  exit(0);

    72

}

    73

    74

    75

static unsigned long __debug_tick;

    76

    77

pthread_t PLC_thread;

    78

static pthread_mutex_t python_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    79

static pthread_mutex_t python_mutex = PTHREAD_MUTEX_INITIALIZER;

    80

static pthread_mutex_t debug_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    81

static pthread_mutex_t debug_mutex = PTHREAD_MUTEX_INITIALIZER;

    82

    83

int PLC_shutdown = 0;

    84

    85

void PLC_thread_proc(void *arg)

    86

{

    87

    while (!PLC_shutdown) {

    88

        sem_wait(&Run_PLC);

    89

        __run();

    90

    }

    91

    pthread_exit(0);

    92

}

    93

    94

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

    95

int startPLC(int argc,char **argv)

    96

{

    97

    struct sigevent sigev;

    98

    setlocale(LC_NUMERIC, "C");

    99

   100

    PLC_shutdown = 0;

   101

   102

    sem_init(&Run_PLC, 0, 0);

   103

   104

    pthread_create(&PLC_thread, NULL, (void*) &PLC_thread_proc, NULL);

   105

   106

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

   107

    sigev.sigev_value.sival_int = 0;

   108

    sigev.sigev_notify = SIGEV_THREAD;

   109

    sigev.sigev_notify_attributes = NULL;

   110

    sigev.sigev_notify_function = PLC_timer_notify;

   111

   112

    pthread_mutex_init(&debug_wait_mutex, NULL);

   113

    pthread_mutex_init(&debug_mutex, NULL);

   114

    pthread_mutex_init(&python_wait_mutex, NULL);

   115

    pthread_mutex_init(&python_mutex, NULL);

   116

   117

    pthread_mutex_lock(&debug_wait_mutex);

   118

    pthread_mutex_lock(&python_wait_mutex);

   119

   120

    timer_create (CLOCK_REALTIME, &sigev, &PLC_timer);

   121

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

   122

        PLC_SetTimer(common_ticktime__,common_ticktime__);

   123

   124

        /* install signal handler for manual break */

   125

        signal(SIGINT, catch_signal);

   126

    }else{

   127

        return 1;

   128

    }

   129

    return 0;

   130

}

   131

   132

int TryEnterDebugSection(void)

   133

{

   134

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

   135

        /* Only enter if debug active */

   136

        if(__DEBUG){

   137

            return 1;

   138

        }

   139

        pthread_mutex_unlock(&debug_mutex);

   140

    }

   141

    return 0;

   142

}

   143

   144

void LeaveDebugSection(void)

   145

{

   146

    pthread_mutex_unlock(&debug_mutex);

   147

}

   148

   149

int stopPLC()

   150

{

   151

    /* Stop the PLC */

   152

    PLC_shutdown = 1;

   153

    sem_post(&Run_PLC);

   154

    PLC_SetTimer(0,0);

   155

	pthread_join(PLC_thread, NULL);

   156

	sem_destroy(&Run_PLC);

   157

    timer_delete (PLC_timer);

   158

    __cleanup();

   159

    pthread_mutex_destroy(&debug_wait_mutex);

   160

    pthread_mutex_destroy(&debug_mutex);

   161

    pthread_mutex_destroy(&python_wait_mutex);

   162

    pthread_mutex_destroy(&python_mutex);

   163

    return 0;

   164

}

   165

   166

extern unsigned long __tick;

   167

   168

int WaitDebugData(unsigned long *tick)

   169

{

   170

    int res;

   171

    if (PLC_shutdown) return 1;

   172

    /* Wait signal from PLC thread */

   173

    res = pthread_mutex_lock(&debug_wait_mutex);

   174

    *tick = __debug_tick;

   175

    return res;

   176

}

   177

   178

/* Called by PLC thread when debug_publish finished

   179

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

   180

void InitiateDebugTransfer()

   181

{

   182

    /* remember tick */

   183

    __debug_tick = __tick;

   184

    /* signal debugger thread it can read data */

   185

    pthread_mutex_unlock(&debug_wait_mutex);

   186

}

   187

   188

int suspendDebug(int disable)

   189

{

   190

    /* Prevent PLC to enter debug code */

   191

    pthread_mutex_lock(&debug_mutex);

   192

    /*__DEBUG is protected by this mutex */

   193

    __DEBUG = !disable;

   194

    if (disable)

   195

    	pthread_mutex_unlock(&debug_mutex);

   196

    return 0;

   197

}

   198

   199

void resumeDebug(void)

   200

{

   201

    __DEBUG = 1;

   202

    /* Let PLC enter debug code */

   203

    pthread_mutex_unlock(&debug_mutex);

   204

}

   205

   206

/* from plc_python.c */

   207

int WaitPythonCommands(void)

   208

{

   209

    /* Wait signal from PLC thread */

   210

    return pthread_mutex_lock(&python_wait_mutex);

   211

}

   212

   213

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

   214

void UnBlockPythonCommands(void)

   215

{

   216

    /* signal debugger thread it can read data */

   217

    pthread_mutex_unlock(&python_wait_mutex);

   218

}

   219

   220

int TryLockPython(void)

   221

{

   222

    return pthread_mutex_trylock(&python_mutex) == 0;

   223

}

   224

   225

void UnLockPython(void)

   226

{

   227

    pthread_mutex_unlock(&python_mutex);

   228

}

   229

   230

void LockPython(void)

   231

{

   232

    pthread_mutex_lock(&python_mutex);

   233

}

   234

   235

#ifndef HAVE_RETAIN

   236

void InitRetain(void)

   237

{

   238

}

   239

   240

void CleanupRetain(void)

   241

{

   242

}

   243

   244

int CheckRetainBuffer(void)

   245

{

   246

	return 1;

   247

}

   248

   249

void ValidateRetainBuffer(void)

   250

{

   251

}

   252

   253

void InValidateRetainBuffer(void)

   254

{

   255

}

   256

   257

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

   258

{

   259

}

   260

   261

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

   262

{

   263

}

   264

#endif // !HAVE_RETAIN