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

CRITICAL_SECTION Atomic64CS; 

    19

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

    20

{

    21

    long long res;

    22

    EnterCriticalSection(&Atomic64CS);

    23

    res=*atomicvar;

    24

    if(*atomicvar == compared){

    25

        *atomicvar = exchange;

    26

    }

    27

    LeaveCriticalSection(&Atomic64CS);

    28

    return res;

    29

}

    30

    31

struct _timeb timetmp;

    32

void PLC_GetTime(IEC_TIME *CURRENT_TIME)

    33

{

    34

	_ftime(&timetmp);

    35

    36

	(*CURRENT_TIME).tv_sec = timetmp.time;

    37

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

    38

}

    39

    40

void PLC_timer_notify()

    41

{

    42

    PLC_GetTime(&__CURRENT_TIME);

    43

    __run();

    44

}

    45

    46

HANDLE PLC_timer = NULL;

    47

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

    48

{

    49

	LARGE_INTEGER liDueTime;

    50

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

    51

	liDueTime.QuadPart =  next / (-100);

    52

    53

	if (!SetWaitableTimer(PLC_timer, &liDueTime, period<1000000?1:period/1000000, NULL, NULL, 0))

    54

    {

    55

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

    56

    }

    57

}

    58

    59

/* Variable used to stop plcloop thread */

    60

void PlcLoop()

    61

{

    62

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

    63

    {

    64

        PLC_timer_notify();

    65

    }

    66

}

    67

    68

HANDLE PLC_thread;

    69

HANDLE debug_sem;

    70

HANDLE debug_wait_sem;

    71

HANDLE python_sem;

    72

HANDLE python_wait_sem;

    73

    74

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

    75

int startPLC(int argc,char **argv)

    76

{

    77

	unsigned long thread_id = 0;

    78

    BOOL tmp;

    79

    setlocale(LC_NUMERIC, "C");

    80

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

    81

    Ttick = common_ticktime__?common_ticktime__:1000000;

    82

    83

    InitializeCriticalSection(&Atomic64CS);

    84

    85

    debug_sem = CreateSemaphore(

    86

                            NULL,           // default security attributes

    87

                            1,  			// initial count

    88

                            1,  			// maximum count

    89

                            NULL);          // unnamed semaphore

    90

    if (debug_sem == NULL)

    91

    {

    92

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

    93

        return;

    94

    }

    95

    96

    debug_wait_sem = CreateSemaphore(

    97

                            NULL,           // default security attributes

    98

                            0,  			// initial count

    99

                            1,  			// maximum count

   100

                            NULL);          // unnamed semaphore

   101

   102

    if (debug_wait_sem == NULL)

   103

    {

   104

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

   105

        return;

   106

    }

   107

   108

    python_sem = CreateSemaphore(

   109

                            NULL,           // default security attributes

   110

                            1,  			// initial count

   111

                            1,  			// maximum count

   112

                            NULL);          // unnamed semaphore

   113

   114

    if (python_sem == NULL)

   115

    {

   116

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

   117

        return;

   118

    }

   119

    python_wait_sem = CreateSemaphore(

   120

                            NULL,           // default security attributes

   121

                            0,  			// initial count

   122

                            1,  			// maximum count

   123

                            NULL);          // unnamed semaphore

   124

   125

   126

    if (python_wait_sem == NULL)

   127

    {

   128

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

   129

        return;

   130

    }

   131

   132

   133

    /* Create a waitable timer */

   134

    timeBeginPeriod(1);

   135

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

   136

    if(NULL == PLC_timer)

   137

    {

   138

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

   139

        return 1;

   140

    }

   141

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

   142

    {

   143

        PLC_SetTimer(Ttick,Ttick);

   144

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

   145

    }

   146

    else{

   147

        return 1;

   148

    }

   149

    return 0;

   150

}

   151

static unsigned long __debug_tick;

   152

   153

int TryEnterDebugSection(void)

   154

{

   155

	//printf("TryEnterDebugSection\n");

   156

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

   157

        /* Only enter if debug active */

   158

        if(__DEBUG){

   159

            return 1;

   160

        }

   161

        ReleaseSemaphore(debug_sem, 1, NULL);

   162

    }

   163

    return 0;

   164

}

   165

   166

void LeaveDebugSection(void)

   167

{

   168

	ReleaseSemaphore(debug_sem, 1, NULL);

   169

    //printf("LeaveDebugSection\n");

   170

}

   171

   172

int stopPLC()

   173

{

   174

    CloseHandle(PLC_timer);

   175

    WaitForSingleObject(PLC_thread, INFINITE);

   176

    __cleanup();

   177

    DeleteCriticalSection(&Atomic64CS);

   178

    CloseHandle(debug_wait_sem);

   179

    CloseHandle(debug_sem);

   180

    CloseHandle(python_wait_sem);

   181

    CloseHandle(python_sem);

   182

    CloseHandle(PLC_thread);

   183

}

   184

   185

/* from plc_debugger.c */

   186

int WaitDebugData(unsigned long *tick)

   187

{

   188

	DWORD res;

   189

	res = WaitForSingleObject(debug_wait_sem, INFINITE);

   190

    *tick = __debug_tick;

   191

    /* Wait signal from PLC thread */

   192

	return res != WAIT_OBJECT_0;

   193

}

   194

   195

/* Called by PLC thread when debug_publish finished

   196

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

   197

void InitiateDebugTransfer()

   198

{

   199

    /* remember tick */

   200

    __debug_tick = __tick;

   201

    /* signal debugger thread it can read data */

   202

    ReleaseSemaphore(debug_wait_sem, 1, NULL);

   203

}

   204

   205

int suspendDebug(int disable)

   206

{

   207

    /* Prevent PLC to enter debug code */

   208

    WaitForSingleObject(debug_sem, INFINITE);

   209

    __DEBUG = !disable;

   210

    if(disable)

   211

        ReleaseSemaphore(debug_sem, 1, NULL);

   212

    return 0;

   213

}

   214

   215

void resumeDebug()

   216

{

   217

	__DEBUG = 1;

   218

    /* Let PLC enter debug code */

   219

	ReleaseSemaphore(debug_sem, 1, NULL);

   220

}

   221

   222

/* from plc_python.c */

   223

int WaitPythonCommands(void)

   224

{

   225

    /* Wait signal from PLC thread */

   226

	return WaitForSingleObject(python_wait_sem, INFINITE);

   227

}

   228

   229

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

   230

void UnBlockPythonCommands(void)

   231

{

   232

    /* signal debugger thread it can read data */

   233

	ReleaseSemaphore(python_wait_sem, 1, NULL);

   234

}

   235

   236

int TryLockPython(void)

   237

{

   238

	return WaitForSingleObject(python_sem, 0) == WAIT_OBJECT_0;

   239

}

   240

   241

void UnLockPython(void)

   242

{

   243

	ReleaseSemaphore(python_sem, 1, NULL);

   244

}

   245

   246

void LockPython(void)

   247

{

   248

	WaitForSingleObject(python_sem, INFINITE);

   249

}

   250

   251

int CheckRetainBuffer(void)

   252

{

   253

	return 1;

   254

}

   255

   256

void ValidateRetainBuffer(void)

   257

{

   258

}

   259

   260

void InValidateRetainBuffer(void)

   261

{

   262

}

   263

   264

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

   265

{

   266

    /*

   267

    unsigned int position;

   268

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

   269

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

   270

    }

   271

    */

   272

}

   273

   274

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

   275

{

   276

}

   277