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

    setlocale(LC_NUMERIC, "C");

    86

    87

    debug_sem = CreateSemaphore(

    88

                            NULL,           // default security attributes

    89

                            1,  			// initial count

    90

                            1,  			// maximum count

    91

                            NULL);          // unnamed semaphore

    92

    if (debug_sem == NULL)

    93

    {

    94

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

    95

        return 1;

    96

    }

    97

    98

    debug_wait_sem = CreateSemaphore(

    99

                            NULL,           // default security attributes

   100

                            0,  			// initial count

   101

                            1,  			// maximum count

   102

                            NULL);          // unnamed semaphore

   103

   104

    if (debug_wait_sem == NULL)

   105

    {

   106

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

   107

        return 1;

   108

    }

   109

   110

    python_sem = CreateSemaphore(

   111

                            NULL,           // default security attributes

   112

                            1,  			// initial count

   113

                            1,  			// maximum count

   114

                            NULL);          // unnamed semaphore

   115

   116

    if (python_sem == NULL)

   117

    {

   118

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

   119

        return 1;

   120

    }

   121

    python_wait_sem = CreateSemaphore(

   122

                            NULL,           // default security attributes

   123

                            0,  			// initial count

   124

                            1,  			// maximum count

   125

                            NULL);          // unnamed semaphore

   126

   127

   128

    if (python_wait_sem == NULL)

   129

    {

   130

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

   131

        return 1;

   132

    }

   133

   134

   135

    /* Create a waitable timer */

   136

    timeBeginPeriod(1);

   137

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

   138

    if(NULL == PLC_timer)

   139

    {

   140

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

   141

        return 1;

   142

    }

   143

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

   144

    {

   145

        PLC_SetTimer(common_ticktime__,common_ticktime__);

   146

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

   147

    }

   148

    else{

   149

        return 1;

   150

    }

   151

    return 0;

   152

}

   153

static unsigned long __debug_tick;

   154

   155

int TryEnterDebugSection(void)

   156

{

   157

	//printf("TryEnterDebugSection\n");

   158

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

   159

        /* Only enter if debug active */

   160

        if(__DEBUG){

   161

            return 1;

   162

        }

   163

        ReleaseSemaphore(debug_sem, 1, NULL);

   164

    }

   165

    return 0;

   166

}

   167

   168

void LeaveDebugSection(void)

   169

{

   170

	ReleaseSemaphore(debug_sem, 1, NULL);

   171

    //printf("LeaveDebugSection\n");

   172

}

   173

   174

int stopPLC()

   175

{

   176

    CloseHandle(PLC_timer);

   177

    WaitForSingleObject(PLC_thread, INFINITE);

   178

    __cleanup();

   179

    CloseHandle(debug_wait_sem);

   180

    CloseHandle(debug_sem);

   181

    CloseHandle(python_wait_sem);

   182

    CloseHandle(python_sem);

   183

    CloseHandle(PLC_thread);

   184

}

   185

   186

/* from plc_debugger.c */

   187

int WaitDebugData(unsigned long *tick)

   188

{

   189

	DWORD res;

   190

	res = WaitForSingleObject(debug_wait_sem, INFINITE);

   191

    *tick = __debug_tick;

   192

    /* Wait signal from PLC thread */

   193

	return res != WAIT_OBJECT_0;

   194

}

   195

   196

/* Called by PLC thread when debug_publish finished

   197

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

   198

void InitiateDebugTransfer()

   199

{

   200

    /* remember tick */

   201

    __debug_tick = __tick;

   202

    /* signal debugger thread it can read data */

   203

    ReleaseSemaphore(debug_wait_sem, 1, NULL);

   204

}

   205

   206

int suspendDebug(int disable)

   207

{

   208

    /* Prevent PLC to enter debug code */

   209

    WaitForSingleObject(debug_sem, INFINITE);

   210

    __DEBUG = !disable;

   211

    if(disable)

   212

        ReleaseSemaphore(debug_sem, 1, NULL);

   213

    return 0;

   214

}

   215

   216

void resumeDebug()

   217

{

   218

	__DEBUG = 1;

   219

    /* Let PLC enter debug code */

   220

	ReleaseSemaphore(debug_sem, 1, NULL);

   221

}

   222

   223

/* from plc_python.c */

   224

int WaitPythonCommands(void)

   225

{

   226

    /* Wait signal from PLC thread */

   227

	return WaitForSingleObject(python_wait_sem, INFINITE);

   228

}

   229

   230

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

   231

void UnBlockPythonCommands(void)

   232

{

   233

    /* signal debugger thread it can read data */

   234

	ReleaseSemaphore(python_wait_sem, 1, NULL);

   235

}

   236

   237

int TryLockPython(void)

   238

{

   239

	return WaitForSingleObject(python_sem, 0) == WAIT_OBJECT_0;

   240

}

   241

   242

void UnLockPython(void)

   243

{

   244

	ReleaseSemaphore(python_sem, 1, NULL);

   245

}

   246

   247

void LockPython(void)

   248

{

   249

	WaitForSingleObject(python_sem, INFINITE);

   250

}

   251

   252

static void __attribute__((constructor))

   253

beremiz_dll_init(void)

   254

{

   255

    InitializeCriticalSection(&Atomic64CS);

   256

   257

}

   258

   259

static void __attribute__((destructor))

   260

beremiz_dll_destroy(void)

   261

{

   262

    DeleteCriticalSection(&Atomic64CS);

   263

}

   264

   265

struct RT_to_nRT_signal_s {

   266

    HANDLE sem;

   267

};

   268

   269

typedef struct RT_to_nRT_signal_s RT_to_nRT_signal_t;

   270

   271

#define _LogAndReturnNull(text) \

   272

    {\

   273

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

   274

        strncat(mstr, name, 255);\

   275

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

   276

        return NULL;\

   277

    }

   278

   279

void *create_RT_to_nRT_signal(char* name){

   280

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

   281

   282

    if(!sig) 

   283

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

   284

   285

    sig->sem = CreateSemaphore(

   286

                            NULL,           // default security attributes

   287

                            1,  			// initial count

   288

                            1,  			// maximum count

   289

                            NULL);          // unnamed semaphore

   290

   291

    if(sig->sem == NULL)

   292

    {

   293

    	char mstr[256];

   294

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

   295

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

   296

        return NULL;

   297

    }

   298

   299

    return (void*)sig;

   300

}

   301

   302

void delete_RT_to_nRT_signal(void* handle){

   303

    RT_to_nRT_signal_t *sig = (RT_to_nRT_signal_t*)handle;

   304

   305

    CloseHandle(python_sem);

   306

   307

    free(sig);

   308

}

   309

   310

int wait_RT_to_nRT_signal(void* handle){

   311

    int ret;

   312

    RT_to_nRT_signal_t *sig = (RT_to_nRT_signal_t*)handle;

   313

	return WaitForSingleObject(sig->sem, INFINITE);

   314

}

   315

   316

int unblock_RT_to_nRT_signal(void* handle){

   317

    RT_to_nRT_signal_t *sig = (RT_to_nRT_signal_t*)handle;

   318

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

   319

}

   320

   321

void nRT_reschedule(void){

   322

    SwitchToThread();

   323

}

   324