1

/*

     2

 * Python Asynchronous execution code

     3

 *

     4

 * PLC put python commands in a fifo, respecting execution order

     5

 * with the help of C pragmas inserted in python_eval FB code

     6

 *

     7

 * Buffer content is read asynchronously, (from non real time part),

     8

 * commands are executed and result stored for later use by PLC.

     9

 *

    10

 * In this implementation, fifo is a list of pointer to python_eval

    11

 * function blocks structures. Some local variables have been added in

    12

 * python_eval interface. We use those local variables as buffer and state

    13

 * flags.

    14

 *

    15

 * */

    16

    17

#include "iec_types_all.h"

    18

#include "POUS.h"

    19

#include <string.h>

    20

    21

/* The fifo (fixed size, as number of FB is fixed) */

    22

static PYTHON_EVAL* EvalFBs[%(python_eval_fb_count)d];

    23

/* Producer and consumer cursors */

    24

static int Current_PLC_EvalFB;

    25

static int Current_Python_EvalFB;

    26

    27

/* A global IEC-Python gateway state, for use inside python_eval FBs*/

    28

static int PythonState;

    29

#define PYTHON_LOCKED_BY_PYTHON 0

    30

#define PYTHON_LOCKED_BY_PLC 1

    31

#define PYTHON_MUSTWAKEUP 2

    32

#define PYTHON_FINISHED 4

    33

    34

/* Each python_eval FunctionBlock have it own state */

    35

#define PYTHON_FB_FREE 0

    36

#define PYTHON_FB_REQUESTED 1

    37

#define PYTHON_FB_PROCESSING 2

    38

#define PYTHON_FB_ANSWERED 3

    39

    40

int WaitPythonCommands(void);

    41

void UnBlockPythonCommands(void);

    42

int TryLockPython(void);

    43

void UnLockPython(void);

    44

void LockPython(void);

    45

    46

int __init_py_ext()

    47

{

    48

	int i;

    49

	/* Initialize cursors */

    50

	Current_Python_EvalFB = 0;

    51

	Current_PLC_EvalFB = 0;

    52

	PythonState = PYTHON_LOCKED_BY_PYTHON;

    53

	for(i = 0; i < %(python_eval_fb_count)d; i++)

    54

		EvalFBs[i] = NULL;

    55

  return 0;

    56

}

    57

    58

void __cleanup_py_ext()

    59

{

    60

	PythonState = PYTHON_FINISHED;

    61

	UnBlockPythonCommands();

    62

}

    63

    64

void __retrieve_py_ext()

    65

{

    66

	/* Check Python thread is not being

    67

	 * modifying internal python_eval data */

    68

	PythonState = TryLockPython() ?

    69

	                PYTHON_LOCKED_BY_PLC :

    70

	                PYTHON_LOCKED_BY_PYTHON;

    71

	/* If python thread _is_ in, then PythonState remains PYTHON_LOCKED_BY_PYTHON

    72

	 * and python_eval will no do anything */

    73

}

    74

    75

void __publish_py_ext()

    76

{

    77

	if(PythonState & PYTHON_LOCKED_BY_PLC){

    78

		/* If runnig PLC did push something in the fifo*/

    79

		if(PythonState & PYTHON_MUSTWAKEUP){

    80

			/* WakeUp python thread */

    81

			UnBlockPythonCommands();

    82

		}

    83

		UnLockPython();

    84

	}

    85

}

    86

/**

    87

 * Called by the PLC, each time a python_eval

    88

 * FB instance is executed

    89

 */

    90

void __PythonEvalFB(int poll, PYTHON_EVAL* data__)

    91

