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

void __init_python()

    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

}

    56

    57

void __cleanup_python()

    58

{

    59

	PythonState = PYTHON_FINISHED;

    60

	UnBlockPythonCommands();

    61

}

    62

    63

void __retrieve_python()

    64

{

    65

	/* Check Python thread is not being 

    66

	 * modifying internal python_eval data */

    67

	PythonState = TryLockPython() ? 

    68

	                PYTHON_LOCKED_BY_PLC : 

    69

	                PYTHON_LOCKED_BY_PYTHON;

    70

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

    71

	 * and python_eval will no do anything */

    72

}

    73

    74

void __publish_python()

    75

{

    76

	if(PythonState & PYTHON_LOCKED_BY_PLC){

    77

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

    78

		if(PythonState & PYTHON_MUSTWAKEUP){

    79

			/* WakeUp python thread */

    80

			UnBlockPythonCommands();

    81

		}

    82

		UnLockPython();

    83

	}

    84

}

    85

/**

    86

 * Called by the PLC, each time a python_eval 

    87

 * FB instance is executed

    88

 */

    89

void __PythonEvalFB(PYTHON_EVAL* data__)

    90

{

    91

	/* detect rising edge on TRIG */

    92

	if(data__->TRIG && !data__->TRIGM1 && data__->TRIGGED == 0){

    93

		/* mark as trigged */

    94

		data__->TRIGGED = 1;

    95

		/* make a safe copy of the code */

    96

		data__->PREBUFFER = data__->CODE;

    97

	}

    98

	/* retain value for next detection */

    99

	data__->TRIGM1 = data__->TRIG;

   100

   101

	/* python thread is not in ? */

   102

	if( PythonState & PYTHON_LOCKED_BY_PLC){

   103

		/* got the order to act */

   104

		if(data__->TRIGGED == 1 &&

   105

		   /* and not already being processed */ 

   106

		   data__->STATE == PYTHON_FB_FREE) 

   107

		{

   108

			/* Enter the block in the fifo

   109

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

   110

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

   111

			 * be requested twice */

   112

			EvalFBs[Current_PLC_EvalFB] = data__;

   113

			/* copy into BUFFER local*/

   114

			data__->BUFFER = data__->PREBUFFER;

   115

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

   116

			data__->ACK = 0;

   117

			/* Mark FB busy */

   118

			data__->STATE = PYTHON_FB_REQUESTED;

   119

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

   120

			PythonState |= PYTHON_MUSTWAKEUP;

   121

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

   122

			/* Get a new line */

   123

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

   124

		}else if(data__->STATE == PYTHON_FB_ANSWERED){

   125

			/* Copy buffer content into result*/

   126

			data__->RESULT = data__->BUFFER;

   127

			/* signal result presece to PLC*/

   128

			data__->ACK = 1;

   129

			/* Mark as free */

   130

			data__->STATE = PYTHON_FB_FREE;

   131

			/* mark as not trigged */

   132

			data__->TRIGGED = 0;

   133

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

   134

		}

   135

	}

   136

}

   137

   138

char* PythonIterator(char* result)

   139

{

   140

	char* next_command;

   141

	PYTHON_EVAL* data__;

   142

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

   143

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

   144

	LockPython();

   145

	/* Get current FB */

   146

	data__ = EvalFBs[Current_Python_EvalFB];

   147

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

   148

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

   149

	   	/* If result not None */

   150

	   	if(result){

   151

			/* Get results len */

   152

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

   153

			/* prevent results overrun */

   154

			if(data__->BUFFER.len > STR_MAX_LEN)

   155

			{

   156

				data__->BUFFER.len = STR_MAX_LEN;

   157

				/* TODO : signal error */

   158

			}

   159

			/* Copy results to buffer */

   160

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

   161

	   	}else{

   162

	   		data__->BUFFER.len = 0;

   163

	   	}

   164

		/* remove block from fifo*/

   165

		EvalFBs[Current_Python_EvalFB] = NULL;

   166

		/* Mark block as answered */

   167

		data__->STATE = PYTHON_FB_ANSWERED;

   168

		/* Get a new line */

   169

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

   170

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

   171

	}

   172

	/* while next slot is empty */

   173

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

   174

	 	  /* or doesn't contain command */ 

   175

	      data__->STATE != PYTHON_FB_REQUESTED)

   176

	{

   177

		UnLockPython();

   178

		/* wait next FB to eval */

   179

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

   180

		WaitPythonCommands();

   181

		/*emergency exit*/

   182

		if(PythonState & PYTHON_FINISHED) return NULL;

   183

		LockPython();

   184

	}

   185

	/* Mark block as processing */

   186

	data__->STATE = PYTHON_FB_PROCESSING;

   187

	//printf("PythonIterator\n");

   188

	/* make BUFFER a null terminated string */

   189

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

   190

	/* next command is BUFFER */

   191

	next_command = data__->BUFFER.body;

   192

	/* free python mutex */

   193

	UnLockPython();

   194

	/* return the next command to eval */

   195

	return next_command;

   196

}

   197