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

}

    21

    22

void PLC_GetTime(IEC_TIME *CURRENT_TIME)

    23

{

    24

    struct timespec tmp;

    25

    clock_gettime(CLOCK_REALTIME, &tmp);

    26

    CURRENT_TIME->tv_sec = tmp.tv_sec;

    27

    CURRENT_TIME->tv_nsec = tmp.tv_nsec;

    28

}

    29

    30

void PLC_timer_notify(sigval_t val)

    31

{

    32

    PLC_GetTime(&__CURRENT_TIME);

    33

    sem_post(&Run_PLC);

    34

}

    35

    36

timer_t PLC_timer;

    37

    38

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

    39

{

    40

    struct itimerspec timerValues;

    41

	/*

    42

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

    43

	*/

    44

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

    45

	{

    46

#ifdef __lldiv_t_defined

    47

		lldiv_t nxt_div = lldiv(next, 1000000000);

    48

		lldiv_t period_div = lldiv(period, 1000000000);

    49

	    timerValues.it_value.tv_sec = nxt_div.quot;

    50

	    timerValues.it_value.tv_nsec = nxt_div.rem;

    51

	    timerValues.it_interval.tv_sec = period_div.quot;

    52

	    timerValues.it_interval.tv_nsec = period_div.rem;

    53

#else

    54

	    timerValues.it_value.tv_sec = next / 1000000000;

    55

	    timerValues.it_value.tv_nsec = next % 1000000000;

    56

	    timerValues.it_interval.tv_sec = period / 1000000000;

    57

	    timerValues.it_interval.tv_nsec = period % 1000000000;

    58

#endif

    59

	}

    60

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

    61

}

    62

//

    63

void catch_signal(int sig)

    64

{

    65

//  signal(SIGTERM, catch_signal);

    66

  signal(SIGINT, catch_signal);

    67

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

    68

  exit(0);

    69

}

    70

    71

    72

static unsigned long __debug_tick;

    73

    74

pthread_t PLC_thread;

    75

static pthread_mutex_t python_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    76

static pthread_mutex_t python_mutex = PTHREAD_MUTEX_INITIALIZER;

    77

static pthread_mutex_t debug_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

    78

static pthread_mutex_t debug_mutex = PTHREAD_MUTEX_INITIALIZER;

    79

    80

int PLC_shutdown = 0;

    81

    82

void PLC_thread_proc(void *arg)

    83

{

    84

    while (!PLC_shutdown) {

    85

        sem_wait(&Run_PLC);

    86

        __run();

    87

    }

    88

    pthread_exit(0);

    89

}

    90

    91

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

    92

int startPLC(int argc,char **argv)

    93

{

    94

    struct sigevent sigev;

    95

    setlocale(LC_NUMERIC, "C");

    96

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

    97

    Ttick = common_ticktime__?common_ticktime__:1000000;

    98

    99

    PLC_shutdown = 0;

   100

   101

    sem_init(&Run_PLC, 0, 0);

   102

   103

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

   104

   105

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

   106

    sigev.sigev_value.sival_int = 0;

   107

    sigev.sigev_notify = SIGEV_THREAD;

   108

    sigev.sigev_notify_attributes = NULL;

   109

    sigev.sigev_notify_function = PLC_timer_notify;

   110

   111

    pthread_mutex_init(&debug_wait_mutex, NULL);

   112

    pthread_mutex_init(&debug_mutex, NULL);

   113

    pthread_mutex_init(&python_wait_mutex, NULL);

   114

    pthread_mutex_init(&python_mutex, NULL);

   115

   116

    pthread_mutex_lock(&debug_wait_mutex);

   117

    pthread_mutex_lock(&python_wait_mutex);

   118

   119

    timer_create (CLOCK_REALTIME, &sigev, &PLC_timer);

   120

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

   121

        PLC_SetTimer(Ttick,Ttick);

   122

   123

        /* install signal handler for manual break */

   124

        signal(SIGINT, catch_signal);

   125

    }else{

   126

        return 1;

   127

    }

   128

    return 0;

   129

}

   130

   131

int TryEnterDebugSection(void)

   132

{

   133

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

   134

        /* Only enter if debug active */

   135

        if(__DEBUG){

   136

            return 1;

   137

        }

   138

        pthread_mutex_unlock(&debug_mutex);

   139

    }

   140

    return 0;

   141

}

   142

   143

void LeaveDebugSection(void)

   144

{

   145

    pthread_mutex_unlock(&debug_mutex);

   146

}

   147

   148

int stopPLC()

   149

{

   150

    /* Stop the PLC */

   151

    PLC_shutdown = 1;

   152

    sem_post(&Run_PLC);

   153

    PLC_SetTimer(0,0);

   154

	pthread_join(PLC_thread, NULL);

   155

	sem_destroy(&Run_PLC);

   156

    timer_delete (PLC_timer);

   157

    __cleanup();

   158

    pthread_mutex_destroy(&debug_wait_mutex);

   159

    pthread_mutex_destroy(&debug_mutex);

   160

    pthread_mutex_destroy(&python_wait_mutex);

   161

    pthread_mutex_destroy(&python_mutex);

   162

    return 0;

   163

}

   164

   165

extern unsigned long __tick;

   166

   167

int WaitDebugData(unsigned long *tick)

   168

{

   169

    int res;

   170

    if (PLC_shutdown) return 1;

   171

    /* Wait signal from PLC thread */

   172

    res = pthread_mutex_lock(&debug_wait_mutex);

   173

    *tick = __debug_tick;

   174

    return res;

   175

}

   176

   177

/* Called by PLC thread when debug_publish finished

   178

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

   179

void InitiateDebugTransfer()

   180

{

   181

    /* remember tick */

   182

    __debug_tick = __tick;

   183

    /* signal debugger thread it can read data */

   184

    pthread_mutex_unlock(&debug_wait_mutex);

   185

}

   186

   187

int suspendDebug(int disable)

   188

{

   189

    /* Prevent PLC to enter debug code */

   190

    pthread_mutex_lock(&debug_mutex);

   191

    /*__DEBUG is protected by this mutex */

   192

    __DEBUG = !disable;

   193

    if (disable)

   194

    	pthread_mutex_unlock(&debug_mutex);

   195

    return 0;

   196

}

   197

   198

void resumeDebug(void)

   199

{

   200

    __DEBUG = 1;

   201

    /* Let PLC enter debug code */

   202

    pthread_mutex_unlock(&debug_mutex);

   203

}

   204

   205

/* from plc_python.c */

   206

int WaitPythonCommands(void)

   207

{

   208

    /* Wait signal from PLC thread */

   209

    return pthread_mutex_lock(&python_wait_mutex);

   210

}

   211

   212

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

   213

void UnBlockPythonCommands(void)

   214

{

   215

    /* signal debugger thread it can read data */

   216

    pthread_mutex_unlock(&python_wait_mutex);

   217

}

   218

   219

int TryLockPython(void)

   220

{

   221

    return pthread_mutex_trylock(&python_mutex) == 0;

   222

}

   223

   224

void UnLockPython(void)

   225

{

   226

    pthread_mutex_unlock(&python_mutex);

   227

}

   228

   229

void LockPython(void)

   230

{

   231

    pthread_mutex_lock(&python_mutex);

   232

}

   233

   234

int CheckRetainBuffer(void)

   235

{

   236

	return 1;

   237

}

   238

   239

void ValidateRetainBuffer(void)

   240

{

   241

}

   242

   243

void InValidateRetainBuffer(void)

   244

{

   245

}

   246

   247

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

   248

{

   249

}

   250

   251

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

   252

{

   253

}