{

    92

    if(!__GET_VAR(data__->TRIG)){

    93

        /* ACK is False when TRIG is false, except a pulse when receiving result */

    94

        __SET_VAR(data__->, ACK,, 0);

    95

    }

    96

	/* detect rising edge on TRIG to trigger evaluation */

    97

	if(((__GET_VAR(data__->TRIG) && !__GET_VAR(data__->TRIGM1)) ||

    98

	   /* polling is equivalent to trig on value rather than on rising edge*/

    99

	    (poll && __GET_VAR(data__->TRIG) )) &&

   100

	    /* trig only if not already trigged */

   101

	    __GET_VAR(data__->TRIGGED) == 0){

   102

		/* mark as trigged */

   103

	    __SET_VAR(data__->, TRIGGED,, 1);

   104

		/* make a safe copy of the code */

   105

		__SET_VAR(data__->, PREBUFFER,, __GET_VAR(data__->CODE));

   106

	}

   107

	/* retain value for next rising edge detection */

   108

	__SET_VAR(data__->, TRIGM1,, __GET_VAR(data__->TRIG));

   109

   110

	/* python thread is not in ? */

   111

	if( PythonState & PYTHON_LOCKED_BY_PLC){

   112

		/* if some answer are waiting, publish*/

   113

		if(__GET_VAR(data__->STATE) == PYTHON_FB_ANSWERED){

   114

			/* Copy buffer content into result*/

   115

			__SET_VAR(data__->, RESULT,, __GET_VAR(data__->BUFFER));

   116

			/* signal result presence to PLC*/

   117

			__SET_VAR(data__->, ACK,, 1);

   118

			/* Mark as free */

   119

			__SET_VAR(data__->, STATE,, PYTHON_FB_FREE);

   120

			/* mark as not trigged */

   121

			if(!poll)

   122

			    __SET_VAR(data__->, TRIGGED,, 0);

   123

			/*printf("__PythonEvalFB pop %%d - %%*s\n",Current_PLC_EvalFB, data__->BUFFER.len, data__->BUFFER.body);*/

   124

		}else if(poll){

   125

			/* when in polling, no answer == ack down */

   126

		    __SET_VAR(data__->, ACK,, 0);

   127

		}

   128

		/* got the order to act ?*/

   129

		if(__GET_VAR(data__->TRIGGED) == 1 &&

   130

		   /* and not already being processed */

   131

		   __GET_VAR(data__->STATE) == PYTHON_FB_FREE)

   132

		{

   133

			/* Enter the block in the fifo

   134

			 * Don't have to check if fifo cell is free

   135

			 * as fifo size == FB count, and a FB cannot

   136

			 * be requested twice */

   137

			EvalFBs[Current_PLC_EvalFB] = data__;

   138

			/* copy into BUFFER local*/

   139

			__SET_VAR(data__->, BUFFER,, __GET_VAR(data__->PREBUFFER));

   140

			/* Set ACK pin to low so that we can set a rising edge on result */

   141

			if(!poll){

   142

				/* when not polling, a new answer imply reseting ack*/

   143

			    __SET_VAR(data__->, ACK,, 0);

   144

			}else{

   145

				/* when in polling, acting reset trigger */

   146

			    __SET_VAR(data__->, TRIGGED,, 0);

   147

			}

   148

			/* Mark FB busy */

   149

			__SET_VAR(data__->, STATE,, PYTHON_FB_REQUESTED);

   150

			/* Have to wakeup python thread in case he was asleep */

   151

			PythonState |= PYTHON_MUSTWAKEUP;

   152

			/*printf("__PythonEvalFB push %%d - %%*s\n",Current_PLC_EvalFB, data__->BUFFER.len, data__->BUFFER.body);*/

   153

			/* Get a new line */

   154

			Current_PLC_EvalFB = (Current_PLC_EvalFB + 1) %% %(python_eval_fb_count)d;

   155

		}

   156

	}

   157

}

   158

   159

char* PythonIterator(char* result, void** id)

   160

{

   161

	char* next_command;

   162

	PYTHON_EVAL* data__;

   163

	//printf("PythonIterator result %%s\n", result);

   164

    /*emergency exit*/

   165

    if(PythonState & PYTHON_FINISHED) return NULL;

   166

	/* take python mutex to prevent changing PLC data while PLC running */

   167

	LockPython();

   168

	/* Get current FB */

   169

	data__ = EvalFBs[Current_Python_EvalFB];

   170

	if(data__ && /* may be null at first run */

   171

	    __GET_VAR(data__->STATE) == PYTHON_FB_PROCESSING){ /* some answer awaited*/

   172

	   	/* If result not None */

   173

	   	if(result){

   174

			/* Get results len */

   175

	   	    __SET_VAR(data__->, BUFFER, .len, strlen(result));

   176

			/* prevent results overrun */

   177

			if(__GET_VAR(data__->BUFFER, .len) > STR_MAX_LEN)

   178

			{

   179

			    __SET_VAR(data__->, BUFFER, .len, STR_MAX_LEN);

   180

				/* TODO : signal error */

   181

			}

   182

			/* Copy results to buffer */

   183

			strncpy((char*)__GET_VAR(data__->BUFFER, .body), result, __GET_VAR(data__->BUFFER,.len));

   184

	   	}else{

   185

	   	    __SET_VAR(data__->, BUFFER, .len, 0);

   186

	   	}

   187

		/* remove block from fifo*/

   188

		EvalFBs[Current_Python_EvalFB] = NULL;

   189

		/* Mark block as answered */

   190

		__SET_VAR(data__->, STATE,, PYTHON_FB_ANSWERED);

   191

		/* Get a new line */

   192

		Current_Python_EvalFB = (Current_Python_EvalFB + 1) %% %(python_eval_fb_count)d;

   193

		//printf("PythonIterator ++ Current_Python_EvalFB %%d\n", Current_Python_EvalFB);

   194

	}

   195

	/* while next slot is empty */

   196

	while(((data__ = EvalFBs[Current_Python_EvalFB]) == NULL) ||

   197

	 	  /* or doesn't contain command */

   198

	      __GET_VAR(data__->STATE) != PYTHON_FB_REQUESTED)

   199

	{

   200

		UnLockPython();

   201

		/* wait next FB to eval */

   202

		//printf("PythonIterator wait\n");

   203

		if(WaitPythonCommands()) return NULL;

   204

		/*emergency exit*/

   205

		if(PythonState & PYTHON_FINISHED) return NULL;

   206

		LockPython();

   207

	}

   208

	/* Mark block as processing */

   209

	__SET_VAR(data__->, STATE,, PYTHON_FB_PROCESSING);

   210

	//printf("PythonIterator\n");

   211

	/* make BUFFER a null terminated string */

   212

	__SET_VAR(data__->, BUFFER, .body[__GET_VAR(data__->BUFFER, .len)], 0);

   213

	/* next command is BUFFER */

   214

	next_command = (char*)__GET_VAR(data__->BUFFER, .body);

   215

	*id=data__;

   216

	/* free python mutex */

   217

	UnLockPython();

   218

	/* return the next command to eval */

   219

	return next_command;

   220

}

   221