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(int poll, PYTHON_EVAL* data__) |
|
90 { |
|
91 /* detect rising edge on TRIG to trigger evaluation */ |
|
92 if(((data__->TRIG && !data__->TRIGM1) || |
|
93 /* polling is equivalent to trig on value rather than on rising edge*/ |
|
94 (poll && data__->TRIG )) && |
|
95 /* trig only if not already trigged */ |
|
96 data__->TRIGGED == 0){ |
|
97 /* mark as trigged */ |
|
98 data__->TRIGGED = 1; |
|
99 /* make a safe copy of the code */ |
|
100 data__->PREBUFFER = data__->CODE; |
|
101 } |
|
102 /* retain value for next rising edge detection */ |
|
103 data__->TRIGM1 = data__->TRIG; |
|
104 |
|
105 /* python thread is not in ? */ |
|
106 if( PythonState & PYTHON_LOCKED_BY_PLC){ |
|
107 /* if some answer are waiting, publish*/ |
|
108 if(data__->STATE == PYTHON_FB_ANSWERED){ |
|
109 /* Copy buffer content into result*/ |
|
110 data__->RESULT = data__->BUFFER; |
|
111 /* signal result presece to PLC*/ |
|
112 data__->ACK = 1; |
|
113 /* Mark as free */ |
|
114 data__->STATE = PYTHON_FB_FREE; |
|
115 /* mark as not trigged */ |
|
116 if(!poll) |
|
117 data__->TRIGGED = 0; |
|
118 /*printf("__PythonEvalFB pop %%d - %%*s\n",Current_PLC_EvalFB, data__->BUFFER.len, data__->BUFFER.body);*/ |
|
119 }else if(poll){ |
|
120 /* when in polling, no answer == ack down */ |
|
121 data__->ACK = 0; |
|
122 } |
|
123 /* got the order to act ?*/ |
|
124 if(data__->TRIGGED == 1 && |
|
125 /* and not already being processed */ |
|
126 data__->STATE == PYTHON_FB_FREE) |
|
127 { |
|
128 /* Enter the block in the fifo |
|
129 /* Don't have to check if fifo cell is free |
|
130 * as fifo size == FB count, and a FB cannot |
|
131 * be requested twice */ |
|
132 EvalFBs[Current_PLC_EvalFB] = data__; |
|
133 /* copy into BUFFER local*/ |
|
134 data__->BUFFER = data__->PREBUFFER; |
|
135 /* Set ACK pin to low so that we can set a rising edge on result */ |
|
136 if(!poll){ |
|
137 /* when not polling, a new answer imply reseting ack*/ |
|
138 data__->ACK = 0; |
|
139 }else{ |
|
140 /* when in polling, acting reset trigger */ |
|
141 data__->TRIGGED = 0; |
|
142 } |
|
143 /* Mark FB busy */ |
|
144 data__->STATE = PYTHON_FB_REQUESTED; |
|
145 /* Have to wakeup python thread in case he was asleep */ |
|
146 PythonState |= PYTHON_MUSTWAKEUP; |
|
147 /*printf("__PythonEvalFB push %%d - %%*s\n",Current_PLC_EvalFB, data__->BUFFER.len, data__->BUFFER.body);*/ |
|
148 /* Get a new line */ |
|
149 Current_PLC_EvalFB = (Current_PLC_EvalFB + 1) %% %(python_eval_fb_count)d; |
|
150 } |
|
151 } |
|
152 } |
|
153 |
|
154 char* PythonIterator(char* result) |
|
155 { |
|
156 char* next_command; |
|
157 PYTHON_EVAL* data__; |
|
158 //printf("PythonIterator result %%s\n", result); |
|
159 /* take python mutex to prevent changing PLC data while PLC running */ |
|
160 LockPython(); |
|
161 /* Get current FB */ |
|
162 data__ = EvalFBs[Current_Python_EvalFB]; |
|
163 if(data__ && /* may be null at first run */ |
|
164 data__->STATE == PYTHON_FB_PROCESSING){ /* some answer awaited*/ |
|
165 /* If result not None */ |
|
166 if(result){ |
|
167 /* Get results len */ |
|
168 data__->BUFFER.len = strlen(result); |
|
169 /* prevent results overrun */ |
|
170 if(data__->BUFFER.len > STR_MAX_LEN) |
|
171 { |
|
172 data__->BUFFER.len = STR_MAX_LEN; |
|
173 /* TODO : signal error */ |
|
174 } |
|
175 /* Copy results to buffer */ |
|
176 strncpy(data__->BUFFER.body, result, data__->BUFFER.len); |
|
177 }else{ |
|
178 data__->BUFFER.len = 0; |
|
179 } |
|
180 /* remove block from fifo*/ |
|
181 EvalFBs[Current_Python_EvalFB] = NULL; |
|
182 /* Mark block as answered */ |
|
183 data__->STATE = PYTHON_FB_ANSWERED; |
|
184 /* Get a new line */ |
|
185 Current_Python_EvalFB = (Current_Python_EvalFB + 1) %% %(python_eval_fb_count)d; |
|
186 //printf("PythonIterator ++ Current_Python_EvalFB %%d\n", Current_Python_EvalFB); |
|
187 } |
|
188 /* while next slot is empty */ |
|
189 while(((data__ = EvalFBs[Current_Python_EvalFB]) == NULL) || |
|
190 /* or doesn't contain command */ |
|
191 data__->STATE != PYTHON_FB_REQUESTED) |
|
192 { |
|
193 UnLockPython(); |
|
194 /* wait next FB to eval */ |
|
195 //printf("PythonIterator wait\n"); |
|
196 if(WaitPythonCommands()) return NULL; |
|
197 /*emergency exit*/ |
|
198 if(PythonState & PYTHON_FINISHED) return NULL; |
|
199 LockPython(); |
|
200 } |
|
201 /* Mark block as processing */ |
|
202 data__->STATE = PYTHON_FB_PROCESSING; |
|
203 //printf("PythonIterator\n"); |
|
204 /* make BUFFER a null terminated string */ |
|
205 data__->BUFFER.body[data__->BUFFER.len] = 0; |
|
206 /* next command is BUFFER */ |
|
207 next_command = data__->BUFFER.body; |
|
208 /* free python mutex */ |
|
209 UnLockPython(); |
|
210 /* return the next command to eval */ |
|
211 return next_command; |
|
212 } |
|
213 |
|