|
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(((__GET_VAR(data__->TRIG) && !__GET_VAR(data__->TRIGM1)) || |
|
94 /* polling is equivalent to trig on value rather than on rising edge*/ |
|
95 (poll && __GET_VAR(data__->TRIG) )) && |
|
96 /* trig only if not already trigged */ |
|
97 __GET_VAR(data__->TRIGGED) == 0){ |
|
98 /* mark as trigged */ |
|
99 __SET_VAR(data__->, TRIGGED, 1); |
|
100 /* make a safe copy of the code */ |
|
101 __SET_VAR(data__->, PREBUFFER, __GET_VAR(data__->CODE)); |
|
102 } |
|
103 /* retain value for next rising edge detection */ |
|
104 __SET_VAR(data__->, TRIGM1, __GET_VAR(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(__GET_VAR(data__->STATE) == PYTHON_FB_ANSWERED){ |
|
110 /* Copy buffer content into result*/ |
|
111 __SET_VAR(data__->, RESULT, __GET_VAR(data__->BUFFER)); |
|
112 /* signal result presece to PLC*/ |
|
113 __SET_VAR(data__->, ACK, 1); |
|
114 /* Mark as free */ |
|
115 __SET_VAR(data__->, STATE, PYTHON_FB_FREE); |
|
116 /* mark as not trigged */ |
|
117 if(!poll) |
|
118 __SET_VAR(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 __SET_VAR(data__->, ACK, 0); |
|
123 } |
|
124 /* got the order to act ?*/ |
|
125 if(__GET_VAR(data__->TRIGGED) == 1 && |
|
126 /* and not already being processed */ |
|
127 __GET_VAR(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 __SET_VAR(data__->, BUFFER, __GET_VAR(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 __SET_VAR(data__->, ACK, 0); |
|
140 }else{ |
|
141 /* when in polling, acting reset trigger */ |
|
142 __SET_VAR(data__->, TRIGGED, 0); |
|
143 } |
|
144 /* Mark FB busy */ |
|
145 __SET_VAR(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 /*emergency exit*/ |
|
161 if(PythonState & PYTHON_FINISHED) return NULL; |
|
162 /* take python mutex to prevent changing PLC data while PLC running */ |
|
163 LockPython(); |
|
164 /* Get current FB */ |
|
165 data__ = EvalFBs[Current_Python_EvalFB]; |
|
166 if(data__ && /* may be null at first run */ |
|
167 __GET_VAR(data__->STATE) == PYTHON_FB_PROCESSING){ /* some answer awaited*/ |
|
168 /* If result not None */ |
|
169 if(result){ |
|
170 /* Get results len */ |
|
171 __SET_VAR(data__->, BUFFER, strlen(result), .len); |
|
172 /* prevent results overrun */ |
|
173 if(__GET_VAR(data__->BUFFER, .len) > STR_MAX_LEN) |
|
174 { |
|
175 __SET_VAR(data__->, BUFFER, STR_MAX_LEN, .len ); |
|
176 /* TODO : signal error */ |
|
177 } |
|
178 /* Copy results to buffer */ |
|
179 strncpy((char*)__GET_VAR(data__->BUFFER, .body), result, __GET_VAR(data__->BUFFER,.len)); |
|
180 }else{ |
|
181 __SET_VAR(data__->, BUFFER, 0, .len); |
|
182 } |
|
183 /* remove block from fifo*/ |
|
184 EvalFBs[Current_Python_EvalFB] = NULL; |
|
185 /* Mark block as answered */ |
|
186 __SET_VAR(data__->, STATE, PYTHON_FB_ANSWERED); |
|
187 /* Get a new line */ |
|
188 Current_Python_EvalFB = (Current_Python_EvalFB + 1) %% %(python_eval_fb_count)d; |
|
189 //printf("PythonIterator ++ Current_Python_EvalFB %%d\n", Current_Python_EvalFB); |
|
190 } |
|
191 /* while next slot is empty */ |
|
192 while(((data__ = EvalFBs[Current_Python_EvalFB]) == NULL) || |
|
193 /* or doesn't contain command */ |
|
194 __GET_VAR(data__->STATE) != PYTHON_FB_REQUESTED) |
|
195 { |
|
196 UnLockPython(); |
|
197 /* wait next FB to eval */ |
|
198 //printf("PythonIterator wait\n"); |
|
199 if(WaitPythonCommands()) return NULL; |
|
200 /*emergency exit*/ |
|
201 if(PythonState & PYTHON_FINISHED) return NULL; |
|
202 LockPython(); |
|
203 } |
|
204 /* Mark block as processing */ |
|
205 __SET_VAR(data__->, STATE, PYTHON_FB_PROCESSING); |
|
206 //printf("PythonIterator\n"); |
|
207 /* make BUFFER a null terminated string */ |
|
208 __SET_VAR(data__->, BUFFER, 0, .body[__GET_VAR(data__->BUFFER, .len)]); |
|
209 /* next command is BUFFER */ |
|
210 next_command = (char*)__GET_VAR(data__->BUFFER, .body); |
|
211 /* free python mutex */ |
|
212 UnLockPython(); |
|
213 /* return the next command to eval */ |
|
214 return next_command; |
|
215 } |
|
216 |