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

HANDLE PLC_timer = NULL;

    39

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

    40

{

    41

	LARGE_INTEGER liDueTime;

    42

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

    43

	liDueTime.QuadPart =  next / (-100);

    44

    45

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

    46

    {

    47

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

    48

    }

    49

}

    50

    51

int PLC_shutdown;

    52

    53

int ForceSaveRetainReq(void) {

    54

    return PLC_shutdown;

    55

}

    56

    57

/* Variable used to stop plcloop thread */

    58

void PlcLoop()

    59

{

    60

    PLC_shutdown = 0;

    61

    while(!PLC_shutdown) {

    62

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

    63

            PLC_shutdown = 1;

    64

            break;

    65

        }

    66

        PLC_GetTime(&__CURRENT_TIME);

    67

        __run();

    68

    }

    69

}

    70

    71

HANDLE PLC_thread;

    72

HANDLE debug_sem;

    73

HANDLE debug_wait_sem;

    74

HANDLE python_sem;

    75

HANDLE python_wait_sem;

    76

    77

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

    78

int startPLC(int argc,char **argv)

    79

{

    80

	unsigned long thread_id = 0;

    81

    BOOL tmp;

    82

    83

    debug_sem = CreateSemaphore(

    84

                            NULL,           // default security attributes

    85

                            1,  			// initial count

    86

                            1,  			// maximum count

    87

                            NULL);          // unnamed semaphore

    88

    if (debug_sem == NULL)

    89

    {

    90

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

    91

        return 1;

    92

    }

    93

    94

    debug_wait_sem = CreateSemaphore(

    95

                            NULL,           // default security attributes

    96

                            0,  			// initial count

    97

                            1,  			// maximum count

    98

                            NULL);          // unnamed semaphore

    99

   100

    if (debug_wait_sem == NULL)

   101

    {

   102

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

   103

        return 1;

   104

    }

   105

   106

    python_sem = CreateSemaphore(

   107

                            NULL,           // default security attributes

   108

                            1,  			// initial count

   109

                            1,  			// maximum count

   110

                            NULL);          // unnamed semaphore

   111

   112

    if (python_sem == NULL)

   113

    {

   114

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

   115

        return 1;

   116

    }

   117

    python_wait_sem = CreateSemaphore(

   118

                            NULL,           // default security attributes

   119

                            0,  			// initial count

   120

                            1,  			// maximum count

   121

                            NULL);          // unnamed semaphore

   122

   123

   124

    if (python_wait_sem == NULL)

   125

    {

   126

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

   127

        return 1;

   128

    }

   129

   130

   131

    /* Create a waitable timer */

   132

    timeBeginPeriod(1);

   133

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

   134

    if(NULL == PLC_timer)

   135

    {

   136

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

   137

        return 1;

   138

    }

   139

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

   140

    {

   141

        PLC_SetTimer(common_ticktime__,common_ticktime__);

   142

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

   143

    }

   144

    else{

   145

        return 1;

   146

    }

   147

    return 0;

   148

}

   149

static unsigned int __debug_tick;

   150

   151

int TryEnterDebugSection(void)

   152

{

   153

	//printf("TryEnterDebugSection\n");

   154

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

   155

        /* Only enter if debug active */

   156

        if(__DEBUG){

   157

            return 1;

   158

        }

   159

        ReleaseSemaphore(debug_sem, 1, NULL);

   160

    }

   161

    return 0;

   162

}

   163

   164

void LeaveDebugSection(void)

   165

{

   166

	ReleaseSemaphore(debug_sem, 1, NULL);

   167

    //printf("LeaveDebugSection\n");

   168

}

   169

   170

int stopPLC()

   171

{

   172

   173

    PLC_shutdown = 1;

   174

    // force last wakeup of PLC thread

   175

    SetWaitableTimer(PLC_timer, 0, 0, NULL, NULL, 0);

   176

    // wait end of PLC thread

   177

    WaitForSingleObject(PLC_thread, INFINITE);

   178

   179

    __cleanup();

   180

   181

    CloseHandle(PLC_timer);

   182

    CloseHandle(debug_wait_sem);

   183

    CloseHandle(debug_sem);

   184

    CloseHandle(python_wait_sem);

   185

    CloseHandle(python_sem);

   186

    CloseHandle(PLC_thread);

   187

}

   188

   189

