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

    debug_sem = CreateSemaphore(

    80

                            NULL,           // default security attributes

    81

                            1,  			// initial count

    82

                            1,  			// maximum count

    83

                            NULL);          // unnamed semaphore

    84

    if (debug_sem == NULL)

    85

    {

    86

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

    87

        return;

    88

    }

    89

    90

    debug_wait_sem = CreateSemaphore(

    91

                            NULL,           // default security attributes

    92

                            0,  			// initial count

    93

                            1,  			// maximum count

    94

                            NULL);          // unnamed semaphore

    95

    96

    if (debug_wait_sem == NULL)

    97

    {

    98

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

    99

        return;

   100

    }

   101

   102

    python_sem = CreateSemaphore(

   103

                            NULL,           // default security attributes

   104

                            1,  			// initial count

   105

                            1,  			// maximum count

   106

                            NULL);          // unnamed semaphore

   107

   108

    if (python_sem == NULL)

   109

    {

   110

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

   111

        return;

   112

    }

   113

    python_wait_sem = CreateSemaphore(

   114

                            NULL,           // default security attributes

   115

                            0,  			// initial count

   116

                            1,  			// maximum count

   117

                            NULL);          // unnamed semaphore

   118

   119

   120

    if (python_wait_sem == NULL)

   121

    {

   122

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

   123

        return;

   124

    }

   125

   126

   127

    /* Create a waitable timer */

   128

    timeBeginPeriod(1);

   129

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

   130

    if(NULL == PLC_timer)

   131

    {

   132

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

   133

        return 1;

   134

    }

   135

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

   136

    {

   137

        PLC_SetTimer(common_ticktime__,common_ticktime__);

   138

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

   139

    }

   140

    else{

   141

        return 1;

   142

    }

   143

    return 0;

   144

}

   145

static unsigned long __debug_tick;

   146

   147

int TryEnterDebugSection(void)

   148

{

   149

	//printf("TryEnterDebugSection\n");

   150

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

   151

        /* Only enter if debug active */

   152

        if(__DEBUG){

   153

            return 1;

   154

        }

   155

        ReleaseSemaphore(debug_sem, 1, NULL);

   156

    }

   157

    return 0;

   158

}

   159

   160

void LeaveDebugSection(void)

   161

{

   162

	ReleaseSemaphore(debug_sem, 1, NULL);

   163

    //printf("LeaveDebugSection\n");

   164

}

   165

   166

int stopPLC()

   167

{

   168

    CloseHandle(PLC_timer);

   169

    WaitForSingleObject(PLC_thread, INFINITE);

   170

    __cleanup();

   171

    CloseHandle(debug_wait_sem);

   172

    CloseHandle(debug_sem);

   173

    CloseHandle(python_wait_sem);

   174

    CloseHandle(python_sem);

   175

    CloseHandle(PLC_thread);

   176

}

   177

   178

/* from plc_debugger.c */

   179

int WaitDebugData(unsigned long *tick)

   180

{

   181

	DWORD res;

   182

	res = WaitForSingleObject(debug_wait_sem, INFINITE);

   183

    *tick = __debug_tick;

   184

    /* Wait signal from PLC thread */

   185

	return res != WAIT_OBJECT_0;

   186

}

   187

   188

/* Called by PLC thread when debug_publish finished

   189

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

   190

void InitiateDebugTransfer()

   191

{

   192

    /* remember tick */

   193

    __debug_tick = __tick;

   194

    /* signal debugger thread it can read data */

   195

    ReleaseSemaphore(debug_wait_sem, 1, NULL);

   196

}

   197

   198

int suspendDebug(int disable)

   199

{

   200

    /* Prevent PLC to enter debug code */

   201

    WaitForSingleObject(debug_sem, INFINITE);

   202

    __DEBUG = !disable;

   203

    if(disable)

   204

        ReleaseSemaphore(debug_sem, 1, NULL);

   205

    return 0;

   206

}

   207

   208

void resumeDebug()

   209

{

   210

	__DEBUG = 1;

   211

    /* Let PLC enter debug code */

   212

	ReleaseSemaphore(debug_sem, 1, NULL);

   213

}

   214

   215

/* from plc_python.c */

   216

int WaitPythonCommands(void)

   217

{

   218

    /* Wait signal from PLC thread */

   219

	return WaitForSingleObject(python_wait_sem, INFINITE);

   220

}

   221

   222

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

   223

void UnBlockPythonCommands(void)

   224

{

   225

    /* signal debugger thread it can read data */

   226

	ReleaseSemaphore(python_wait_sem, 1, NULL);

   227

}

   228

   229

int TryLockPython(void)

   230

{

   231

	return WaitForSingleObject(python_sem, 0) == WAIT_OBJECT_0;

   232

}

   233

   234

void UnLockPython(void)

   235

{

   236

	ReleaseSemaphore(python_sem, 1, NULL);

   237

}

   238

   239

void LockPython(void)

   240

{

   241

	WaitForSingleObject(python_sem, INFINITE);

   242

}

   243

   244

void InitRetain(void)

   245

{

   246

}

   247

   248

void CleanupRetain(void)

   249

{

   250

}

   251

   252

int CheckRetainBuffer(void)

   253

{

   254

	return 1;

   255

}

   256

   257

void ValidateRetainBuffer(void)

   258

{

   259

}

   260

   261

void InValidateRetainBuffer(void)

   262

{

   263

}

   264

   265

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

   266

{

   267

    /*

   268

    unsigned int position;

   269

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

   270

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

   271

    }

   272

    */

   273

}

   274

   275

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

   276

{

   277

}

   278

   279

static void __attribute__((constructor))

   280

beremiz_dll_init(void)

   281

{

   282

    InitializeCriticalSection(&Atomic64CS);

   283

   284

}

   285

   286

static void __attribute__((destructor))

   287

beremiz_dll_destroy(void)

   288

{

   289

    DeleteCriticalSection(&Atomic64CS);

   290

}

   291