hio_5_conveyor_belts.cpp

Go 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