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_%(location)s()

    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_%(location)s()

    59

{

    60

	PythonState = PYTHON_FINISHED;

    61

	UnBlockPythonCommands();

    62

}

    63

    64

void __retrieve_%(location)s()

    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_%(location)s()

    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

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

    93

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

    94

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

    95

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

    96

	    /* trig only if not already trigged */

    97

	   data__->TRIGGED == 0){

    98

		/* mark as trigged */

    99

		data__->TRIGGED = 1;

   100

		/* make a safe copy of the code */

   101

		data__->PREBUFFER = data__->CODE;

   102

	}

   103

	/* retain value for next rising edge detection */

   104

	data__->TRIGM1 = data__->TRIG;

   105

   106

	/* python thread is not in ? */

   107

	if( PythonState & PYTHON_LOCKED_BY_PLC){

   108

		/* if some answer are waiting, publish*/

   109

		if(data__->STATE == PYTHON_FB_ANSWERED){

   110

			/* Copy buffer content into result*/

   111

			data__->RESULT = data__->BUFFER;

   112

			/* signal result presece to PLC*/

   113

			data__->ACK = 1;

   114

			/* Mark as free */

   115

			data__->STATE = PYTHON_FB_FREE;

   116

			/* mark as not trigged */

   117

			if(!poll)

   118

				data__->TRIGGED = 0;

   119

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

   120

		}else if(poll){

   121

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

   122

			data__->ACK = 0;

   123

		}

   124

		/* got the order to act ?*/

   125

		if(data__->TRIGGED == 1 &&

   126

		   /* and not already being processed */

   127

		   data__->STATE == PYTHON_FB_FREE)

   128

		{

   129

			/* Enter the block in the fifo

   130

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

   131

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

   132

			 * be requested twice */

   133

			EvalFBs[Current_PLC_EvalFB] = data__;

   134

			/* copy into BUFFER local*/

   135

			data__->BUFFER = data__->PREBUFFER;

   136

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

   137

			if(!poll){

   138

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

   139

				data__->ACK = 0;

   140

			}else{

   141

				/* when in polling, acting reset trigger */

   142

				data__->TRIGGED = 0;

   143

			}

   144

			/* Mark FB busy */

   145

			data__->STATE = PYTHON_FB_REQUESTED;

   146

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

   147

			PythonState |= PYTHON_MUSTWAKEUP;

   148

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

   149

			/* Get a new line */

   150

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

   151

		}

   152

	}

   153

}

   154

   155

char* PythonIterator(char* result)

   156

{

   157

	char* next_command;

   158

	PYTHON_EVAL* data__;

   159

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

   160

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

   161

	LockPython();

   162

	/* Get current FB */

   163

	data__ = EvalFBs[Current_Python_EvalFB];

   164

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

   165

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

   166

	   	/* If result not None */

   167

	   	if(result){

   168

			/* Get results len */

   169

			data__->BUFFER.len = strlen(result);

   170

			/* prevent results overrun */

   171

			if(data__->BUFFER.len > STR_MAX_LEN)

   172

			{

   173

				data__->BUFFER.len = STR_MAX_LEN;

   174

				/* TODO : signal error */

   175

			}

   176

			/* Copy results to buffer */

   177

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

   178

	   	}else{

   179

	   		data__->BUFFER.len = 0;

   180

	   	}

   181

		/* remove block from fifo*/

   182

		EvalFBs[Current_Python_EvalFB] = NULL;

   183

		/* Mark block as answered */

   184

		data__->STATE = PYTHON_FB_ANSWERED;

   185

		/* Get a new line */

   186

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

   187

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

   188

	}

   189

	/* while next slot is empty */

   190

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

   191

	 	  /* or doesn't contain command */

   192

	      data__->STATE != PYTHON_FB_REQUESTED)

   193

	{

   194

		UnLockPython();

   195

		/* wait next FB to eval */

   196

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

   197

		if(WaitPythonCommands()) return NULL;

   198

		/*emergency exit*/

   199

		if(PythonState & PYTHON_FINISHED) return NULL;

   200

		LockPython();

   201

	}

   202

	/* Mark block as processing */

   203

	data__->STATE = PYTHON_FB_PROCESSING;

   204

	//printf("PythonIterator\n");

   205

	/* make BUFFER a null terminated string */

   206

	data__->BUFFER.body[data__->BUFFER.len] = 0;

   207

	/* next command is BUFFER */

   208

	next_command = data__->BUFFER.body;

   209

	/* free python mutex */

   210

	UnLockPython();

   211

	/* return the next command to eval */

   212

	return next_command;

   213

}

   214