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

    12

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

    13

{

    14

    return InterlockedCompareExchange(atomicvar, exchange, compared);

    15

}

    16

CRITICAL_SECTION Atomic64CS; 

    17

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

    18

{

    19

    long long res;

    20

    EnterCriticalSection(&Atomic64CS);

    21

    res=*atomicvar;

    22

    if(*atomicvar == compared){

    23

        *atomicvar = exchange;

    24

    }

    25

    LeaveCriticalSection(&Atomic64CS);

    26

    return res;

    27

}

    28

    29

struct _timeb timetmp;

    30

void PLC_GetTime(IEC_TIME *CURRENT_TIME)

    31

{

    32

	_ftime(&timetmp);

    33

    34

	(*CURRENT_TIME).tv_sec = timetmp.time;

    35

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

    36

}

    37

    38

void PLC_timer_notify()

    39

{

    40

    PLC_GetTime(&__CURRENT_TIME);

    41

    __run();

    42

}

    43

    44

HANDLE PLC_timer = NULL;

    45

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

    46

{

    47

	LARGE_INTEGER liDueTime;

    48

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

    49

	liDueTime.QuadPart =  next / (-100);

    50

    51

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

    52

    {

    53

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

    54

    }

    55

}

    56

    57

/* Variable used to stop plcloop thread */

    58

void PlcLoop()

    59

{

    60

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

    61

    {

    62

        PLC_timer_notify();

    63

    }

    64

}

    65

    66

HANDLE PLC_thread;

    67

HANDLE debug_sem;

    68

HANDLE debug_wait_sem;

    69

HANDLE python_sem;

    70

HANDLE python_wait_sem;

    71

    72

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

    73

int startPLC(int argc,char **argv)

    74

{

    75

	unsigned long thread_id = 0;

    76

    BOOL tmp;

    77

    setlocale(LC_NUMERIC, "C");

    78

    79

    InitializeCriticalSection(&Atomic64CS);

    80

    81

    debug_sem = CreateSemaphore(

    82

                            NULL,           // default security attributes

    83

                            1,  			// initial count

    84

                            1,  			// maximum count

    85

                            NULL);          // unnamed semaphore

    86

    if (debug_sem == NULL)

    87

    {

    88

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

    89

        return;

    90

    }

    91

    92

    debug_wait_sem = CreateSemaphore(

    93

                            NULL,           // default security attributes

    94

                            0,  			// initial count

    95

                            1,  			// maximum count

    96

                            NULL);          // unnamed semaphore

    97

    98

    if (debug_wait_sem == NULL)

    99

    {

   100

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

   101

        return;

   102

    }

   103

   104

    python_sem = CreateSemaphore(

   105

                            NULL,           // default security attributes

   106

                            1,  			// initial count

   107

                            1,  			// maximum count

   108

                            NULL);          // unnamed semaphore

   109

   110

    if (python_sem == NULL)

   111

    {

   112

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

   113

        return;

   114

    }

   115

    python_wait_sem = CreateSemaphore(

   116

                            NULL,           // default security attributes

   117

                            0,  			// initial count

   118

                            1,  			// maximum count

   119

                            NULL);          // unnamed semaphore

   120

   121

   122

    if (python_wait_sem == NULL)

   123

    {

   124

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

   125

        return;

   126

    }

   127

   128

   129

    /* Create a waitable timer */

   130

    timeBeginPeriod(1);

   131

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

   132

    if(NULL == PLC_timer)

   133

    {

   134

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

   135

        return 1;

   136

    }

   137

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

   138

    {

   139

        PLC_SetTimer(common_ticktime__,common_ticktime__);

   140

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

   141

    }

   142

    else{

   143

        return 1;

   144

    }

   145

    return 0;

   146

}

   147

static unsigned long __debug_tick;

   148

   149

int TryEnterDebugSection(void)

   150

{

   151

	//printf("TryEnterDebugSection\n");

   152

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

   153

        /* Only enter if debug active */

   154

        if(__DEBUG){

   155

            return 1;

   156

        }

   157

        ReleaseSemaphore(debug_sem, 1, NULL);

   158

    }

   159

    return 0;

   160

}

   161

   162

void LeaveDebugSection(void)

   163

{

   164

	ReleaseSemaphore(debug_sem, 1, NULL);

   165

    //printf("LeaveDebugSection\n");

   166

}

   167

   168

int stopPLC()

   169

{

   170

    CloseHandle(PLC_timer);

   171

    WaitForSingleObject(PLC_thread, INFINITE);

   172

    __cleanup();

   173

    DeleteCriticalSection(&Atomic64CS);

   174

    CloseHandle(debug_wait_sem);

   175

    CloseHandle(debug_sem);

   176

    CloseHandle(python_wait_sem);

   177

    CloseHandle(python_sem);

   178

    CloseHandle(PLC_thread);

   179

}

   180

   181

/* from plc_debugger.c */

   182

int WaitDebugData(unsigned long *tick)

   183

{

   184

	DWORD res;

   185

	res = WaitForSingleObject(debug_wait_sem, INFINITE);

   186

    *tick = __debug_tick;

   187

    /* Wait signal from PLC thread */

   188

	return res != WAIT_OBJECT_0;

   189

}

   190

   191

/* Called by PLC thread when debug_publish finished

   192

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

   193

void InitiateDebugTransfer()

   194

{

   195

    /* remember tick */

   196

    __debug_tick = __tick;

   197

    /* signal debugger thread it can read data */

   198

    ReleaseSemaphore(debug_wait_sem, 1, NULL);

   199

}

   200

   201

int suspendDebug(int disable)

   202

{

   203

    /* Prevent PLC to enter debug code */

   204

    WaitForSingleObject(debug_sem, INFINITE);

   205

    __DEBUG = !disable;

   206

    if(disable)

   207

        ReleaseSemaphore(debug_sem, 1, NULL);

   208

    return 0;

   209

}

   210

   211

void resumeDebug()

   212

{

   213

	__DEBUG = 1;

   214

    /* Let PLC enter debug code */

   215

	ReleaseSemaphore(debug_sem, 1, NULL);

   216

}

   217

   218

/* from plc_python.c */

   219

int WaitPythonCommands(void)

   220

{

   221

    /* Wait signal from PLC thread */

   222

	return WaitForSingleObject(python_wait_sem, INFINITE);

   223

}

   224

   225

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

   226

void UnBlockPythonCommands(void)

   227

{

   228

    /* signal debugger thread it can read data */

   229

	ReleaseSemaphore(python_wait_sem, 1, NULL);

   230

}

   231

   232

int TryLockPython(void)

   233

{

   234

	return WaitForSingleObject(python_sem, 0) == WAIT_OBJECT_0;

   235

}

   236

   237

void UnLockPython(void)

   238

{

   239

	ReleaseSemaphore(python_sem, 1, NULL);

   240

}

   241

   242

void LockPython(void)

   243

{

   244

	WaitForSingleObject(python_sem, INFINITE);

   245

}

   246

   247

int CheckRetainBuffer(void)

   248

{

   249

	return 1;

   250

}

   251

   252

void ValidateRetainBuffer(void)

   253

{

   254

}

   255

   256

void InValidateRetainBuffer(void)

   257

{

   258

}

   259

   260

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

   261

{

   262

    /*

   263

    unsigned int position;

   264

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

   265

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

   266

    }

   267

    */

   268

}

   269

   270

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

   271

{

   272

}

   273