/* from plc_debugger.c */

   190

int WaitDebugData(unsigned int *tick)

   191

{

   192

	DWORD res;

   193

	res = WaitForSingleObject(debug_wait_sem, INFINITE);

   194

    *tick = __debug_tick;

   195

    /* Wait signal from PLC thread */

   196

	return res != WAIT_OBJECT_0;

   197

}

   198

   199

/* Called by PLC thread when debug_publish finished

   200

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

   201

void InitiateDebugTransfer()

   202

{

   203

    /* remember tick */

   204

    __debug_tick = __tick;

   205

    /* signal debugger thread it can read data */

   206

    ReleaseSemaphore(debug_wait_sem, 1, NULL);

   207

}

   208

   209

int suspendDebug(int disable)

   210

{

   211

    /* Prevent PLC to enter debug code */

   212

    WaitForSingleObject(debug_sem, INFINITE);

   213

    __DEBUG = !disable;

   214

    if(disable)

   215

        ReleaseSemaphore(debug_sem, 1, NULL);

   216

    return 0;

   217

}

   218

   219

void resumeDebug()

   220

{

   221

	__DEBUG = 1;

   222

    /* Let PLC enter debug code */

   223

	ReleaseSemaphore(debug_sem, 1, NULL);

   224

}

   225

   226

/* from plc_python.c */

   227

int WaitPythonCommands(void)

   228

{

   229

    /* Wait signal from PLC thread */

   230

	return WaitForSingleObject(python_wait_sem, INFINITE);

   231

}

   232

   233

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

   234

void UnBlockPythonCommands(void)

   235

{

   236

    /* signal debugger thread it can read data */

   237

	ReleaseSemaphore(python_wait_sem, 1, NULL);

   238

}

   239

   240

int TryLockPython(void)

   241

{

   242

	return WaitForSingleObject(python_sem, 0) == WAIT_OBJECT_0;

   243

}

   244

   245

void UnLockPython(void)

   246

{

   247

	ReleaseSemaphore(python_sem, 1, NULL);

   248

}

   249

   250

void LockPython(void)

   251

{

   252

	WaitForSingleObject(python_sem, INFINITE);

   253

}

   254

   255

static void __attribute__((constructor))

   256

beremiz_dll_init(void)

   257

{

   258

    InitializeCriticalSection(&Atomic64CS);

   259

   260

}

   261

   262

static void __attribute__((destructor))

   263

beremiz_dll_destroy(void)

   264

{

   265

    DeleteCriticalSection(&Atomic64CS);

   266

}

   267

   268

struct RT_to_nRT_signal_s {

   269

    HANDLE sem;

   270

};

   271

   272

typedef struct RT_to_nRT_signal_s RT_to_nRT_signal_t;

   273

   274

#define _LogAndReturnNull(text) \

   275

    {\

   276

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

   277

        strncat(mstr, name, 255);\

   278

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

   279

        return NULL;\

   280

    }

   281

   282

void *create_RT_to_nRT_signal(char* name){

   283

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

   284

   285

    if(!sig) 

   286

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

   287

   288

    sig->sem = CreateSemaphore(

   289

                            NULL,           // default security attributes

   290

                            1,  			// initial count

   291

                            1,  			// maximum count

   292

                            NULL);          // unnamed semaphore

   293

   294

    if(sig->sem == NULL)

   295

    {

   296

    	char mstr[256];

   297

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

   298

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

   299

        return NULL;

   300

    }

   301

   302

    return (void*)sig;

   303

}

   304

   305

void delete_RT_to_nRT_signal(void* handle){

   306

    RT_to_nRT_signal_t *sig = (RT_to_nRT_signal_t*)handle;

   307

   308

    CloseHandle(python_sem);

   309

   310

    free(sig);

   311

}

   312

   313

int wait_RT_to_nRT_signal(void* handle){

   314

    int ret;

   315

    RT_to_nRT_signal_t *sig = (RT_to_nRT_signal_t*)handle;

   316

	return WaitForSingleObject(sig->sem, INFINITE);

   317

}

   318

   319

int unblock_RT_to_nRT_signal(void* handle){

   320

    RT_to_nRT_signal_t *sig = (RT_to_nRT_signal_t*)handle;

   321

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

   322

}

   323

   324

void nRT_reschedule(void){

   325

    SwitchToThread();

   326

}

   327