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

    40

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

    41

    {

    42

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

    43

    }

    44

}

    45

    46

/* Variable used to stop plcloop thread */

    47

void PlcLoop()

    48

{

    49

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

    50

    {

    51

        PLC_timer_notify();

    52

    }

    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

    68

    debug_sem = CreateSemaphore(

    69

                            NULL,           // default security attributes

    70

                            1,  			// initial count

    71

                            1,  			// maximum count

    72

                            NULL);          // unnamed semaphore

    73

    if (debug_sem == NULL)

    74

    {

    75

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

    76

        return;

    77

    }

    78

    79

    debug_wait_sem = CreateSemaphore(

    80

                            NULL,           // default security attributes

    81

                            0,  			// initial count

    82

                            1,  			// maximum count

    83

                            NULL);          // unnamed semaphore

    84

    85

    if (debug_wait_sem == NULL)

    86

    {

    87

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

    88

        return;

    89

    }

    90

    91

    python_sem = CreateSemaphore(

    92

                            NULL,           // default security attributes

    93

                            1,  			// initial count

    94

                            1,  			// maximum count

    95

                            NULL);          // unnamed semaphore

    96

    97

    if (python_sem == NULL)

    98

    {

    99

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

   100

        return;

   101

    }

   102

    python_wait_sem = CreateSemaphore(

   103

                            NULL,           // default security attributes

   104

                            0,  			// initial count

   105

                            1,  			// maximum count

   106

                            NULL);          // unnamed semaphore

   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

   116

    /* Create a waitable timer */

   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

    {

   125

        PLC_SetTimer(Ttick,Ttick);

   126

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

   127

    }

   128

    else{

   129

        return 1;

   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

        }

   143

        ReleaseSemaphore(debug_sem, 1, NULL);

   144

    }

   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

{

   156

    CloseHandle(PLC_timer);

   157

    WaitForSingleObject(PLC_thread, INFINITE);

   158

    __cleanup();

   159

    CloseHandle(debug_wait_sem);

   160

    CloseHandle(debug_sem);

   161

    CloseHandle(python_wait_sem);

   162

    CloseHandle(python_sem);

   163

    CloseHandle(PLC_thread);

   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 */

   187

    WaitForSingleObject(debug_sem, INFINITE);

   188

    /*__DEBUG is protected by this mutex */

   189

    __DEBUG = !disable;

   190

    if(disable)

   191

        ReleaseSemaphore(debug_sem, 1, NULL);

   192

}

   193

   194

void resumeDebug()

   195

{

   196

	__DEBUG = 1;

   197

    /* Let PLC enter debug code */

   198

	ReleaseSemaphore(debug_sem, 1, NULL);

   199

}

   200

   201

/* from plc_python.c */

   202

int WaitPythonCommands(void)

   203

{

   204

    /* Wait signal from PLC thread */

   205

	return WaitForSingleObject(python_wait_sem, INFINITE);

   206

}

   207

   208

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

   209

void UnBlockPythonCommands(void)

   210

{

   211

    /* signal debugger thread it can read data */

   212

	ReleaseSemaphore(python_wait_sem, 1, NULL);

   213

}

   214

   215

int TryLockPython(void)

   216

{

   217

	return WaitForSingleObject(python_sem, 0) == WAIT_OBJECT_0;

   218

}

   219

   220

void UnLockPython(void)

   221

{

   222

	ReleaseSemaphore(python_sem, 1, NULL);

   223

}

   224

   225

void LockPython(void)

   226

{

   227

	WaitForSingleObject(python_sem, INFINITE);

   228

}

   229

   230

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

   231

{

   232

    unsigned int position;

   233

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

   234

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

   235

    }

   236

}

   237

   238

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

   239

{

   240

}

   241