Check for existence of config dict fields before using them in generated drivers

site_ansto/instrument/bilby/config/chopper/sct_astrium_chopper.tcl

@@ -569,12 +569,21 @@ proc ::scobj::astrium_chopper::read_config {} {
     set ns "::scobj::astrium_chopper"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "astrium_chopper" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "astrium_chopper"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [chopper_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[chopper_simulation] => using null asyncqueue"

site_ansto/instrument/bilby/config/motors/sct_shutters.tcl

@@ -307,12 +307,21 @@ proc ::scobj::shutters::read_config {} {
     set ns "::scobj::shutters"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "shutters" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "shutters"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [motor_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[motor_simulation] => using null asyncqueue"

site_ansto/instrument/bilby/config/motors/sct_tank.tcl

@@ -342,12 +342,21 @@ proc ::scobj::tank::read_config {} {
     set ns "::scobj::tank"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "tank" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "tank"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [motor_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[motor_simulation] => using null asyncqueue"

site_ansto/instrument/config/environment/sct_hiden_xcs.tcl

@@ -1156,12 +1156,21 @@ proc ::scobj::hiden_xcs::read_config {} {
     set ns "::scobj::hiden_xcs"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "hiden_xcs" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "hiden_xcs"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [environment_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[environment_simulation] => using null asyncqueue"

site_ansto/instrument/config/environment/sct_huber_pilot.tcl

@@ -460,12 +460,21 @@ proc ::scobj::huber_pilot::read_config {} {
     set ns "::scobj::huber_pilot"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "huber_pilot" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "huber_pilot"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [environment_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[environment_simulation] => using null asyncqueue"

site_ansto/instrument/config/environment/sct_isotech_ps.tcl

@@ -347,12 +347,21 @@ proc ::scobj::isotech_ps::read_config {} {
     set ns "::scobj::isotech_ps"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "isotech_ps" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "isotech_ps"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [environment_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[environment_simulation] => using null asyncqueue"

site_ansto/instrument/config/environment/sct_nhq_200.tcl

@@ -707,12 +707,21 @@ proc ::scobj::nhq_200::read_config {} {
     set ns "::scobj::nhq_200"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "nhq_200" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "nhq_200"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [environment_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[environment_simulation] => using null asyncqueue"

site_ansto/instrument/config/environment/sct_omron_hldc.tcl

@@ -274,12 +274,21 @@ proc ::scobj::omron_hldc::read_config {} {
     set ns "::scobj::omron_hldc"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "omron_hldc" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "omron_hldc"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [environment_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[environment_simulation] => using null asyncqueue"

site_ansto/instrument/config/environment/temperature/sct_lakeshore_218.tcl

@@ -340,12 +340,21 @@ proc ::scobj::lakeshore_218::read_config {} {
     set ns "::scobj::lakeshore_218"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "lakeshore_218" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "lakeshore_218"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [environment_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[environment_simulation] => using null asyncqueue"

site_ansto/instrument/config/environment/temperature/sct_mercury_base.tcl

@@ -550,12 +550,21 @@ proc ::scobj::mercury_base::read_config {} {
     set ns "::scobj::mercury_base"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "mercury_base" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "mercury_base"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [environment_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[environment_simulation] => using null asyncqueue"

site_ansto/instrument/config/environment/temperature/sct_mercury_level.tcl

@@ -227,12 +227,21 @@ proc ::scobj::mercury_level::read_config {} {
     set ns "::scobj::mercury_level"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "mercury_level" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "mercury_level"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [environment_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[environment_simulation] => using null asyncqueue"

site_ansto/instrument/config/environment/temperature/sct_mercury_pres.tcl

@@ -391,12 +391,21 @@ proc ::scobj::mercury_pres::read_config {} {
     set ns "::scobj::mercury_pres"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "mercury_pres" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "mercury_pres"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [environment_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[environment_simulation] => using null asyncqueue"

site_ansto/instrument/config/environment/temperature/sct_mercury_scpi.tcl

@@ -746,12 +746,21 @@ proc ::scobj::mercury_scpi::read_config {} {
     set ns "::scobj::mercury_scpi"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "mercury_scpi" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "mercury_scpi"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [environment_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[environment_simulation] => using null asyncqueue"

site_ansto/instrument/config/environment/temperature/sct_mercury_temp.tcl

@@ -396,12 +396,21 @@ proc ::scobj::mercury_temp::read_config {} {
     set ns "::scobj::mercury_temp"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "mercury_temp" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "mercury_temp"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [environment_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[environment_simulation] => using null asyncqueue"

site_ansto/instrument/config/environment/temperature/sct_mercury_valve.tcl

@@ -345,12 +345,21 @@ proc ::scobj::mercury_valve::read_config {} {
     set ns "::scobj::mercury_valve"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "mercury_valve" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "mercury_valve"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [environment_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[environment_simulation] => using null asyncqueue"

site_ansto/instrument/config/environment/temperature/sct_pfeiffer_hg.tcl

@@ -495,12 +495,21 @@ proc ::scobj::pfeiffer_hg::read_config {} {
     set ns "::scobj::pfeiffer_hg"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "pfeiffer_hg" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "pfeiffer_hg"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [environment_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[environment_simulation] => using null asyncqueue"

site_ansto/instrument/config/source/sct_reactor_status.tcl

@@ -346,12 +346,21 @@ proc ::scobj::reactor_status::read_config {} {
     set ns "::scobj::reactor_status"
     dict for {k v} $::config_dict {
       if { [dict exists $v "implementation"] } {
+        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
+          continue
+        }
         set name [dict get $v name]
         set enabled [string tolower [dict get $v "enabled"]]
         set implementation [dict get $v "implementation"]
+        if { !([dict exists $::config_dict $implementation]) } {
+          continue
+        }
         set v [dict get $::config_dict $implementation]
-        if { [dict get $v "driver"] == "reactor_status" } {
+        if { !([dict exists $v "driver"]) } {
-          if { [dict get $v enabled] } {
+          continue
+        }
+        if { [string equal -nocase [dict get $v "driver"] "reactor_status"] } {
+          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
             if { ![string equal -nocase [SplitReply [opal_simulation]] "false"] } {
               set asyncqueue "null"
               ${ns}::sics_log 9 "[opal_simulation] => using null asyncqueue"

site_ansto/instrument/util/gen_sct.py

@@ -1400,12 +1400,21 @@ def put_read_config(MyDriver):
   txt += ['    set ns "%s"' % MyDriver['namespace']]
   txt += ['    dict for {k v} $::config_dict {']
   txt += ['      if { [dict exists $v "implementation"] } {']
+  txt += ['        if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {']
+  txt += ['          continue']
+  txt += ['        }']
   txt += ['        set name [dict get $v name]']
   txt += ['        set enabled [string tolower [dict get $v "enabled"]]']
   txt += ['        set implementation [dict get $v "implementation"]']
+  txt += ['        if { !([dict exists $::config_dict $implementation]) } {']
+  txt += ['          continue']
+  txt += ['        }']
   txt += ['        set v [dict get $::config_dict $implementation]']
-  txt += ['        if { [dict get $v "driver"] == "%s" } {' % MyDriver['name']]
+  txt += ['        if { !([dict exists $v "driver"]) } {']
-  txt += ['          if { [dict get $v enabled] } {']
+  txt += ['          continue']
+  txt += ['        }']
+  txt += ['        if { [string equal -nocase [dict get $v "driver"] "%s"] } {' % MyDriver['name']]
+  txt += ['          if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {']
   txt += ['            if { ![string equal -nocase [SplitReply [%s]] "false"] } {' % MyDriver['simulation_group']]
   txt += ['              set asyncqueue "null"']
   txt += ['              ${ns}::sics_log 9 "[%s] => using null asyncqueue"' % MyDriver['simulation_group']]