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 int 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

    40

	/*

    41

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

    42

	*/

    43

    44

	if (!SetWaitableTimer(PLC_timer, &liDueTime, common_ticktime__, NULL, NULL, 0))

    45

    {

    46

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

    47

    }

    48

}

    49

    50

/* Variable used to stop plcloop thread */

    51

int runplcloop;

    52

void PlcLoop()

    53

{

    54

	runplcloop = 1;

    55

	while(runplcloop)

    56

	{

    57

	// Set a timer

    58

	PLC_SetTimer(Ttick,Ttick);

    59

	if (WaitForSingleObject(PLC_timer, INFINITE) != WAIT_OBJECT_0)

    60

	{

    61

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

    62

	}

    63

	PLC_timer_notify();

    64

	}

    65

}

    66

    67

HANDLE PLC_thread;

    68

HANDLE debug_sem;

    69

HANDLE debug_wait_sem;

    70

HANDLE python_sem;

    71

HANDLE python_wait_sem;

    72

    73

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

    74

int startPLC(int argc,char **argv)

    75

{

    76

	unsigned long thread_id = 0;

    77

	/* Translate PLC's microseconds to Ttick nanoseconds */

    78

	Ttick = 1000000 * maxval(common_ticktime__,1);

    79

    80

	debug_sem = CreateSemaphore(

    81

							NULL,           // default security attributes

    82

					        1,  			// initial count

    83

					        1,  			// maximum count

    84

					        NULL);          // unnamed semaphore

    85

    if (debug_sem == NULL)

    86

    {

    87

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

    88

        return;

    89

    }

    90

    91

	debug_wait_sem = CreateSemaphore(

    92

					        NULL,           // default security attributes

    93

					        0,  			// initial count

    94

					        1,  			// maximum count

    95

					        NULL);          // unnamed semaphore

    96

    97

    if (debug_wait_sem == NULL)

    98

    {

    99

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

   100

        return;

   101

    }

   102

   103

	python_sem = CreateSemaphore(

   104

					        NULL,           // default security attributes

   105

					        1,  			// initial count

   106

					        1,  			// maximum count

   107

					        NULL);          // unnamed semaphore

   108

   109

    if (python_sem == NULL)

   110

    {

   111

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

   112

        return;

   113

    }

   114

	python_wait_sem = CreateSemaphore(

   115

					        NULL,           // default security attributes

   116

					        0,  			// initial count

   117

					        1,  			// maximum count

   118

					        NULL);          // unnamed semaphore

   119

   120

   121

    if (python_wait_sem == NULL)

   122

    {

   123

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

   124

        return;

   125

    }

   126

   127

   128

	/* Create a waitable timer */

   129

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

   130

    if(NULL == PLC_timer)

   131

    {

   132

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

   133

        return 1;

   134

    }

   135

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

   136

    {

   137

    	printf("Tick Time : %d ms\n", common_ticktime__);

   138

    	PLC_thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)PlcLoop, NULL, 0, &thread_id);

   139

    }

   140

    else{

   141

    	return 1;

   142

    }

   143

    return 0;

   144

}

   145

static int __debug_tick;

   146

   147

int TryEnterDebugSection(void)

   148

{

   149

	//printf("TryEnterDebugSection\n");

   150

	return WaitForSingleObject(debug_sem, 0) == WAIT_OBJECT_0;

   151

}

   152

   153

void LeaveDebugSection(void)

   154

{

   155

	ReleaseSemaphore(debug_sem, 1, NULL);

   156

    //printf("LeaveDebugSection\n");

   157

}

   158

   159

int stopPLC()

   160

{

   161

	runplcloop = 0;

   162

	WaitForSingleObject(PLC_thread, INFINITE);

   163

	__cleanup();

   164

	__debug_tick = -1;

   165

	ReleaseSemaphore(debug_wait_sem, 1, NULL);

   166

	CloseHandle(debug_sem);

   167

	CloseHandle(debug_wait_sem);

   168

	CloseHandle(PLC_timer);

   169

	CloseHandle(PLC_thread);

   170

}

   171

   172

/* from plc_debugger.c */

   173

int WaitDebugData()

   174

{

   175

	if(WaitForSingleObject(debug_wait_sem, INFINITE) != WAIT_OBJECT_0) return -1;

   176

	return __debug_tick;

   177

}

   178

   179

/* Called by PLC thread when debug_publish finished

   180

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

   181

void InitiateDebugTransfer()

   182

{

   183

    /* remember tick */

   184

    __debug_tick = __tick;

   185

    /* signal debugger thread it can read data */

   186

    ReleaseSemaphore(debug_wait_sem, 1, NULL);

   187

}

   188

   189

void suspendDebug()

   190

{

   191

	__DEBUG = 0;

   192

    /* Prevent PLC to enter debug code */

   193

	WaitForSingleObject(debug_sem, INFINITE);

   194

}

   195

   196

void resumeDebug()

   197

{

   198

	__DEBUG = 1;

   199

    /* Let PLC enter debug code */

   200

	ReleaseSemaphore(debug_sem, 1, NULL);

   201

}

   202

   203

/* from plc_python.c */

   204

int WaitPythonCommands(void)

   205

{

   206

    /* Wait signal from PLC thread */

   207

	return WaitForSingleObject(python_wait_sem, INFINITE);

   208

}

   209

   210

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

   211

void UnBlockPythonCommands(void)

   212

{

   213

    /* signal debugger thread it can read data */

   214

	ReleaseSemaphore(python_wait_sem, 1, NULL);

   215

}

   216

   217

int TryLockPython(void)

   218

{

   219

	return WaitForSingleObject(python_sem, 0) == WAIT_OBJECT_0;

   220

}

   221

   222

void UnLockPython(void)

   223

{

   224

	ReleaseSemaphore(python_sem, 1, NULL);

   225

}

   226

   227

void LockPython(void)

   228

{

   229

	WaitForSingleObject(python_sem, INFINITE);

   230

}

   231