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

#include <locale.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?1: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;

    66

    setlocale(LC_NUMERIC, "C");

    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

    timeBeginPeriod(1);

   120

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

   121

    if(NULL == PLC_timer)

   122

    {

   123

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

   124

        return 1;

   125

    }

   126

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

   127

    {

   128

        PLC_SetTimer(Ttick,Ttick);

   129

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

   130

    }

   131

    else{

   132

        return 1;

   133

    }

   134

    return 0;

   135

}

   136

static unsigned long __debug_tick;

   137

   138

int TryEnterDebugSection(void)

   139

{

   140

	//printf("TryEnterDebugSection\n");

   141

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

   142

        /* Only enter if debug active */

   143

        if(__DEBUG){

   144

            return 1;

   145

        }

   146

        ReleaseSemaphore(debug_sem, 1, NULL);

   147

    }

   148

    return 0;

   149

}

   150

   151

void LeaveDebugSection(void)

   152

{

   153

	ReleaseSemaphore(debug_sem, 1, NULL);

   154

    //printf("LeaveDebugSection\n");

   155

}

   156

   157

int stopPLC()

   158

{

   159

    CloseHandle(PLC_timer);

   160

    WaitForSingleObject(PLC_thread, INFINITE);

   161

    __cleanup();

   162

    CloseHandle(debug_wait_sem);

   163

    CloseHandle(debug_sem);

   164

    CloseHandle(python_wait_sem);

   165

    CloseHandle(python_sem);

   166

    CloseHandle(PLC_thread);

   167

}

   168

   169

/* from plc_debugger.c */

   170

int WaitDebugData(unsigned long *tick)

   171

{

   172

	DWORD res;

   173

	res = WaitForSingleObject(debug_wait_sem, INFINITE);

   174

    *tick = __debug_tick;

   175

    /* Wait signal from PLC thread */

   176

	return res != WAIT_OBJECT_0;

   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

int suspendDebug(int disable)

   190

{

   191

    /* Prevent PLC to enter debug code */

   192

    WaitForSingleObject(debug_sem, INFINITE);

   193

    __DEBUG = !disable;

   194

    if(disable)

   195

        ReleaseSemaphore(debug_sem, 1, NULL);

   196

    return 0;

   197

}

   198

   199

void resumeDebug()

   200

{

   201

	__DEBUG = 1;

   202

    /* Let PLC enter debug code */

   203

	ReleaseSemaphore(debug_sem, 1, NULL);

   204

}

   205

   206

/* from plc_python.c */

   207

int WaitPythonCommands(void)

   208

{

   209

    /* Wait signal from PLC thread */

   210

	return WaitForSingleObject(python_wait_sem, INFINITE);

   211

}

   212

   213

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

   214

void UnBlockPythonCommands(void)

   215

{

   216

    /* signal debugger thread it can read data */

   217

	ReleaseSemaphore(python_wait_sem, 1, NULL);

   218

}

   219

   220

int TryLockPython(void)

   221

{

   222

	return WaitForSingleObject(python_sem, 0) == WAIT_OBJECT_0;

   223

}

   224

   225

void UnLockPython(void)

   226

{

   227

	ReleaseSemaphore(python_sem, 1, NULL);

   228

}

   229

   230

void LockPython(void)

   231

{

   232

	WaitForSingleObject(python_sem, INFINITE);

   233

}

   234

   235

int CheckRetainBuffer(void)

   236

{

   237

	return 1;

   238

}

   239

   240

void ValidateRetainBuffer(void)

   241

{

   242

}

   243

   244

void InValidateRetainBuffer(void)

   245

{

   246

}

   247

   248

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

   249

{

   250

    /*

   251

    unsigned int position;

   252

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

   253

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

   254

    }

   255

    */

   256

}

   257

   258

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

   259

{

   260

}

   261