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

/*

    14

 * Functions and variables provied by generated C softPLC

    15

 **/ 

    16

extern int common_ticktime__;

    17

    18

/*

    19

 * Functions and variables provied by plc.c

    20

 **/ 

    21

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

    22

    23

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

    24

    25

#ifdef __WIN32__

    26

void timer_notify()

    27

{

    28

   struct _timeb timebuffer;

    29

    30

   _ftime( &timebuffer );

    31

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

    32

}

    33

    34

int main(int argc,char **argv)

    35

{

    36

    HANDLE hTimer = NULL;

    37

    LARGE_INTEGER liDueTime;

    38

    39

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

    40

    41

    // Create a waitable timer.

    42

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

    43

    if (NULL == hTimer)

    44

    {

    45

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

    46

        return 1;

    47

    }

    48

    49

    config_init__();

    50

    51

    // Set a timer to wait for 10 seconds.

    52

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

    53

    {

    54

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

    55

        return 2;

    56

    }

    57

    58

    while(1){

    59

    // Wait for the timer.

    60

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

    61

        {

    62

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

    63

            break;

    64

        }

    65

        timer_notify();

    66

    }

    67

    return 0;

    68

}

    69

#else

    70

void timer_notify(sigval_t val)

    71

{

    72

    struct timespec CURRENT_TIME;

    73

    clock_gettime(CLOCK_REALTIME, &CURRENT_TIME);

    74

    run(CURRENT_TIME.tv_sec, CURRENT_TIME.tv_nsec);

    75

}

    76

    77

void catch_signal(int sig)

    78

{

    79

  signal(SIGTERM, catch_signal);

    80

  signal(SIGINT, catch_signal);

    81

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

    82

}

    83

    84

int main(int argc,char **argv)

    85

{

    86

    timer_t timer;

    87

    struct sigevent sigev;

    88

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

    89

    time_t tv_sec = common_ticktime__/1000;

    90

    struct itimerspec timerValues;

    91

    92

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

    93

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

    94

    sigev.sigev_value.sival_int = 0;

    95

    sigev.sigev_notify = SIGEV_THREAD;

    96

    sigev.sigev_notify_attributes = NULL;

    97

    sigev.sigev_notify_function = timer_notify;

    98

    timerValues.it_value.tv_sec = tv_sec;

    99

    timerValues.it_value.tv_nsec = tv_nsec;

   100

    timerValues.it_interval.tv_sec = tv_sec;

   101

    timerValues.it_interval.tv_nsec = tv_nsec;

   102

   103

    config_init__();

   104

   105

    timer_create (CLOCK_REALTIME, &sigev, &timer);

   106

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

   107

   108

    /* install signal handler for manual break */

   109

    signal(SIGTERM, catch_signal);

   110

    signal(SIGINT, catch_signal);

   111

   112

    pause();

   113

   114

    timer_delete (timer);

   115

   116

    return 0;

   117

}

   118

#endif