hio_5_conveyor_belts.cppGo to the documentation of this file.00001 /** @file hio_5_conveyor_belts.cpp 00002 00003 Tutorial, conveyor belt chain example for hiosys plugin 00004 00005 @ingroup Tutorials 00006 00007 @include hio_5_conveyor_belts.cpp 00008 00009 */ 00010 00011 #include "libfaudes.h" 00012 00013 // make the faudes namespace available to our program 00014 using namespace faudes; 00015 using namespace std; 00016 00017 int conveyor_belts(){ 00018 00019 /* 00020 ----------------------------------------------------------------- 00021 Conveyor Belts, only left to right, designed with hiosys-approach 00022 ----------------------------------------------------------------- 00023 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. 00024 E.g. for the first 4 conveyor belts, we obtain the following hierarchy of automata: 00025 00026 ABCD_controller 00027 | 00028 ------------------------------------- 00029 | | 00030 AB_controller CD_controller 00031 | | 00032 -------------------- ------------------ 00033 | | | | 00034 A_controller B_controller C_controller D_controller 00035 | | | | 00036 ------------------------------------------------------------------------- 00037 phys_interface(eg.'phys_A_l_implies_cb11-x-y.vio') 00038 ------------------------------------------------------------------------- 00039 | | | | \ 00040 plant_cb11 plant_cb4 plant_cb12 plant_cb5 plant_TICK 00041 00042 The lowest level ("plant_") implements a timed physical model of the conveyor-belt chain. 00043 The model 'plant_TICK' implements the passing of time for the controllers 'A_' 00044 to 'D_'(20 time units per wait-loop). For HIL-Simulation, the "plant_" layer is replaced 00045 by IO devices. 00046 00047 The physical interface translates physical sensor edges to abstract inputs for 00048 the controllers 'A_' to 'D_', and translates abstract controller outputs to 00049 physical actuator edges. 00050 00051 The folder data/5_conveyor_belts/hil_demo/ contains a script 'run.sh' and 00052 appendage to run the controllers in HIL simulation with the lrtlab Fischertechnik model. 00053 See data/5_conveyor_belts/hil_demo/README.txt for details. To update hil_demo 00054 with the latest controllers computed by this tutorial, run 00055 hio_5_conveyor_belts_update_hil_demo.sh 00056 00057 Note: execution of this tutorial can take about two hours! 00058 */ 00059 00060 string errstr; 00061 00062 ////////////////////////////////////////// 00063 // read plantA: 00064 ////////////////////////////////////////// 00065 00066 cout << endl << "******** reading files: plant A, spec A, constraints LC_A, LP_A and LE_A." << endl; 00067 //read plantA and corresp. alphabets: 00068 HioPlant plantA("data/5_conveyor_belts/A_plant.gen"); 00069 plantA.Write("tmp_hio_cb_A_plant.gen"); 00070 if(!IsHioPlantForm(plantA,errstr)) cout<<errstr; 00071 cout<<endl<<"plant done."; 00072 //read contraints: 00073 // L_P of plant A: has been left minimal, designed as empty generator for simmplicity 00074 // this is allowed, because, for SINGLE plants, the controller is computed 00075 // such that its projection to SigmaP is a constraint for liveness of the plant. 00076 Generator LP_A("data/5_conveyor_belts/A_LP.gen"); 00077 // L_E of plant A (no A_nack): designed as empty generator with alphabet 00078 // {A_nack} for simmplicity 00079 Generator LE_A("data/5_conveyor_belts/A_LE.gen"); 00080 00081 //read specification and corr. alphabets: 00082 HioPlant specA("data/5_conveyor_belts/A_spec.gen"); 00083 if(!IsHioPlantForm(specA,errstr)) cout<<errstr; 00084 specA.Write("tmp_hio_cb_A_spec.gen"); 00085 00086 // read constraint L_C: 00087 HioConstraint LC_A("data/5_conveyor_belts/A_LC.gen"); 00088 if(!IsHioConstraintForm(LC_A,errstr)) cout<<errstr; 00089 LC_A.Write("tmp_hio_cb_A_LC.gen"); 00090 00091 // // do controller synthesis: 00092 HioController controllerA; 00093 cout << endl << "******** local controller synthesis for plant A, B, C,...,H." << endl; 00094 HioSynthMonolithic(plantA,specA,LC_A,LP_A,LE_A,controllerA); 00095 LP_A.Clear(); 00096 FAUDES_TEST_DUMP("HioSynthMonolithic: Fischertechnik Conveyor Belts",controllerA); 00097 // controllerA.Name("Controller A"); 00098 controllerA.Write("tmp_hio_cb_A_controller.gen"); 00099 // // controller without errStates 00100 // Parallel(controllerA,plantA,controllerA); 00101 // Project(controllerA,plantA.PEvents()+specA.PEvents(),controllerA); 00102 // PrefixClosure(controllerA); 00103 // StateMin(controllerA,controllerA); 00104 // controllerA.StateNamesEnabled(false); 00105 // controllerA.Name("controller A"); 00106 // controllerA.Write("tmp_hio_cb_A_controller.gen"); 00107 00108 plantA.Clear(); 00109 00110 // // remark: controller synthesis for plants B, C,... is analogous. 00111 // // Hence, the controllers are obtained by copy of the controllerA-file and appr. string replacement 00112 HioController controllerX; 00113 controllerA.Version("A_","B_",controllerX); 00114 controllerX.Write("tmp_hio_cb_B_controller.gen"); 00115 controllerA.Version("A_","C_",controllerX); 00116 controllerX.Write("tmp_hio_cb_C_controller.gen"); 00117 controllerA.Version("A_","D_",controllerX); 00118 controllerX.Write("tmp_hio_cb_D_controller.gen"); 00119 controllerA.Version("A_","E_",controllerX); 00120 controllerX.Write("tmp_hio_cb_E_controller.gen"); 00121 controllerA.Version("A_","F_",controllerX); 00122 controllerX.Write("tmp_hio_cb_F_controller.gen"); 00123 controllerA.Version("A_","G_",controllerX); 00124 controllerX.Write("tmp_hio_cb_G_controller.gen"); 00125 controllerA.Version("A_","H_",controllerX); 00126 controllerX.Write("tmp_hio_cb_H_controller.gen"); 00127 00128 controllerA.Clear(); 00129 controllerX.Clear(); 00130 00131 // ////////////////////////////////////////// 00132 // // plantAB: I/O shuffle and composition with environment 00133 // ////////////////////////////////////////// 00134 00135 // plants are abstracted by specs, where all specs specB,specC... for a single conveyor belt are analogous to specA 00136 HioPlant specB; 00137 specA.Version("A_","B_",specB); 00138 specB.Write("tmp_hio_cb_B_spec.gen"); 00139 00140 cout <<endl<< "******** IOshuffle of spec A and spec B." << endl; 00141 HioPlant shuffAB; 00142 HioShuffle(specA, specB, shuffAB); 00143 FAUDES_TEST_DUMP("HioShuffle: Fischertechnik Conveyor Belts",shuffAB); 00144 specA.Clear(); 00145 specB.Clear(); 00146 00147 cout<<endl<<"**** Statistics of shuffAB: "<<endl; 00148 shuffAB.SWrite(); 00149 cout<<endl<<"**** Doing statemin..."; 00150 StateMin(shuffAB,shuffAB); 00151 cout<<endl<<"**** Statistics after statemin: "<<endl; 00152 shuffAB.SWrite(); 00153 shuffAB.StateNamesEnabled(false); 00154 shuffAB.Name("IO shuffle AB"); 00155 shuffAB.Write("tmp_hio_cb_AB_shuff.gen_rename"); // _rename to avoid dot processing 00156 00157 cout <<endl<< "******** environment: read files AB_Env1 and AB_Env2, composition to environment model." << endl; 00158 //read environmentAB, which is derived from two components: 00159 HioEnvironment envAB1("data/5_conveyor_belts/AB_Env1.gen"); 00160 HioEnvironment envAB2("data/5_conveyor_belts/AB_Env2.gen"); 00161 envAB1.Write("tmp_hio_cb_AB_env1.gen"); 00162 envAB2.Write("tmp_hio_cb_AB_env2.gen"); 00163 HioEnvironment envAB; 00164 // compose preserving event attributes 00165 aParallel(envAB1,envAB2,envAB); 00166 envAB1.Clear(); 00167 envAB2.Clear(); 00168 StateMin(envAB,envAB); 00169 envAB.StateNamesEnabled(false); 00170 envAB.Name("envAB"); 00171 if(!IsHioEnvironmentForm(envAB,errstr)) cout<<errstr; 00172 envAB.Write("tmp_hio_cb_AB_env.gen"); 00173 00174 cout <<endl<< "******** Composition shuffAB||envAB." << endl; 00175 00176 /////////////////////////////////////////////////// 00177 // controller synthesis for plantAB: 00178 /////////////////////////////////////////////////// 00179 00180 cout <<endl<< "******** Specification and constraints for compound AB." << endl; 00181 00182 //read specAB 00183 HioPlant specAB("data/5_conveyor_belts/AB_spec.gen"); 00184 if(!IsHioPlantForm(specAB,errstr)) cout<<errstr; 00185 specAB.Write("tmp_hio_cb_AB_spec.gen"); 00186 00187 // read LC_AB 00188 HioConstraint LC_AB("data/5_conveyor_belts/AB_LC.gen"); 00189 if(!IsHioConstraintForm(LC_AB,errstr)) cout<<errstr; 00190 LC_AB.Write("tmp_hio_cb_AB_LC.gen"); 00191 // read LL_AB 00192 Generator LL_AB("data/5_conveyor_belts/AB_LL.gen"); 00193 00194 // local constraints LC_B and LE_B from LC_A and LE_A 00195 Generator LC_B, LE_B; 00196 LC_A.Version("A_","B_",LC_B); 00197 LE_A.Version("A_","B_",LE_B); 00198 Generator intConstr_AB; 00199 Parallel(LC_A,LC_B,intConstr_AB); 00200 Parallel(intConstr_AB,LE_A,intConstr_AB); 00201 Parallel(intConstr_AB,LE_B,intConstr_AB); 00202 intConstr_AB.Name("intConstr_AB"); 00203 intConstr_AB.StateNamesEnabled(false); 00204 LE_A.Clear(); 00205 LE_B.Clear(); 00206 LC_A.Clear(); 00207 LC_B.Clear(); 00208 00209 cout <<endl<< "******** Controller synthesis for compound AB." << endl; 00210 //calculate IO controller for plantAB 00211 HioController controllerAB; 00212 HioSynthHierarchical(shuffAB, envAB, specAB, intConstr_AB, LC_AB, LL_AB, controllerAB); 00213 controllerAB.Name("controllerAB"); 00214 controllerAB.SWrite(); 00215 controllerAB.Write("tmp_hio_cb_AB_controller.gen_rename"); 00216 00217 HioController controllerX2; 00218 00219 controllerAB.Version("AB_","CD_",controllerX); 00220 controllerX.Version("A_","C_",controllerX2); 00221 controllerX2.Version("B_","D_",controllerX); 00222 controllerX.Write("tmp_hio_cb_CD_controller.gen_rename"); 00223 00224 controllerAB.Version("AB_","EF_",controllerX); 00225 controllerX.Version("A_","E_",controllerX2); 00226 controllerX2.Version("B_","F_",controllerX); 00227 controllerX.Write("tmp_hio_cb_EF_controller.gen_rename"); 00228 00229 controllerAB.Version("AB_","GH_",controllerX); 00230 controllerX.Version("A_","G_",controllerX2); 00231 controllerX2.Version("B_","H_",controllerX); 00232 controllerX.Write("tmp_hio_cb_GH_controller.gen_rename"); 00233 00234 00235 00236 shuffAB.Clear(); 00237 envAB.Clear(); 00238 intConstr_AB.Clear(); 00239 00240 //###################################################################### 00241 //***** 00242 //***** plantABCD: I/O shuffle and composition with environment.***** 00243 //***** 00244 //###################################################################### 00245 00246 cout <<endl<< "******** IOshuffle of spec AB and spec CD." << endl; 00247 00248 // specCD from specAB 00249 HioPlant specCD; 00250 specAB.Version("AB_","CD_",specCD); 00251 specCD.Write("tmp_hio_cb_CD_spec.gen"); 00252 00253 // HioShuffle 00254 HioPlant shuffABCD; 00255 HioShuffle(specAB, specCD, shuffABCD); 00256 //specAB.Clear(); // needed later to create specABCD 00257 specCD.Clear(); 00258 StateMin(shuffABCD,shuffABCD); 00259 shuffABCD.Name("shuff ABCD"); 00260 shuffABCD.StateNamesEnabled(false); 00261 shuffABCD.SWrite(); 00262 shuffABCD.Write("tmp_hio_cb_ABCD_shuff.gen_rename"); 00263 00264 cout <<endl<< "******** environmentAB: read files, composition to environment model." << endl; 00265 //read environmentABCD: 00266 HioEnvironment envABCD1("data/5_conveyor_belts/ABCD_Env1.gen"); 00267 envABCD1.Write("tmp_hio_cb_ABCD_env1.gen"); 00268 HioEnvironment envABCD2("data/5_conveyor_belts/ABCD_Env_ABCDfreetr.gen"); 00269 envABCD2.Write("tmp_hio_cb_ABCD_env_freetr.gen"); 00270 HioEnvironment envABCD; 00271 aParallel(envABCD1,envABCD2,envABCD); 00272 envABCD2.Read("data/5_conveyor_belts/ABCD_Env_ABCDoccfl.gen"); 00273 envABCD2.Write("tmp_hio_cb_ABCD_env_occfl.gen"); 00274 aParallel(envABCD,envABCD2,envABCD); 00275 envABCD1.Clear(); 00276 envABCD2.Clear(); 00277 StateMin(envABCD,envABCD); 00278 envABCD.StateNamesEnabled(false); 00279 envABCD.Name("envABCD"); 00280 if(!IsHioEnvironmentForm(envABCD,errstr)) cout<<errstr; 00281 envABCD.SWrite(); 00282 envABCD.Write("tmp_hio_cb_ABCD_env.gen"); 00283 00284 /////////////////////////////////////////////////// 00285 // controller synthesis for plantABCD: 00286 /////////////////////////////////////////////////// 00287 00288 // specABCD: same as spec AB or spec CD, spec EF, spec GH 00289 HioPlant specABCD; 00290 specAB.Version("AB_","ABCD_",specABCD); 00291 specAB.Clear(); 00292 specABCD.Write("tmp_hio_cb_ABCD_spec.gen"); 00293 00294 // internal contraints: 00295 Generator LC_CD,LL_CD; 00296 LC_AB.Version("AB_","CD_",LC_CD); 00297 LL_AB.Version("AB_","CD_",LL_CD); 00298 00299 Generator intConstr_ABCD; 00300 Parallel(LC_AB,LC_CD,intConstr_ABCD); 00301 Parallel(intConstr_ABCD,LL_AB,intConstr_ABCD); 00302 Parallel(intConstr_ABCD,LL_CD,intConstr_ABCD); 00303 intConstr_ABCD.Name("intConstr_ABCD"); 00304 intConstr_ABCD.StateNamesEnabled(false); 00305 00306 // external constraints: 00307 Generator LC_ABCD,LL_ABCD; 00308 LC_AB.Version("AB_","ABCD_",LC_ABCD); 00309 LL_AB.Version("AB_","ABCD_",LL_ABCD); 00310 00311 //calculate IO controller for plantABCD 00312 00313 cout <<endl<< "******** Controller synthesis for compound ABCD." << endl; 00314 //calculate IO controller for plantABCD 00315 HioController controllerABCD; 00316 // caution: takes up to 2 hours! 00317 cout <<endl<< "**** Synthesis procedure is running - this can take about two hours! ..." << endl; 00318 //HioSynthHierarchical(shuffABCD, envABCD, specABCD, intConstr_ABCD, LC_ABCD, LL_ABCD, controllerABCD); 00319 controllerABCD.Name("controllerABCD"); 00320 controllerABCD.SWrite(); 00321 controllerABCD.Write("tmp_hio_cb_ABCD_controller.gen_rename"); 00322 controllerABCD.Read("tmp_hio_cb_ABCD_controller.gen_rename"); 00323 00324 shuffABCD.Clear(); 00325 envABCD.Clear(); 00326 intConstr_ABCD.Clear(); 00327 00328 controllerABCD.Version("ABCD_","EFGH_",controllerX); 00329 controllerX.Version("AB_","EF_",controllerX2); 00330 controllerX2.Version("CD_","GH_",controllerX); 00331 controllerX.Write("tmp_hio_cb_EFGH_controller.gen_rename"); 00332 00333 controllerABCD.Version("ABCD_","ABCDEFGH_",controllerX); 00334 controllerX.Version("CD_","EFGH_",controllerX2); 00335 controllerX2.Version("AB_","ABCD_",controllerX); 00336 controllerX.Write("tmp_hio_cb_ABCDEFGH_controller.gen_rename"); 00337 00338 cout << endl << "done."; 00339 00340 return 0; 00341 } 00342 00343 /** Run the tutorial */ 00344 int main() { 00345 // call simple machine example 00346 try { 00347 conveyor_belts(); 00348 } 00349 catch (Exception& e) { 00350 std::cout << "function: " << e.Where() << std::endl; 00351 std::cout << "exception description: " << e.What() << std::endl; 00352 std::cout << "exception id: " << e.Id() << std::endl; 00353 } 00354 return 0; 00355 } libFAUDES 2.23h --- 2014.04.03 --- c++ api documentaion by doxygen |