1

#include <stdio.h>

     2

#include <sys/timeb.h>

     3

#include <time.h>

     4

#include <windows.h>

     5

     6

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

     7

{

     8

    return InterlockedCompareExchange(atomicvar, exchange, compared);

     9

}

    10

    11

//long AtomicExchange(long* atomicvar,long exchange)

    12

//{

    13

//    return InterlockedExchange(atomicvar, exchange);    

    14

//}

    15

    16

struct _timeb timetmp;

    17

void PLC_GetTime(IEC_TIME *CURRENT_TIME)

    18

{

    19

	_ftime(&timetmp);

    20

    21

	(*CURRENT_TIME).tv_sec = timetmp.time;

    22

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

    23

}

    24

    25

void PLC_timer_notify()

    26

{

    27

    PLC_GetTime(&__CURRENT_TIME);

    28

    __run();

    29

}

    30

    31

HANDLE PLC_timer = NULL;

    32

void PLC_SetTimer(long long next, long long period)

    33

{

    34

	LARGE_INTEGER liDueTime;

    35

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

    36

	liDueTime.QuadPart =  next / (-100);

    37

    38

	/*

    39

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

    40

	*/

    41

    42

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

    43

    {

    44

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

    45

    }

    46

}

    47

    48

/* Variable used to stop plcloop thread */

    49

int runplcloop;

    50

void PlcLoop()

    51

{

    52

	runplcloop = 1;

    53

	while(runplcloop)

    54

	{

    55

	// Set a timer

    56

	PLC_SetTimer(Ttick,Ttick);

    57

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

    58

	{

    59

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

    60

	}

    61

	PLC_timer_notify();

    62

	}

    63

}

    64

    65

HANDLE DebugLock;

    66

HANDLE PLC_thread;

    67

    68

int startPLC(int argc,char **argv)

    69

{

    70

	unsigned long thread_id = 0;

    71

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

    72

	Ttick = 1000000 * maxval(common_ticktime__,1);

    73

    74

	DebugLock = CreateMutex( 

    75

	        	NULL,              // default security attributes

    76

	        	FALSE,             // initially not owned

    77

	        	NULL);             // unnamed mutex

    78

    79

    if (DebugLock == NULL) 

    80

    {

    81

        printf("CreateMutex error: %d\n", GetLastError());

    82

        return;

    83

    }

    84

    85

	/* Create a waitable timer */

    86

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

    87

    if(NULL == PLC_timer)

    88

    {

    89

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

    90

        return 1;

    91

    }

    92

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

    93

    {

    94

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

    95

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

    96

    }

    97

    else{

    98

    	return 1;

    99

    }

   100

    return 0;

   101

}

   102

   103

int stopPLC()

   104

{

   105

	runplcloop = 0;

   106

	WaitForSingleObject(PLC_thread, INFINITE);

   107

	CloseHandle(PLC_thread);

   108

	CloseHandle(DebugLock);

   109

    CloseHandle(PLC_timer);

   110

    __cleanup();

   111

}

   112

   113

/* from plc_debugger.c */

   114

void WaitDebugData()

   115

{

   116

	DWORD dwWaitResult;

   117

	dwWaitResult = WaitForSingleObject( 

   118

					DebugLock,  // handle to mutex

   119

					INFINITE);  // no time-out interval

   120

}

   121

   122

/* Called by PLC thread when debug_publish finished

   123

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

   124

void InitiateDebugTransfer()

   125

{

   126

    /* signal debugger thread to continue*/

   127

	ReleaseMutex(DebugLock);

   128

}