1

/*

     2

 *  matiec - a compiler for the programming languages defined in IEC 61131-3

     3

 *

     4

 *  Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)

     5

 *  Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant

     6

 *

     7

 *  This program is free software: you can redistribute it and/or modify

     8

 *  it under the terms of the GNU General Public License as published by

     9

 *  the Free Software Foundation, either version 3 of the License, or

    10

 *  (at your option) any later version.

    11

 *

    12

 *  This program is distributed in the hope that it will be useful,

    13

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    14

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15

 *  GNU General Public License for more details.

    16

 *

    17

 *  You should have received a copy of the GNU General Public License

    18

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    19

 *

    20

 *

    21

 * This code is made available on the understanding that it will not be

    22

 * used in safety-critical situations without a full and competent review.

    23

 *

    24

 *

    25

 * Minimal standaloen C runtime, for test purpose.

    26

 * TODO : UPDATE

    27

 *

    28

 */

    29

    30

#ifdef __WIN32__

    31

#include <stdio.h>

    32

#include <sys/timeb.h>

    33

#include <time.h>

    34

#include <windows.h>

    35

#else

    36

#include <stdio.h>

    37

#include <string.h>

    38

#include <time.h>

    39

#include <signal.h>

    40

#endif

    41

    42

#include "iec_types.h"

    43

    44

/*

    45

 * Functions and variables provied by generated C softPLC

    46

 **/ 

    47

extern int common_ticktime__;

    48

    49

IEC_BOOL __DEBUG;

    50

    51

/*

    52

 * Functions and variables provied by plc.c

    53

 **/ 

    54

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

    55

    56

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

    57

    58

#ifdef __WIN32__

    59

void timer_notify()

    60

{

    61

   struct _timeb timebuffer;

    62

    63

   _ftime( &timebuffer );

    64

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

    65

}

    66

    67

int main(int argc,char **argv)

    68

{

    69

    HANDLE hTimer = NULL;

    70

    LARGE_INTEGER liDueTime;

    71

    72

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

    73

    74

    // Create a waitable timer.

    75

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

    76

    if (NULL == hTimer)

    77

    {

    78

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

    79

        return 1;

    80

    }

    81

    82

    config_init__();

    83

    84

    // Set a timer to wait for 10 seconds.

    85

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

    86

    {

    87

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

    88

        return 2;

    89

    }

    90

    91

    while(1){

    92

    // Wait for the timer.

    93

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

    94

        {

    95

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

    96

            break;

    97

        }

    98

        timer_notify();

    99

    }

   100

    return 0;

   101

}

   102

#else

   103

void timer_notify(sigval_t val)

   104

{

   105

    struct timespec CURRENT_TIME;

   106

    clock_gettime(CLOCK_REALTIME, &CURRENT_TIME);

   107

    run(CURRENT_TIME.tv_sec, CURRENT_TIME.tv_nsec);

   108

}

   109

   110

void catch_signal(int sig)

   111

{

   112

  signal(SIGTERM, catch_signal);

   113

  signal(SIGINT, catch_signal);

   114

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

   115

}

   116

   117

int main(int argc,char **argv)

   118

{

   119

    timer_t timer;

   120

    struct sigevent sigev;

   121

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

   122

    time_t tv_sec = common_ticktime__/1000;

   123

    struct itimerspec timerValues;

   124

   125

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

   126

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

   127

    sigev.sigev_value.sival_int = 0;

   128

    sigev.sigev_notify = SIGEV_THREAD;

   129

    sigev.sigev_notify_attributes = NULL;

   130

    sigev.sigev_notify_function = timer_notify;

   131

    timerValues.it_value.tv_sec = tv_sec;

   132

    timerValues.it_value.tv_nsec = tv_nsec;

   133

    timerValues.it_interval.tv_sec = tv_sec;

   134

    timerValues.it_interval.tv_nsec = tv_nsec;

   135

   136

    config_init__();

   137

   138

    timer_create (CLOCK_REALTIME, &sigev, &timer);

   139

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

   140

   141

    /* install signal handler for manual break */

   142

    signal(SIGTERM, catch_signal);

   143

    signal(SIGINT, catch_signal);

   144

   145

    pause();

   146

   147

    timer_delete (timer);

   148

   149

    return 0;

   150

}

   151

#endif