1

/**

     2

 * Win32 specific code

     3

 **/

     4

     5

#include <stdio.h>

     6

#include <sys/timeb.h>

     7

#include <time.h>

     8

#include <windows.h>

    10

    11

/* provided by POUS.C */

    12

extern unsigned long long common_ticktime__;

    13

    14

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

    15

{

    16

    return InterlockedCompareExchange(atomicvar, exchange, compared);

    17

}

    18

    19

struct _timeb timetmp;

    20

void PLC_GetTime(IEC_TIME *CURRENT_TIME)

    21

{

    22

	_ftime(&timetmp);

    23

    24

	(*CURRENT_TIME).tv_sec = timetmp.time;

    25

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

    26

}

    27

    28

void PLC_timer_notify()

    29

{

    30

    PLC_GetTime(&__CURRENT_TIME);

    31

    __run();

    32

}

    33

    34

HANDLE PLC_timer = NULL;

    35

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

    36

{

    37

	LARGE_INTEGER liDueTime;

    38

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

    39

	liDueTime.QuadPart =  next / (-100);

    40

    41

	if (!SetWaitableTimer(PLC_timer, &liDueTime, period/1000000, NULL, NULL, 0))

    42

    {

    43

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

    44

    }

    45

}

    46

    47

/* Variable used to stop plcloop thread */

    48

void PlcLoop()

    49

{

    50

    while(WaitForSingleObject(PLC_timer, INFINITE) == WAIT_OBJECT_0)

    51

    {

    52

        PLC_timer_notify();

    53

    }

    54

}

    55

    56

HANDLE PLC_thread;

    57

HANDLE debug_sem;

    58

HANDLE debug_wait_sem;

    59

HANDLE python_sem;

    60

HANDLE python_wait_sem;

    61

    62

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

    63

int startPLC(int argc,char **argv)

    64

{

    65

	unsigned long thread_id = 0;

    67

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

    68

    Ttick = common_ticktime__?common_ticktime__:1000000;

    69

    70

    debug_sem = CreateSemaphore(

    71

                            NULL,           // default security attributes

    72

                            1,  			// initial count

    73

                            1,  			// maximum count

    74

                            NULL);          // unnamed semaphore

    75

    if (debug_sem == NULL)

    76

    {

    77

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

    78

        return;

    79

    }

    80

    81

    debug_wait_sem = CreateSemaphore(

    82

                            NULL,           // default security attributes

    83

                            0,  			// initial count

    84

                            1,  			// maximum count

    85

                            NULL);          // unnamed semaphore

    86

    87

    if (debug_wait_sem == NULL)

    88

    {

    89

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

    90

        return;

    91

    }

    92

    93

    python_sem = CreateSemaphore(

    94

                            NULL,           // default security attributes

    95

                            1,  			// initial count

    96

                            1,  			// maximum count

    97

                            NULL);          // unnamed semaphore

    98

    99

    if (python_sem == NULL)

   100

    {

   101

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

   102

        return;

   103

    }

   104

    python_wait_sem = CreateSemaphore(

   105

                            NULL,           // default security attributes

   106

                            0,  			// initial count

   107

                            1,  			// maximum count

   108

                            NULL);          // unnamed semaphore

   109

   110

   111

    if (python_wait_sem == NULL)

   112

    {

   113

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

   114

        return;

   115

    }

   116

   117

   118

    /* Create a waitable timer */

   119

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

   120

    if(NULL == PLC_timer)

   121

    {

   122

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

   123

        return 1;

   124

    }

   125

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

   126

    {

   127

        PLC_SetTimer(Ttick,Ttick);

   128

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

   129

    }

   130

    else{

   131

        return 1;

   132

    }

   133

    return 0;

   134

}

   135

static unsigned long __debug_tick;

   136

   137

int TryEnterDebugSection(void)

   138

{

   139

	//printf("TryEnterDebugSection\n");

   140

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

   141

        /* Only enter if debug active */

   142

        if(__DEBUG){

   143

            return 1;

   144

        }

   145

        ReleaseSemaphore(debug_sem, 1, NULL);

   146

    }

   147

    return 0;

   148

}

   149

   150

void LeaveDebugSection(void)

   151

{

   152

	ReleaseSemaphore(debug_sem, 1, NULL);

   153

    //printf("LeaveDebugSection\n");

   154

}

   155

   156

int stopPLC()

   157

{

   158

    CloseHandle(PLC_timer);

   159

    WaitForSingleObject(PLC_thread, INFINITE);

   160

    __cleanup();

   161

    CloseHandle(debug_wait_sem);

   162

    CloseHandle(debug_sem);

   163

    CloseHandle(python_wait_sem);

   164

    CloseHandle(python_sem);

   165

    CloseHandle(PLC_thread);

   166

}

   167

   168

/* from plc_debugger.c */

   169

int WaitDebugData(unsigned long *tick)

   170

{

   171

    *tick = __debug_tick;

   172

    /* Wait signal from PLC thread */

   173

	return WaitForSingleObject(debug_wait_sem, INFINITE) != WAIT_OBJECT_0;

   174

}

   175

   176

/* Called by PLC thread when debug_publish finished

   177

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

   178

void InitiateDebugTransfer()

   179

{

   180

    /* remember tick */

   181

    __debug_tick = __tick;

   182

    /* signal debugger thread it can read data */

   183

    ReleaseSemaphore(debug_wait_sem, 1, NULL);

   184

}

   185

   186

void suspendDebug(int disable)

   187

{

   188

    /* Prevent PLC to enter debug code */

   189

    WaitForSingleObject(debug_sem, INFINITE);

   190

    /*__DEBUG is protected by this mutex */

   191

    __DEBUG = !disable;

   192

    if(disable)

   193

        ReleaseSemaphore(debug_sem, 1, NULL);

   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

   232

int CheckRetainBuffer(void)

   233

{

   234

	return 1;

   235

}

   236

   237

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

   238

{

   239

    unsigned int position;

   240

    for(position=0; position<count; position++ ){

   241

        printf("%d : 0x%2.2x\n", offset+position, ((char*)p)[position]);

   242

    }

   243

}

   244

   245

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

   246

{

   247

}

   248