1

/**

     2

 * Win32 specific code

     3

 **/

     4

     5

#include <stdio.h>

     6

#include <sys/timeb.h>

     7

#include <time.h>

     8

#include <windows.h>

     9

    10

/* provided by POUS.C */

    11

extern unsigned long common_ticktime__;

    12

    13

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

    14

{

    15

    return InterlockedCompareExchange(atomicvar, exchange, compared);

    16

}

    17

    18

struct _timeb timetmp;

    19

void PLC_GetTime(IEC_TIME *CURRENT_TIME)

    20

{

    21

	_ftime(&timetmp);

    22

    23

	(*CURRENT_TIME).tv_sec = timetmp.time;

    24

	(*CURRENT_TIME).tv_nsec = timetmp.millitm * 1000000;

    25

}

    26

    27

void PLC_timer_notify()

    28

{

    29

    PLC_GetTime(&__CURRENT_TIME);

    30

    __run();

    31

}

    32

    33

HANDLE PLC_timer = NULL;

    34

void PLC_SetTimer(long long next, long long period)

    35

{

    36

	LARGE_INTEGER liDueTime;

    37

	/* arg 2 of SetWaitableTimer take 100 ns interval*/

    38

	liDueTime.QuadPart =  next / (-100);

    39

    41

    {

    42

        printf("SetWaitableTimer failed (%d)\n", GetLastError());

    43

    }

    44

}

    45

    46

/* Variable used to stop plcloop thread */

    47

void PlcLoop()

    48

{

    53

}

    54

    55

HANDLE PLC_thread;

    56

HANDLE debug_sem;

    57

HANDLE debug_wait_sem;

    58

HANDLE python_sem;

    59

HANDLE python_wait_sem;

    60

    61

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

    62

int startPLC(int argc,char **argv)

    63

{

    64

	unsigned long thread_id = 0;

    65

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

    66

    Ttick = common_ticktime__?common_ticktime__:1000000;

    67

    73

    if (debug_sem == NULL)

    74

    {

    75

        printf("startPLC CreateSemaphore debug_sem error: %d\n", GetLastError());

    76

        return;

    77

    }

    78

    84

    85

    if (debug_wait_sem == NULL)

    86

    {

    87

        printf("startPLC CreateSemaphore debug_wait_sem error: %d\n", GetLastError());

    88

        return;

    89

    }

    90

    96

    97

    if (python_sem == NULL)

    98

    {

    99

        printf("startPLC CreateSemaphore python_sem error: %d\n", GetLastError());

   100

        return;

   101

    }

   107

   108

   109

    if (python_wait_sem == NULL)

   110

    {

   111

        printf("startPLC CreateSemaphore python_wait_sem error: %d\n", GetLastError());

   112

        return;

   113

    }

   114

   115

   117

    PLC_timer = CreateWaitableTimer(NULL, FALSE, "WaitableTimer");

   118

    if(NULL == PLC_timer)

   119

    {

   120

        printf("CreateWaitableTimer failed (%d)\n", GetLastError());

   121

        return 1;

   122

    }

   123

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

   124

    {

   127

    }

   128

    else{

   130

    }

   131

    return 0;

   132

}

   133

static unsigned long __debug_tick;

   134

   135

int TryEnterDebugSection(void)

   136

{

   137

	//printf("TryEnterDebugSection\n");

   138

    if(WaitForSingleObject(debug_sem, 0) == WAIT_OBJECT_0){

   139

        /* Only enter if debug active */

   140

        if(__DEBUG){

   141

            return 1;

   142

        }

   145

    return 0;

   146

}

   147

   148

void LeaveDebugSection(void)

   149

{

   150

	ReleaseSemaphore(debug_sem, 1, NULL);

   151

    //printf("LeaveDebugSection\n");

   152

}

   153

   154

int stopPLC()

   155

{

   164

}

   165

   166

/* from plc_debugger.c */

   167

int WaitDebugData(unsigned long *tick)

   168

{

   169

    *tick = __debug_tick;

   170

    /* Wait signal from PLC thread */

   171

	return WaitForSingleObject(debug_wait_sem, INFINITE) != WAIT_OBJECT_0;

   172

}

   173

   174

/* Called by PLC thread when debug_publish finished

   175

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

   176

void InitiateDebugTransfer()

   177

{

   178

    /* remember tick */

   179

    __debug_tick = __tick;

   180

    /* signal debugger thread it can read data */

   181

    ReleaseSemaphore(debug_wait_sem, 1, NULL);

   182

}

   183

   184

void suspendDebug(int disable)

   185

{

   186

    /* Prevent PLC to enter debug code */

   188

    /*__DEBUG is protected by this mutex */

   189

    __DEBUG = !disable;

   190

}

   191

   192

void resumeDebug()

   193

{

   194

	__DEBUG = 1;

   195

    /* Let PLC enter debug code */

   196

	ReleaseSemaphore(debug_sem, 1, NULL);

   197

}

   198

   199

/* from plc_python.c */

   200

int WaitPythonCommands(void)

   201

{

   202

    /* Wait signal from PLC thread */

   203

	return WaitForSingleObject(python_wait_sem, INFINITE);

   204

}

   205

   206

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

   207

void UnBlockPythonCommands(void)

   208

{

   209

    /* signal debugger thread it can read data */

   210

	ReleaseSemaphore(python_wait_sem, 1, NULL);

   211

}

   212

   213

int TryLockPython(void)

   214

{

   215

	return WaitForSingleObject(python_sem, 0) == WAIT_OBJECT_0;

   216

}

   217

   218

void UnLockPython(void)

   219

{

   220

	ReleaseSemaphore(python_sem, 1, NULL);

   221

}

   222

   223

void LockPython(void)

   224

{

   225

	WaitForSingleObject(python_sem, INFINITE);

   226

}

   227