mpd-ref.edn

{:_id "mpd-ref",
 :_rev "6-b4475e103286fba67eb4ad849270841d",
 :Mp
 {:Date [{:Type "created", :Value "2020-01-11"}],
  :Name "wait",
  :Description
  "Simple measurement programm definition (mpd) which serves as a reference for documentation  and testing.",
  :Standard "NN",
  ;; -------------------------------------------------------
  ;; Exchange section 
  ;; -------------------------------------------------------
  ;; Endpoint for exchanging data and information.
  ;; Internal and external use is intendet. 
  :Exchange
  ;; one level deep nested values ..
  {:A {:Type "ref", :Unit "Pa", :Value 100.0},
   ;; .. or flat values are valid
   :B "token",
   :Target_pressure
   {:Selected 1,
    :Select [{:value 10.0} {:value 100.0} {:value 1000.0}],
    :Unit "Pa"},
   :Ref_gas
   {:Selected "N2",
    :Select
    [{:value "N2", :display "Stickstoff"}
     {:value "Ar", :display "Argon"}
     {:value "Ne", :display "Neon"}
     {:value "Kr", :display "Krypton"}
     {:value "Xe", :display "Xenon"}
     {:value "He", :display "Helium"}
     {:value "H2", :display "Wasserstoff"}],
    :Ready false}},
  ;; -------------------------------------------------------
  ;; Container section 
  ;; -------------------------------------------------------
  :Container
  [;; Containers are fixed sequences of things to do. 
   ;; In opposit to definitions containers have no conditions structure.
   
   ;; 0. container:
   {:Description "Container just waits parallel and sequential.",
    ;; The ctrl endpoint of the first container.
    ;; All values are ok. The values start, stop and mon will start stop and mon.
    ;; mon ... relaunch the container if all tasks are executed
    ;; void ... just some value (as good as foo or bar), causes no action.
    :Ctrl "ready",
    :Title "multiple wait tasks",
    ;; Element is inteded for filtering the exchange interface:
    ;; which elements should be vissible at a gui of this
    ;; container
    :Element ["A"],
    ;; The definition of what schould happen after what.
    ;; The "array of arrays"-structure controlls what happens 
    ;; parallel and what sequential.
    :Definition
    [
     ;; First: start a wait task with 1000 ms waittime.
     ;; At the same time start a wait task with 2000 ms waittime.
     [{:TaskName "Common-wait", :Replace {"@waittime" 1000}}
      {:TaskName "Common-wait", :Replace {"@waittime" 2000}}]
     [
      ;; After first step is executed: start 4 wait tasks 
      ;; with 100 ms waittime, step is executed within 1000ms
      {:TaskName "Common-wait", :Replace {"@waittime" 1000}}
      {:TaskName "Common-wait", :Replace {"@waittime" 1000}}
      {:TaskName "Common-wait", :Replace {"@waittime" 1000}}
      {:TaskName "Common-wait", :Replace {"@waittime" 1000}}]
     [{:TaskName "Common-wait", :Replace {"@waittime" 2000}}]]}
   {  ;; 1. container
    :Description "Container with one task only",
    :Ctrl "ready",
    :Title "container with single task",
    :Element ["Target_pressure"],
    :Definition
    [[{:TaskName "Common-wait", :Replace {"@waittime" 1000}}]]}
   ;; 2. container   
   {:Description "Show case select feature",
    :Ctrl "ready",
    :Title "choose definition, run it",
    :Element [],
    :Definition
    [[{:TaskName "Common-select_definition",
       :Replace {"@definitionclass" "wait"}}]]}
   ;; 3. container
   {:Description "Run a mpd (first container of ref).",
    :Ctrl "ready",
    :Title "run 1st container",
    :Element ["Ref_gas"],
    :Definition
    [[{:TaskName "Common-run_mp",
       :Replace
       {"@conttitle" "multiple wait tasks" "@mpdef" "mpd-ref"}}]]}
   ;; 4. container
   {:Description "Test read_exchange action.",
    :Ctrl "ready",
    :Title "read exchange.",
    :Element [],
    :Definition
    [[{:TaskName "Common-simple_read_element",
       :Replace
       {"@docpath" "Measurement.Values.Pressure", "@exchpath" "A"}}]]}
   ;; 5. container
   {:Description "Test anselm request.",
    :Ctrl "ready",
    :Title "anselm.",
    :Element [],
    :Definition [[{:TaskName "Common-anselm_get_dut_max"}]]}
   ;; 6. container
   {:Description
    "Test date and time and the ability to parallel write to database docs.",
    :Ctrl "ready",
    :Title "date & time",
    :Element [],
    :Definition
    [[{:TaskName "Common-get_date",
       :Replace
       {"@docpath" "Calibration.Measurement.Date"
        "@type" "tethys-test"}}
      {:TaskName "Common-get_time",
       :Replace
       {"@docpath" "Calibration.Measurement.AuxValues.Time"
        "@type" "tethys-test"}}]]}
   ;; 7. container
   {:Description "Message test.",
    :Ctrl "ready",
    :Title "message",
    :Element [],
    :Definition
    [[{:TaskName "Common-message",
       :Replace {"@message" "Lorem ipsum dolor sit amet."}}]]}
   ;; 8. container
   {:Description "Add a document.",
    :Ctrl "ready",
    :Title "add doc.",
    :Element [],
    :Definition
    [[{:TaskName "SE3_state-gen_state_doc"}]]}
   ;; 9. container
   {:Description "Write date to exchange interface.",
    :Ctrl "ready",
    :Title "write exchange",
    :Element [],
    :Definition
    [[{:TaskName "Common-exchange_value",
       :Replace {"@exchpath" "C", "@value" "done"}}]]}
   ;; 10. container
   {:Description "Replicate feature.",
    :Ctrl "ready",
    :Title "replicate",
    :Element [],
    :Definition
    [[{:TaskName "Common-db_replicate"}]]}
   ;; 11. container
   {:Description "Remove documents.",
    :Ctrl "ready",
    :Title "rm docs.",
    :Element [],
    :Definition
       [[{:TaskName "Common-rm_db_docs"}]]}],
  ;; -------------------------------------------------------
  ;; Definitions section 
  ;; -------------------------------------------------------
  :Definitions
  ;; Several definitions with the same
  ;; class (here wait) are possible.
  ;; At Runtime: the first of  matching 
   ;; (see condition section) definition is started.
  
  ;; 1st wait definition
  [{:DefinitionClass "wait",
    :ShortDescr "waits 0.1 and 0.2s\n",
    :Condition
    [{:ExchangePath "A.Unit", :Methode "eq", :Value "Pa"}
     {:ExchangePath "A.Value", :Methode "gt", :Value 133}],
    :Definition
    [[{:TaskName "Common-wait", :Replace {"@waittime" 100}}
      {:TaskName "Common-wait", :Replace {"@waittime" 200}}]]}
   ;; 2nd wait definition
   ;; The conditions of this match the predefined
   ;; exchange values (see :Exchange section above)
   {:DefinitionClass "wait",
    :ShortDescr "waits 0.3 and 0.4s\n",
    :Condition
    [{:ExchangePath "A.Unit", :Methode "eq", :Value "Pa"}
     {:ExchangePath "A.Value", :Methode "lt", :Value 133}],
    ;; The definition structure under definitions section 
    ;; works the same as under container
    :Definition
    [[{:TaskName "Common-wait", :Replace {"@waittime" 300}}
      {:TaskName "Common-wait", :Replace {"@waittime" 5000}}]]}
   ;; 3rd wait definition
   {:DefinitionClass "wait",
    :ShortDescr "waits 0.4 and 0.5s\n",
    :Condition
    [{:ExchangePath "A.Unit", :Methode "eq", :Value "Pa"}
     {:ExchangePath "A.Value", :Methode "lt", :Value 13}],
    :Definition
    [[{:TaskName "Common-wait", :Replace {"@waittime" 400}}
      {:TaskName "Common-wait", :Replace {"@waittime" 500}}]]}]
  ;; -------------------------------------------------------
  ;; Task section 
  ;; -------------------------------------------------------
 }}