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

extern unsigned long long common_ticktime__;

    15

static sem_t Run_PLC;

    16

    17

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

    18

{

    19

    return __sync_val_compare_and_swap(atomicvar, compared, exchange);

    20

}

    25

    26

void PLC_GetTime(IEC_TIME *CURRENT_TIME)

    27

{

    28

    struct timespec tmp;

    29

    clock_gettime(CLOCK_REALTIME, &tmp);

    30

    CURRENT_TIME->tv_sec = tmp.tv_sec;

    31

    CURRENT_TIME->tv_nsec = tmp.tv_nsec;

    32

}

    33

    34

void PLC_timer_notify(sigval_t val)

    35

{

    36

    PLC_GetTime(&__CURRENT_TIME);

    37

    sem_post(&Run_PLC);

    38

}

    39

    40

timer_t PLC_timer;

    41

    42

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

    43

{

    44

    struct itimerspec timerValues;

    45

	/*

    46

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

    47

	*/

    48

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

    49

	{

    50

#ifdef __lldiv_t_defined

    51

		lldiv_t nxt_div = lldiv(next, 1000000000);

    52

		lldiv_t period_div = lldiv(period, 1000000000);

    53

	    timerValues.it_value.tv_sec = nxt_div.quot;

    54

	    timerValues.it_value.tv_nsec = nxt_div.rem;

    55

	    timerValues.it_interval.tv_sec = period_div.quot;

    56

	    timerValues.it_interval.tv_nsec = period_div.rem;

    57

#else

    58

	    timerValues.it_value.tv_sec = next / 1000000000;

    59

	    timerValues.it_value.tv_nsec = next % 1000000000;

    60

	    timerValues.it_interval.tv_sec = period / 1000000000;

    61

	    timerValues.it_interval.tv_nsec = period % 1000000000;

    62

#endif

    63

	}

    64

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

    65

}

    66

//

    67

void catch_signal(int sig)

    68

{

    69

//  signal(SIGTERM, catch_signal);

    70

  signal(SIGINT, catch_signal);

    71

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

    72

  exit(0);

    73

}

    74

    75

    76

static unsigned long __debug_tick;

    77

    78

pthread_t PLC_thread;

    79

static pthread_mutex_t python_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    80

static pthread_mutex_t python_mutex = PTHREAD_MUTEX_INITIALIZER;

    81

static pthread_mutex_t debug_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    82

static pthread_mutex_t debug_mutex = PTHREAD_MUTEX_INITIALIZER;

    83

    84

int PLC_shutdown = 0;

    85

    86

void PLC_thread_proc(void *arg)

    87

{

    88

    while (!PLC_shutdown) {

    89

        sem_wait(&Run_PLC);

    90

        __run();

    91

    }

    92

    pthread_exit(0);

    93

}

    94

    95

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

    96

int startPLC(int argc,char **argv)

    97

{

    98

    struct sigevent sigev;

    99

    setlocale(LC_NUMERIC, "C");

   100

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

   101

    Ttick = common_ticktime__?common_ticktime__:1000000;

   102

   103

    PLC_shutdown = 0;

   104

   105

    sem_init(&Run_PLC, 0, 0);

   106

   107

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

   108

   109

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

   110

    sigev.sigev_value.sival_int = 0;

   111

    sigev.sigev_notify = SIGEV_THREAD;

   112

    sigev.sigev_notify_attributes = NULL;

   113

    sigev.sigev_notify_function = PLC_timer_notify;

   114

   115

    pthread_mutex_init(&debug_wait_mutex, NULL);

   116

    pthread_mutex_init(&debug_mutex, NULL);

   117

    pthread_mutex_init(&python_wait_mutex, NULL);

   118

    pthread_mutex_init(&python_mutex, NULL);

   119

   120

    pthread_mutex_lock(&debug_wait_mutex);

   121

    pthread_mutex_lock(&python_wait_mutex);

   122

   123

    timer_create (CLOCK_REALTIME, &sigev, &PLC_timer);

   124

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

   125

        PLC_SetTimer(Ttick,Ttick);

   126

   127

        /* install signal handler for manual break */

   128

        signal(SIGINT, catch_signal);

   129

    }else{

   130

        return 1;

   131

    }

   132

    return 0;

   133

}

   134

   135

