1

/**

     2

 * Code common to all C targets

     4

     6

#include "iec_types.h"

     7

/*

     8

 * Prototypes of functions provied by generated C softPLC

    10

void config_run__(int tick);

    11

void config_init__(void);

    12

    13

/*

    14

 * Prototypes of functions provied by generated target C code

    15

 * */

    16

void __init_debug(void);

    17

void __cleanup_debug(void);

    18

/*void __retrieve_debug(void);*/

    19

void __publish_debug(void);

    20

    21

void __init_python(void);

    22

void __cleanup_python(void);

    23

void __retrieve_python(void);

    24

void __publish_python(void);

    25

    26

/*

    27

 *  Variables used by generated C softPLC and plugins

    28

 **/

    29

IEC_TIME __CURRENT_TIME;

    30

IEC_BOOL __DEBUG;

    31

int __tick = -1;

    32

    33

/* Help to quit cleanly when init fail at a certain level */

    34

static int init_level = 0;

    35

    36

/*

    38

 **/

    39

%(calls_prototypes)s

    40

    41

/*

    43

 **/

    44

void __run()

    45

{

    46

    __tick++;

    47

    48

    %(retrieve_calls)s

    49

    50

    __retrieve_python();

    51

    52

    /*__retrieve_debug();*/

    54

    config_run__(__tick);

    55

    56

    __publish_python();

    57

    58

    __publish_debug();

    60

    %(publish_calls)s

    61

    62

}

    63

    64

/*

    65

 * Initialize variables according to PLC's defalut values,

    67

 **/

    68

int __init(int argc,char **argv)

    69

{

    70

    int res;

    72

    config_init__();

    73

    __init_debug();

    74

    __init_python();

    75

    %(init_calls)s

    76

    return 0;

    77

}

    78

/*

    79

 * Calls plugin cleanup proc.

    80

 **/

    81

void __cleanup()

    82

{

    83

    %(cleanup_calls)s

    84

    __cleanup_debug();

    85

    __cleanup_python();

    86

}

    87

    88

    89

void PLC_GetTime(IEC_TIME *CURRENT_TIME);

    90

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

    91

    92

#define CALIBRATED -2

    93

#define NOT_CALIBRATED -1

    94

static int calibration_count = NOT_CALIBRATED;

    95

static IEC_TIME cal_begin;

    96

static long long Tsync = 0;

    97

static long long FreqCorr = 0;

    98

static int Nticks = 0;

    99

static int  last_tick = 0;

   100

static long long Ttick = 0;

   101

#define mod %%

   102

/*

   105

 **/

   106

void align_tick(int sync_align_ratio)

   107

{

   108

	/*

   109

	printf("align_tick(%%d)\n", calibrate);

   110

	*/

   111

	if(sync_align_ratio < 0){ /* Calibration */

   112

		if(calibration_count == CALIBRATED)

   113

			/* Re-calibration*/

   114

			calibration_count = NOT_CALIBRATED;

   115

		if(calibration_count == NOT_CALIBRATED)

   116

			/* Calibration start, get time*/

   117

			PLC_GetTime(&cal_begin);

   118

		calibration_count++;

   119

	}else{ /* do alignment (if possible) */

   120

		if(calibration_count >= 0){

   121

			/* End of calibration */

   122

			/* Get final time */

   123

			IEC_TIME cal_end;

   124

			PLC_GetTime(&cal_end);

   125

			/*adjust calibration_count*/

   126

			calibration_count++;

   128

			Tsync = ((long long)(cal_end.tv_sec - cal_begin.tv_sec) * (long long)1000000000 +

   129

					(cal_end.tv_nsec - cal_begin.tv_nsec)) / calibration_count;

   130

			if( (Nticks = (Tsync / Ttick)) > 0){

   131

				FreqCorr = (Tsync mod Ttick); /* to be divided by Nticks */

   132

			}else{

   133

				FreqCorr = Tsync - (Ttick mod Tsync);

   134

			}

   135

			/*

   136

			printf("Tsync = %%ld\n", Tsync);

   137

			printf("calibration_count = %%d\n", calibration_count);

   138

			printf("Nticks = %%d\n", Nticks);

   139

			*/

   140

			calibration_count = CALIBRATED;

   141

		}

   142

		if(calibration_count == CALIBRATED){

   143

			/* Get Elapsed time since last PLC tick (__CURRENT_TIME) */

   144

			IEC_TIME now;

   145

			long long elapsed;

   146

			long long Tcorr;

   147

			long long PhaseCorr;

   148

			long long PeriodicTcorr;

   149

			PLC_GetTime(&now);

   150

			elapsed = (now.tv_sec - __CURRENT_TIME.tv_sec) * 1000000000 + now.tv_nsec - __CURRENT_TIME.tv_nsec;

   151

			if(Nticks > 0){

   152

				PhaseCorr = elapsed - (Ttick + FreqCorr/Nticks)*sync_align_ratio/100; /* to be divided by Nticks */

   153

				Tcorr = Ttick + (PhaseCorr + FreqCorr) / Nticks;

   154

				if(Nticks < 2){

   155

					/* When Sync source period is near Tick time */

   156

					/* PhaseCorr may not be applied to Periodic time given to timer */

   157

					PeriodicTcorr = Ttick + FreqCorr / Nticks;

   158

				}else{

   160

				}

   161

			}else if(__tick > last_tick){

   162

				last_tick = __tick;

   163

				PhaseCorr = elapsed - (Tsync*sync_align_ratio/100);

   164

				PeriodicTcorr = Tcorr = Ttick + PhaseCorr + FreqCorr;

   165

			}else{

   166

				/*PLC did not run meanwhile. Nothing to do*/

   167

				return;

   168

			}

   169

			/* DO ALIGNEMENT */

   170

			PLC_SetTimer(Tcorr - elapsed, PeriodicTcorr);

   171

		}

   172

	}

   173

}

   174

   175

/**

   176

 * Prototypes for function provided by arch-specific code (main)

   177

 * is concatained hereafter