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

int PLC_shutdown;

    58

    59

int ForceSaveRetainReq(void) {

    60

    return PLC_shutdown;

    61

}

    62

    63

/* Variable used to stop plcloop thread */

    64

void PlcLoop()

    65

{

    66

    PLC_shutdown = 0;

    67

    while(!PLC_shutdown) {

    68

        if (WaitForSingleObject(PLC_timer, INFINITE) != WAIT_OBJECT_0)

    69

            PLC_shutdown = 1;

    70

        PLC_timer_notify();

    71

    }

    72

}

    73

    74

HANDLE PLC_thread;

    75

HANDLE debug_sem;

    76

HANDLE debug_wait_sem;

    77

HANDLE python_sem;

    78

HANDLE python_wait_sem;

    79

    80

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

    81

int startPLC(int argc,char **argv)

    82

{

    83

	unsigned long thread_id = 0;

    84

    BOOL tmp;

    85

    86

    debug_sem = CreateSemaphore(

    87

                            NULL,           // default security attributes

    88

                            1,  			// initial count

    89

                            1,  			// maximum count

    90

                            NULL);          // unnamed semaphore

    91

    if (debug_sem == NULL)

    92

    {

    93

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

    94

        return 1;

    95

    }

    96

    97

    debug_wait_sem = CreateSemaphore(

    98

                            NULL,           // default security attributes

    99

                            0,  			// initial count

   100

                            1,  			// maximum count

   101

                            NULL);          // unnamed semaphore

   102

   103

    if (debug_wait_sem == NULL)

   104

    {

   105

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

   106

        return 1;

   107

    }

   108

   109

    python_sem = CreateSemaphore(

   110

                            NULL,           // default security attributes

   111

                            1,  			// initial count

   112

                            1,  			// maximum count

   113

                            NULL);          // unnamed semaphore

   114

   115

    if (python_sem == NULL)

   116

    {

   117

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

   118

        return 1;

   119

    }

   120

    python_wait_sem = CreateSemaphore(

   121

                            NULL,           // default security attributes

   122

                            0,  			// initial count

   123

                            1,  			// maximum count

   124

                            NULL);          // unnamed semaphore

   125

   126

   127

    if (python_wait_sem == NULL)

   128

    {

   129

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

   130

        return 1;

   131

    }

   132

   133

   134

    /* Create a waitable timer */

   135

    timeBeginPeriod(1);

   136

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

   137

    if(NULL == PLC_timer)

   138

    {

   139

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

   140

        return 1;

   141

    }

   142

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

   143

    {

   144

        PLC_SetTimer(common_ticktime__,common_ticktime__);

   145

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

   146

    }

   147

    else{

   148

        return 1;

   149

    }

   150

    return 0;

   151

}

   152

static unsigned long __debug_tick;

   153

   154

int TryEnterDebugSection(void)

   155

{

   156

	//printf("TryEnterDebugSection\n");

   157

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

   158

        /* Only enter if debug active */

   159

        if(__DEBUG){

   160

            return 1;

   161

        }

   162

        ReleaseSemaphore(debug_sem, 1, NULL);

   163

    }

   164

    return 0;

   165

}

   166

   167

void LeaveDebugSection(void)

   168

{

   169

	ReleaseSemaphore(debug_sem, 1, NULL);

   170

    //printf("LeaveDebugSection\n");

   171

}

   172

   173

int stopPLC()

   174

{

   175

    CloseHandle(PLC_timer);

   176

    WaitForSingleObject(PLC_thread, INFINITE);

   177

    __cleanup();

   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

static void __attribute__((constructor))

   252

beremiz_dll_init(void)

   253

{

   254

    InitializeCriticalSection(&Atomic64CS);

   255

   256

}

   257

   258

static void __attribute__((destructor))

   259

beremiz_dll_destroy(void)

   260

{

   261

    DeleteCriticalSection(&Atomic64CS);

   262

}

   263

   264

struct RT_to_nRT_signal_s {

   265

    HANDLE sem;

   266

};

   267

   268

typedef struct RT_to_nRT_signal_s RT_to_nRT_signal_t;

   269

   270

#define _LogAndReturnNull(text) \

   271

    {\

   272

    	char mstr[256] = text " for ";\

   273

        strncat(mstr, name, 255);\

   274

        LogMessage(LOG_CRITICAL, mstr, strlen(mstr));\

   275

        return NULL;\

   276

    }

   277

   278

void *create_RT_to_nRT_signal(char* name){

   279

    RT_to_nRT_signal_t *sig = (RT_to_nRT_signal_t*)malloc(sizeof(RT_to_nRT_signal_t));

   280

   281

    if(!sig) 

   282

    	_LogAndReturnNull("Failed allocating memory for RT_to_nRT signal");

   283

   284

    sig->sem = CreateSemaphore(

   285

                            NULL,           // default security attributes

   286

                            1,  			// initial count

   287

                            1,  			// maximum count

   288

                            NULL);          // unnamed semaphore

   289

   290

    if(sig->sem == NULL)

   291

    {

   292

    	char mstr[256];

   293

        snprintf(mstr, 255, "startPLC CreateSemaphore %s error: %d\n", name, GetLastError());

   294

        LogMessage(LOG_CRITICAL, mstr, strlen(mstr));

   295

        return NULL;

   296

    }

   297

   298

    return (void*)sig;

   299

}

   300

   301

void delete_RT_to_nRT_signal(void* handle){

   302

    RT_to_nRT_signal_t *sig = (RT_to_nRT_signal_t*)handle;

   303

   304

    CloseHandle(python_sem);

   305

   306

    free(sig);

   307

}

   308

   309

int wait_RT_to_nRT_signal(void* handle){

   310

    int ret;

   311

    RT_to_nRT_signal_t *sig = (RT_to_nRT_signal_t*)handle;

   312

	return WaitForSingleObject(sig->sem, INFINITE);

   313

}

   314

   315

int unblock_RT_to_nRT_signal(void* handle){

   316

    RT_to_nRT_signal_t *sig = (RT_to_nRT_signal_t*)handle;

   317

	return ReleaseSemaphore(sig->sem, 1, NULL);

   318

}

   319

   320

void nRT_reschedule(void){

   321

    SwitchToThread();

   322

}

   323