int TryEnterDebugSection(void)

   136

{

   137

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

   138

        /* Only enter if debug active */

   139

        if(__DEBUG){

   140

            return 1;

   141

        }

   142

        pthread_mutex_unlock(&debug_mutex);

   143

    }

   144

    return 0;

   145

}

   146

   147

void LeaveDebugSection(void)

   148

{

   149

    pthread_mutex_unlock(&debug_mutex);

   150

}

   151

   152

int stopPLC()

   153

{

   154

    /* Stop the PLC */

   155

    PLC_shutdown = 1;

   156

    sem_post(&Run_PLC);

   157

    PLC_SetTimer(0,0);

   158

	pthread_join(PLC_thread, NULL);

   159

	sem_destroy(&Run_PLC);

   160

    timer_delete (PLC_timer);

   161

    __cleanup();

   162

    pthread_mutex_destroy(&debug_wait_mutex);

   163

    pthread_mutex_destroy(&debug_mutex);

   164

    pthread_mutex_destroy(&python_wait_mutex);

   165

    pthread_mutex_destroy(&python_mutex);

   166

    return 0;

   167

}

   168

   169

extern unsigned long __tick;

   170

   171

int WaitDebugData(unsigned long *tick)

   172

{

   173

    int res;

   174

    if (PLC_shutdown) return 1;

   175

    /* Wait signal from PLC thread */

   176

    res = pthread_mutex_lock(&debug_wait_mutex);

   177

    *tick = __debug_tick;

   178

    return res;

   179

}

   180

   181

/* Called by PLC thread when debug_publish finished

   182

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

   183

void InitiateDebugTransfer()

   184

{

   185

    /* remember tick */

   186

    __debug_tick = __tick;

   187

    /* signal debugger thread it can read data */

   188

    pthread_mutex_unlock(&debug_wait_mutex);

   189

}

   190

   191

int suspendDebug(int disable)

   192

{

   193

    /* Prevent PLC to enter debug code */

   194

    pthread_mutex_lock(&debug_mutex);

   195

    /*__DEBUG is protected by this mutex */

   196

    __DEBUG = !disable;

   197

    if (disable)

   198

    	pthread_mutex_unlock(&debug_mutex);

   199

    return 0;

   200

}

   201

   202

void resumeDebug(void)

   203

{

   204

    __DEBUG = 1;

   205

    /* Let PLC enter debug code */

   206

    pthread_mutex_unlock(&debug_mutex);

   207

}

   208

   209

/* from plc_python.c */

   210

int WaitPythonCommands(void)

   211

{

   212

    /* Wait signal from PLC thread */

   213

    return pthread_mutex_lock(&python_wait_mutex);

   214

}

   215

   216

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

   217

void UnBlockPythonCommands(void)

   218

{

   219

    /* signal debugger thread it can read data */

   220

    pthread_mutex_unlock(&python_wait_mutex);

   221

}

   222

   223

int TryLockPython(void)

   224

{

   225

    return pthread_mutex_trylock(&python_mutex) == 0;

   226

}

   227

   228

void UnLockPython(void)

   229

{

   230

    pthread_mutex_unlock(&python_mutex);

   231

}

   232

   233

void LockPython(void)

   234

{

   235

    pthread_mutex_lock(&python_mutex);

   236

}

   237

   238

int CheckRetainBuffer(void)

   239

{

   240

	return 1;

   241

}

   242

   243

void ValidateRetainBuffer(void)

   244

{

   245

}

   246

   247

void InValidateRetainBuffer(void)

   248

{

   249

}

   250

   251

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

   252

{

   253

}

   254

   255

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

   256

{

   257

}