1

#ifdef __WIN32__

     2

#include <stdio.h>

     3

#include <sys/timeb.h>

     4

#include <time.h>

     5

#include <windows.h>

     6

#else

     7

#include <stdio.h>

     8

#include <string.h>

     9

#include <time.h>

    10

#include <signal.h>

    11

#endif

    12

    13

#include "iec_types.h"

    14

    15

/*

    16

 * Functions and variables provied by generated C softPLC

    17

 **/ 

    18

extern int common_ticktime__;

    19

    20

IEC_BOOL __DEBUG;

    21

    22

/*

    23

 * Functions and variables provied by plc.c

    24

 **/ 

    25

void run(long int tv_sec, long int tv_nsec);

    26

    27

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

    28

    29

#ifdef __WIN32__

    30

void timer_notify()

    31

{

    32

   struct _timeb timebuffer;

    33

    34

   _ftime( &timebuffer );

    35

   run(timebuffer.time, timebuffer.millitm * 1000000);

    36

}

    37

    38

int main(int argc,char **argv)

    39

{

    40

    HANDLE hTimer = NULL;

    41

    LARGE_INTEGER liDueTime;

    42

    43

    liDueTime.QuadPart = -10000 * maxval(common_ticktime__,1);;

    44

    45

    // Create a waitable timer.

    46

    hTimer = CreateWaitableTimer(NULL, TRUE, "WaitableTimer");

    47

    if (NULL == hTimer)

    48

    {

    49

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

    50

        return 1;

    51

    }

    52

    53

    config_init__();

    54

    55

    // Set a timer to wait for 10 seconds.

    56

    if (!SetWaitableTimer(hTimer, &liDueTime, common_ticktime__, NULL, NULL, 0))

    57

    {

    58

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

    59

        return 2;

    60

    }

    61

    62

    while(1){

    63

    // Wait for the timer.

    64

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

    65

        {

    66

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

    67

            break;

    68

        }

    69

        timer_notify();

    70

    }

    71

    return 0;

    72

}

    73

#else

    74

void timer_notify(sigval_t val)

    75

{

    76

    struct timespec CURRENT_TIME;

    77

    clock_gettime(CLOCK_REALTIME, &CURRENT_TIME);

    78

    run(CURRENT_TIME.tv_sec, CURRENT_TIME.tv_nsec);

    79

}

    80

    81

void catch_signal(int sig)

    82

{

    83

  signal(SIGTERM, catch_signal);

    84

  signal(SIGINT, catch_signal);

    85

  printf("Got Signal %d\n",sig);

    86

}

    87

    88

int main(int argc,char **argv)

    89

{

    90

    timer_t timer;

    91

    struct sigevent sigev;

    92

    long tv_nsec = 1000000 * (maxval(common_ticktime__,1)%1000);

    93

    time_t tv_sec = common_ticktime__/1000;

    94

    struct itimerspec timerValues;

    95

    96

    memset (&sigev, 0, sizeof (struct sigevent));

    97

    memset (&timerValues, 0, sizeof (struct itimerspec));

    98

    sigev.sigev_value.sival_int = 0;

    99

    sigev.sigev_notify = SIGEV_THREAD;

   100

    sigev.sigev_notify_attributes = NULL;

   101

    sigev.sigev_notify_function = timer_notify;

   102

    timerValues.it_value.tv_sec = tv_sec;

   103

    timerValues.it_value.tv_nsec = tv_nsec;

   104

    timerValues.it_interval.tv_sec = tv_sec;

   105

    timerValues.it_interval.tv_nsec = tv_nsec;

   106

   107

    config_init__();

   108

   109

    timer_create (CLOCK_REALTIME, &sigev, &timer);

   110

    timer_settime (timer, 0, &timerValues, NULL);

   111

   112

    /* install signal handler for manual break */

   113

    signal(SIGTERM, catch_signal);

   114

    signal(SIGINT, catch_signal);

   115

   116

    pause();

   117

   118

    timer_delete (timer);

   119

   120

    return 0;

   121

}

   122

#endif