hio_5_conveyor_belts.cpp
Go to the documentation of this file.
1 /** @file hio_5_conveyor_belts.cpp
2 
3 Tutorial, conveyor belt chain example for hiosys plugin
4 
5 @ingroup Tutorials
6 
7 @include hio_5_conveyor_belts.cpp
8 
9 */
10 
11 #include "libfaudes.h"
12 
13 // make the faudes namespace available to our program
14 using namespace faudes;
15 using namespace std;
16 
18 
19 /*
20 -----------------------------------------------------------------
21 Conveyor Belts, only left to right, designed with hiosys-approach
22 -----------------------------------------------------------------
23 Controller design, physical interface and simulation model for the conveyor-belt chain "cb11-cb4-cb12-cb5-cb13-cb6-cb14-cb10" of the LRT Fischertechnik model.
24 E.g. for the first 4 conveyor belts, we obtain the following hierarchy of automata:
25 
26  ABCD_controller
27  |
28  -------------------------------------
29  | |
30  AB_controller CD_controller
31  | |
32  -------------------- ------------------
33  | | | |
34 A_controller B_controller C_controller D_controller
35  | | | |
36  -------------------------------------------------------------------------
37  phys_interface(eg.'phys_A_l_implies_cb11-x-y.vio')
38  -------------------------------------------------------------------------
39  | | | | \
40  plant_cb11 plant_cb4 plant_cb12 plant_cb5 plant_TICK
41 
42 The lowest level ("plant_") implements a timed physical model of the conveyor-belt chain.
43 The model 'plant_TICK' implements the passing of time for the controllers 'A_'
44 to 'D_'(20 time units per wait-loop). For HIL-Simulation, the "plant_" layer is replaced
45 by IO devices.
46 
47 The physical interface translates physical sensor edges to abstract inputs for
48 the controllers 'A_' to 'D_', and translates abstract controller outputs to
49 physical actuator edges.
50 
51 The folder data/5_conveyor_belts/hil_demo/ contains a script 'run.sh' and
52 appendage to run the controllers in HIL simulation with the lrtlab Fischertechnik model.
53 See data/5_conveyor_belts/hil_demo/README.txt for details. To update hil_demo
54 with the latest controllers computed by this tutorial, run
55 hio_5_conveyor_belts_update_hil_demo.sh
56 
57 Note: execution of this tutorial can take about two hours!
58 */
59 
60 string errstr;
61 
62 //////////////////////////////////////////
63 // read plantA:
64 //////////////////////////////////////////
65 
66  cout << endl << "******** reading files: plant A, spec A, constraints LC_A, LP_A and LE_A." << endl;
67  //read plantA and corresp. alphabets:
68  HioPlant plantA("data/5_conveyor_belts/A_plant.gen");
69  plantA.Write("tmp_hio_cb_A_plant.gen");
70  if(!IsHioPlantForm(plantA,errstr)) cout<<errstr;
71  cout<<endl<<"plant done.";
72  //read contraints:
73  // L_P of plant A: has been left minimal, designed as empty generator for simmplicity
74  // this is allowed, because, for SINGLE plants, the controller is computed
75  // such that its projection to SigmaP is a constraint for liveness of the plant.
76  Generator LP_A("data/5_conveyor_belts/A_LP.gen");
77  // L_E of plant A (no A_nack): designed as empty generator with alphabet
78  // {A_nack} for simmplicity
79  Generator LE_A("data/5_conveyor_belts/A_LE.gen");
80 
81  //read specification and corr. alphabets:
82  HioPlant specA("data/5_conveyor_belts/A_spec.gen");
83  if(!IsHioPlantForm(specA,errstr)) cout<<errstr;
84  specA.Write("tmp_hio_cb_A_spec.gen");
85 
86  // read constraint L_C:
87  HioConstraint LC_A("data/5_conveyor_belts/A_LC.gen");
88  if(!IsHioConstraintForm(LC_A,errstr)) cout<<errstr;
89  LC_A.Write("tmp_hio_cb_A_LC.gen");
90 
91  // // do controller synthesis:
92  HioController controllerA;
93  cout << endl << "******** local controller synthesis for plant A, B, C,...,H." << endl;
94  HioSynthMonolithic(plantA,specA,LC_A,LP_A,LE_A,controllerA);
95  LP_A.Clear();
96  FAUDES_TEST_DUMP("HioSynthMonolithic: Fischertechnik Conveyor Belts",controllerA);
97  // controllerA.Name("Controller A");
98  controllerA.Write("tmp_hio_cb_A_controller.gen");
99  // // controller without errStates
100  // Parallel(controllerA,plantA,controllerA);
101  // Project(controllerA,plantA.PEvents()+specA.PEvents(),controllerA);
102  // PrefixClosure(controllerA);
103  // StateMin(controllerA,controllerA);
104  // controllerA.StateNamesEnabled(false);
105  // controllerA.Name("controller A");
106  // controllerA.Write("tmp_hio_cb_A_controller.gen");
107 
108  plantA.Clear();
109 
110  // // remark: controller synthesis for plants B, C,... is analogous.
111  // // Hence, the controllers are obtained by copy of the controllerA-file and appr. string replacement
112  HioController controllerX;
113  controllerA.Version("A_","B_",controllerX);
114  controllerX.Write("tmp_hio_cb_B_controller.gen");
115  controllerA.Version("A_","C_",controllerX);
116  controllerX.Write("tmp_hio_cb_C_controller.gen");
117  controllerA.Version("A_","D_",controllerX);
118  controllerX.Write("tmp_hio_cb_D_controller.gen");
119  controllerA.Version("A_","E_",controllerX);
120  controllerX.Write("tmp_hio_cb_E_controller.gen");
121  controllerA.Version("A_","F_",controllerX);
122  controllerX.Write("tmp_hio_cb_F_controller.gen");
123  controllerA.Version("A_","G_",controllerX);
124  controllerX.Write("tmp_hio_cb_G_controller.gen");
125  controllerA.Version("A_","H_",controllerX);
126  controllerX.Write("tmp_hio_cb_H_controller.gen");
127 
128  controllerA.Clear();
129  controllerX.Clear();
130 
131 // //////////////////////////////////////////
132 // // plantAB: I/O shuffle and composition with environment
133 // //////////////////////////////////////////
134 
135  // plants are abstracted by specs, where all specs specB,specC... for a single conveyor belt are analogous to specA
136  HioPlant specB;
137  specA.Version("A_","B_",specB);
138  specB.Write("tmp_hio_cb_B_spec.gen");
139 
140  cout <<endl<< "******** IOshuffle of spec A and spec B." << endl;
141  HioPlant shuffAB;
142  HioShuffle(specA, specB, shuffAB);
143  FAUDES_TEST_DUMP("HioShuffle: Fischertechnik Conveyor Belts",shuffAB);
144  specA.Clear();
145  specB.Clear();
146 
147  cout<<endl<<"**** Statistics of shuffAB: "<<endl;
148  shuffAB.SWrite();
149  cout<<endl<<"**** Doing statemin...";
150  StateMin(shuffAB,shuffAB);
151  cout<<endl<<"**** Statistics after statemin: "<<endl;
152  shuffAB.SWrite();
153  shuffAB.StateNamesEnabled(false);
154  shuffAB.Name("IO shuffle AB");
155  shuffAB.Write("tmp_hio_cb_AB_shuff.gen_rename"); // _rename to avoid dot processing
156 
157  cout <<endl<< "******** environment: read files AB_Env1 and AB_Env2, composition to environment model." << endl;
158  //read environmentAB, which is derived from two components:
159  HioEnvironment envAB1("data/5_conveyor_belts/AB_Env1.gen");
160  HioEnvironment envAB2("data/5_conveyor_belts/AB_Env2.gen");
161  envAB1.Write("tmp_hio_cb_AB_env1.gen");
162  envAB2.Write("tmp_hio_cb_AB_env2.gen");
163  HioEnvironment envAB;
164  // compose preserving event attributes
165  aParallel(envAB1,envAB2,envAB);
166  envAB1.Clear();
167  envAB2.Clear();
168  StateMin(envAB,envAB);
169  envAB.StateNamesEnabled(false);
170  envAB.Name("envAB");
171  if(!IsHioEnvironmentForm(envAB,errstr)) cout<<errstr;
172  envAB.Write("tmp_hio_cb_AB_env.gen");
173 
174  cout <<endl<< "******** Composition shuffAB||envAB." << endl;
175 
176  ///////////////////////////////////////////////////
177  // controller synthesis for plantAB:
178  ///////////////////////////////////////////////////
179 
180  cout <<endl<< "******** Specification and constraints for compound AB." << endl;
181 
182  //read specAB
183  HioPlant specAB("data/5_conveyor_belts/AB_spec.gen");
184  if(!IsHioPlantForm(specAB,errstr)) cout<<errstr;
185  specAB.Write("tmp_hio_cb_AB_spec.gen");
186 
187  // read LC_AB
188  HioConstraint LC_AB("data/5_conveyor_belts/AB_LC.gen");
189  if(!IsHioConstraintForm(LC_AB,errstr)) cout<<errstr;
190  LC_AB.Write("tmp_hio_cb_AB_LC.gen");
191  // read LL_AB
192  Generator LL_AB("data/5_conveyor_belts/AB_LL.gen");
193 
194  // local constraints LC_B and LE_B from LC_A and LE_A
195  Generator LC_B, LE_B;
196  LC_A.Version("A_","B_",LC_B);
197  LE_A.Version("A_","B_",LE_B);
198  Generator intConstr_AB;
199  Parallel(LC_A,LC_B,intConstr_AB);
200  Parallel(intConstr_AB,LE_A,intConstr_AB);
201  Parallel(intConstr_AB,LE_B,intConstr_AB);
202  intConstr_AB.Name("intConstr_AB");
203  intConstr_AB.StateNamesEnabled(false);
204  LE_A.Clear();
205  LE_B.Clear();
206  LC_A.Clear();
207  LC_B.Clear();
208 
209  cout <<endl<< "******** Controller synthesis for compound AB." << endl;
210  //calculate IO controller for plantAB
211  HioController controllerAB;
212  HioSynthHierarchical(shuffAB, envAB, specAB, intConstr_AB, LC_AB, LL_AB, controllerAB);
213  controllerAB.Name("controllerAB");
214  controllerAB.SWrite();
215  controllerAB.Write("tmp_hio_cb_AB_controller.gen_rename");
216 
217  HioController controllerX2;
218 
219  controllerAB.Version("AB_","CD_",controllerX);
220  controllerX.Version("A_","C_",controllerX2);
221  controllerX2.Version("B_","D_",controllerX);
222  controllerX.Write("tmp_hio_cb_CD_controller.gen_rename");
223 
224  controllerAB.Version("AB_","EF_",controllerX);
225  controllerX.Version("A_","E_",controllerX2);
226  controllerX2.Version("B_","F_",controllerX);
227  controllerX.Write("tmp_hio_cb_EF_controller.gen_rename");
228 
229  controllerAB.Version("AB_","GH_",controllerX);
230  controllerX.Version("A_","G_",controllerX2);
231  controllerX2.Version("B_","H_",controllerX);
232  controllerX.Write("tmp_hio_cb_GH_controller.gen_rename");
233 
234 
235 
236  shuffAB.Clear();
237  envAB.Clear();
238  intConstr_AB.Clear();
239 
240 //######################################################################
241  //*****
242  //***** plantABCD: I/O shuffle and composition with environment.*****
243  //*****
244 //######################################################################
245 
246  cout <<endl<< "******** IOshuffle of spec AB and spec CD." << endl;
247 
248  // specCD from specAB
249  HioPlant specCD;
250  specAB.Version("AB_","CD_",specCD);
251  specCD.Write("tmp_hio_cb_CD_spec.gen");
252 
253  // HioShuffle
254  HioPlant shuffABCD;
255  HioShuffle(specAB, specCD, shuffABCD);
256  //specAB.Clear(); // needed later to create specABCD
257  specCD.Clear();
258  StateMin(shuffABCD,shuffABCD);
259  shuffABCD.Name("shuff ABCD");
260  shuffABCD.StateNamesEnabled(false);
261  shuffABCD.SWrite();
262  shuffABCD.Write("tmp_hio_cb_ABCD_shuff.gen_rename");
263 
264  cout <<endl<< "******** environmentAB: read files, composition to environment model." << endl;
265  //read environmentABCD:
266  HioEnvironment envABCD1("data/5_conveyor_belts/ABCD_Env1.gen");
267  envABCD1.Write("tmp_hio_cb_ABCD_env1.gen");
268  HioEnvironment envABCD2("data/5_conveyor_belts/ABCD_Env_ABCDfreetr.gen");
269  envABCD2.Write("tmp_hio_cb_ABCD_env_freetr.gen");
270  HioEnvironment envABCD;
271  aParallel(envABCD1,envABCD2,envABCD);
272  envABCD2.Read("data/5_conveyor_belts/ABCD_Env_ABCDoccfl.gen");
273  envABCD2.Write("tmp_hio_cb_ABCD_env_occfl.gen");
274  aParallel(envABCD,envABCD2,envABCD);
275  envABCD1.Clear();
276  envABCD2.Clear();
277  StateMin(envABCD,envABCD);
278  envABCD.StateNamesEnabled(false);
279  envABCD.Name("envABCD");
280  if(!IsHioEnvironmentForm(envABCD,errstr)) cout<<errstr;
281  envABCD.SWrite();
282  envABCD.Write("tmp_hio_cb_ABCD_env.gen");
283 
284  ///////////////////////////////////////////////////
285  // controller synthesis for plantABCD:
286  ///////////////////////////////////////////////////
287 
288  // specABCD: same as spec AB or spec CD, spec EF, spec GH
289  HioPlant specABCD;
290  specAB.Version("AB_","ABCD_",specABCD);
291  specAB.Clear();
292  specABCD.Write("tmp_hio_cb_ABCD_spec.gen");
293 
294  // internal contraints:
295  Generator LC_CD,LL_CD;
296  LC_AB.Version("AB_","CD_",LC_CD);
297  LL_AB.Version("AB_","CD_",LL_CD);
298 
299  Generator intConstr_ABCD;
300  Parallel(LC_AB,LC_CD,intConstr_ABCD);
301  Parallel(intConstr_ABCD,LL_AB,intConstr_ABCD);
302  Parallel(intConstr_ABCD,LL_CD,intConstr_ABCD);
303  intConstr_ABCD.Name("intConstr_ABCD");
304  intConstr_ABCD.StateNamesEnabled(false);
305 
306  // external constraints:
307  Generator LC_ABCD,LL_ABCD;
308  LC_AB.Version("AB_","ABCD_",LC_ABCD);
309  LL_AB.Version("AB_","ABCD_",LL_ABCD);
310 
311  //calculate IO controller for plantABCD
312 
313  cout <<endl<< "******** Controller synthesis for compound ABCD." << endl;
314  //calculate IO controller for plantABCD
315  HioController controllerABCD;
316  // caution: takes up to 2 hours!
317  cout <<endl<< "**** Synthesis procedure is running - this can take about two hours! ..." << endl;
318  //HioSynthHierarchical(shuffABCD, envABCD, specABCD, intConstr_ABCD, LC_ABCD, LL_ABCD, controllerABCD);
319  controllerABCD.Name("controllerABCD");
320  controllerABCD.SWrite();
321  controllerABCD.Write("tmp_hio_cb_ABCD_controller.gen_rename");
322  controllerABCD.Read("tmp_hio_cb_ABCD_controller.gen_rename");
323 
324  shuffABCD.Clear();
325  envABCD.Clear();
326  intConstr_ABCD.Clear();
327 
328  controllerABCD.Version("ABCD_","EFGH_",controllerX);
329  controllerX.Version("AB_","EF_",controllerX2);
330  controllerX2.Version("CD_","GH_",controllerX);
331  controllerX.Write("tmp_hio_cb_EFGH_controller.gen_rename");
332 
333  controllerABCD.Version("ABCD_","ABCDEFGH_",controllerX);
334  controllerX.Version("CD_","EFGH_",controllerX2);
335  controllerX2.Version("AB_","ABCD_",controllerX);
336  controllerX.Write("tmp_hio_cb_ABCDEFGH_controller.gen_rename");
337 
338  cout << endl << "done.";
339 
340  return 0;
341 }
342 
343 /** Run the tutorial */
344 int main() {
345  // call simple machine example
346  try {
347  conveyor_belts();
348  }
349  catch (Exception& e) {
350  std::cout << "function: " << e.Where() << std::endl;
351  std::cout << "exception description: " << e.What() << std::endl;
352  std::cout << "exception id: " << e.Id() << std::endl;
353 }
354  return 0;
355 }

libFAUDES 2.24g --- 2014.09.15 --- c++ api documentaion by doxygen