From 0b2f3d520b164f3de9a70c21fd113e191ddc4bd2 Mon Sep 17 00:00:00 2001
From: Douglas Clowes <dcl@ansto.gov.au>
Date: Thu, 6 Nov 2014 13:36:47 +1100
Subject: [PATCH] Regen SCT drivers

---
 .../config/chopper/astrium_chopper_sct.tcl    | 24 ++++++---
 .../bilby/config/motors/shutters_sct.tcl      | 24 ++++++---
 .../bilby/config/motors/tank_sct.tcl          | 24 ++++++---
 .../config/environment/agilent_33220A_sct.tcl | 37 ++------------
 .../config/environment/hiden_xcs_sct.tcl      | 24 ++++++---
 .../config/environment/huber_pilot_sct.tcl    | 24 ++++++---
 .../config/environment/isotech_ps_sct.tcl     | 45 ++++++++++++----
 .../config/environment/keithley_m2700_sct.tcl | 24 ++++++---
 .../green_magnet_labview_sct.tcl              | 37 ++------------
 .../magneticField/oxford12tlv_sct.tcl         | 24 ++++++---
 .../environment/magneticField/tsi_smc_sct.tcl | 24 ++++++---
 .../config/environment/nhq_200_sct.tcl        | 24 ++++++---
 .../config/environment/omron_hldc_sct.tcl     | 24 ++++++---
 .../config/environment/protekmm_sct.tcl       | 24 ++++++---
 .../temperature/eurotherm_m2000_sct.tcl       | 24 ++++++---
 .../temperature/julabo_lh45_gen_sct.tcl       | 45 ++++++++++++----
 .../temperature/lakeshore_218_sct.tcl         | 24 ++++++---
 .../temperature/lakeshore_m370_sct.tcl        | 24 ++++++---
 .../environment/temperature/ls336_sct.tcl     | 24 ++++++---
 .../environment/temperature/ls340_sct.tcl     | 51 +++++++++++++++----
 .../temperature/mercury_base_sct.tcl          | 24 ++++++---
 .../temperature/mercury_level_sct.tcl         | 24 ++++++---
 .../temperature/mercury_pres_sct.tcl          | 24 ++++++---
 .../temperature/mercury_scpi_sct.tcl          | 24 ++++++---
 .../temperature/mercury_temp_sct.tcl          | 24 ++++++---
 .../temperature/mercury_valve_sct.tcl         | 24 ++++++---
 .../environment/temperature/nprvasm2_sct.tcl  | 24 ++++++---
 .../temperature/pfeiffer_hg_sct.tcl           | 24 ++++++---
 .../temperature/watlow_mpm_sct.tcl            | 24 ++++++---
 .../temperature/watlow_mrm_sct.tcl            | 24 ++++++---
 .../temperature/watlow_mst4_sct.tcl           | 24 ++++++---
 .../environment/temperature/west4100_sct.tcl  | 37 ++------------
 .../environment/temperature/west_6100_sct.tcl | 24 ++++++---
 .../config/source/reactor_status_sct.tcl      | 24 ++++++---
 34 files changed, 570 insertions(+), 354 deletions(-)

diff --git a/site_ansto/instrument/bilby/config/chopper/astrium_chopper_sct.tcl b/site_ansto/instrument/bilby/config/chopper/astrium_chopper_sct.tcl
index b081bbea..8e76275e 100644
--- a/site_ansto/instrument/bilby/config/chopper/astrium_chopper_sct.tcl
+++ b/site_ansto/instrument/bilby/config/chopper/astrium_chopper_sct.tcl
@@ -698,7 +698,7 @@ namespace eval ::scobj::astrium_chopper {
 
 proc add_astrium_chopper {name ip_address tcp_port} {
   set simulation_flag "[string tolower [SplitReply [chopper_simulation]]]"
-  ::scobj::astrium_chopper::add_driver ${name} "NXdisk_chopper" "${simulation_flag}" ${ip_address} ${tcp_port}
+  ::scobj::astrium_chopper::add_driver ${name} "NXdisk_chopper" ${simulation_flag} ${ip_address} ${tcp_port}
 }
 
 clientput "file evaluation of sct_astrium_chopper.tcl"
@@ -737,20 +737,31 @@ proc ::scobj::astrium_chopper::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -761,12 +772,9 @@ proc ::scobj::astrium_chopper::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue}
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
         }
       }
     }
diff --git a/site_ansto/instrument/bilby/config/motors/shutters_sct.tcl b/site_ansto/instrument/bilby/config/motors/shutters_sct.tcl
index 7bbf5a24..64ebbcdb 100644
--- a/site_ansto/instrument/bilby/config/motors/shutters_sct.tcl
+++ b/site_ansto/instrument/bilby/config/motors/shutters_sct.tcl
@@ -328,7 +328,7 @@ namespace eval ::scobj::shutters {
 
 proc add_shutters {name ip_address tcp_port} {
   set simulation_flag "[string tolower [SplitReply [motor_simulation]]]"
-  ::scobj::shutters::add_driver ${name} "instrument" "${simulation_flag}" ${ip_address} ${tcp_port}
+  ::scobj::shutters::add_driver ${name} "instrument" ${simulation_flag} ${ip_address} ${tcp_port}
 }
 
 clientput "file evaluation of sct_shutters.tcl"
@@ -367,20 +367,31 @@ proc ::scobj::shutters::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} dmc2280 ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -391,12 +402,9 @@ proc ::scobj::shutters::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue}
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
         }
       }
     }
diff --git a/site_ansto/instrument/bilby/config/motors/tank_sct.tcl b/site_ansto/instrument/bilby/config/motors/tank_sct.tcl
index 3e0fd483..201d5704 100644
--- a/site_ansto/instrument/bilby/config/motors/tank_sct.tcl
+++ b/site_ansto/instrument/bilby/config/motors/tank_sct.tcl
@@ -386,7 +386,7 @@ namespace eval ::scobj::tank {
 
 proc add_tank {name ip_address tcp_port} {
   set simulation_flag "[string tolower [SplitReply [motor_simulation]]]"
-  ::scobj::tank::add_driver ${name} "instrument" "${simulation_flag}" ${ip_address} ${tcp_port}
+  ::scobj::tank::add_driver ${name} "instrument" ${simulation_flag} ${ip_address} ${tcp_port}
 }
 
 clientput "file evaluation of sct_tank.tcl"
@@ -425,20 +425,31 @@ proc ::scobj::tank::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} dmc2280 ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -449,12 +460,9 @@ proc ::scobj::tank::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue}
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/agilent_33220A_sct.tcl b/site_ansto/instrument/config/environment/agilent_33220A_sct.tcl
index 1b335090..8cb0a7e8 100644
--- a/site_ansto/instrument/config/environment/agilent_33220A_sct.tcl
+++ b/site_ansto/instrument/config/environment/agilent_33220A_sct.tcl
@@ -60,7 +60,7 @@ namespace eval ::scobj::agilent_33220A {
 
 proc add_agilent_33220A {name ip_address tcp_port} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::agilent_33220A::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port}
+  ::scobj::agilent_33220A::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port}
 }
 
 clientput "file evaluation of sct_agilent_33220A.tcl"
@@ -96,39 +96,8 @@ proc ::scobj::agilent_33220A::read_config {} {
           continue
         }
         if { [string equal -nocase [dict get $v "driver"] "agilent_33220A"] } {
-          if { ![string equal -nocase "${simulation_flag}" "false"] } {
-            set asyncqueue "null"
-            ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
-          } elseif { [dict exists $v "asyncqueue"] } {
-            set asyncqueue [dict get $v "asyncqueue"]
-            if { [string equal -nocase ${asyncqueue} "sct"] } {
-              set ip_address [dict get $v ip]
-              set tcp_port [dict get $v port]
-              }
-          } else {
-            if { [dict exists $v "asyncprotocol"] } {
-              set asyncprotocol [dict get $v "asyncprotocol"]
-            } else {
-              set asyncprotocol ${name}_protocol
-              MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
-                ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
-                ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
-              }
-            }
-            set asyncqueue ${name}_queue
-            set ip_address [dict get $v ip]
-            set tcp_port [dict get $v port]
-            MakeAsyncQueue ${asyncqueue} ${asyncprotocol} ${ip_address} ${tcp_port}
-            if { [dict exists $v "timeout"] } {
-              ${asyncqueue} timeout "[dict get $v "timeout"]"
-            }
-          }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue}
-          }
+          ::scobj::agilent_33220A::sics_log 9 "No sctcontroller for agilent_33220A"
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/hiden_xcs_sct.tcl b/site_ansto/instrument/config/environment/hiden_xcs_sct.tcl
index 6886500c..ff6d80cf 100644
--- a/site_ansto/instrument/config/environment/hiden_xcs_sct.tcl
+++ b/site_ansto/instrument/config/environment/hiden_xcs_sct.tcl
@@ -1273,7 +1273,7 @@ namespace eval ::scobj::hiden_xcs {
 
 proc add_hiden_xcs {name ip_address tcp_port id} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::hiden_xcs::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${id}"
+  ::scobj::hiden_xcs::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id}
 }
 
 clientput "file evaluation of sct_hiden_xcs.tcl"
@@ -1312,20 +1312,31 @@ proc ::scobj::hiden_xcs::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -1336,6 +1347,7 @@ proc ::scobj::hiden_xcs::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -1352,11 +1364,7 @@ proc ::scobj::hiden_xcs::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/huber_pilot_sct.tcl b/site_ansto/instrument/config/environment/huber_pilot_sct.tcl
index 5c7239e8..9b355eb6 100644
--- a/site_ansto/instrument/config/environment/huber_pilot_sct.tcl
+++ b/site_ansto/instrument/config/environment/huber_pilot_sct.tcl
@@ -526,7 +526,7 @@ namespace eval ::scobj::huber_pilot {
 
 proc add_huber_pilot {name ip_address tcp_port} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::huber_pilot::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port}
+  ::scobj::huber_pilot::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port}
 }
 
 clientput "file evaluation of sct_huber_pilot.tcl"
@@ -565,20 +565,31 @@ proc ::scobj::huber_pilot::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -589,12 +600,9 @@ proc ::scobj::huber_pilot::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue}
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/isotech_ps_sct.tcl b/site_ansto/instrument/config/environment/isotech_ps_sct.tcl
index 7026be6d..a89a0246 100644
--- a/site_ansto/instrument/config/environment/isotech_ps_sct.tcl
+++ b/site_ansto/instrument/config/environment/isotech_ps_sct.tcl
@@ -349,8 +349,8 @@ proc ::scobj::isotech_ps::add_driver {name device_class simulation_flag ip_addre
         ::scobj::isotech_ps::sics_log 9 "makesctcontroller sct_${name} aqadapter ${tcp_port}"
         makesctcontroller sct_${name} aqadapter ${tcp_port}
       } else {
-        ::scobj::isotech_ps::sics_log 9 "makesctcontroller sct_${name} std ${ip_address}:${tcp_port} \"\\r\""
-        makesctcontroller sct_${name} std ${ip_address}:${tcp_port} "\r"
+        ::scobj::isotech_ps::sics_log 9 "makesctcontroller sct_${name} std ${ip_address}:${tcp_port} \\r"
+        makesctcontroller sct_${name} std ${ip_address}:${tcp_port} \r
       }
     } else {
       ::scobj::isotech_ps::sics_log 9 "simulation_flag=${simulation_flag} => Null sctcontroller for isotech_ps"
@@ -373,7 +373,7 @@ namespace eval ::scobj::isotech_ps {
 
 proc add_isotech_ps {name ip_address tcp_port} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::isotech_ps::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port}
+  ::scobj::isotech_ps::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port}
 }
 
 clientput "file evaluation of sct_isotech_ps.tcl"
@@ -412,20 +412,50 @@ proc ::scobj::isotech_ps::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
+              set arg_list [list]
+              set missing_list [list]
+              array unset default_map
+              array set default_map [list terminator \r]
+              foreach arg {terminator} {
+                if {[dict exists $u $arg]} {
+                  lappend arg_list "[dict get $u $arg]"
+                } elseif {[dict exists $v $arg]} {
+                  lappend arg_list "[dict get $v $arg]"
+                } elseif {[info exists default_map($arg)]} {
+                  lappend arg_list $default_map($arg)
+                } else {
+                  ${ns}::sics_log 9 "Missing configuration value $arg"
+                  lappend missing_list $arg
+                }
               }
+              if { [llength $missing_list] > 0 } {
+                  error "$name is missing configuration values $missing_list"
+              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port} {*}$arg_list
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -436,12 +466,9 @@ proc ::scobj::isotech_ps::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue}
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/keithley_m2700_sct.tcl b/site_ansto/instrument/config/environment/keithley_m2700_sct.tcl
index a8194864..f5143cd9 100644
--- a/site_ansto/instrument/config/environment/keithley_m2700_sct.tcl
+++ b/site_ansto/instrument/config/environment/keithley_m2700_sct.tcl
@@ -80,7 +80,7 @@ namespace eval ::scobj::keithley_m2700 {
 
 proc add_keithley_m2700 {name ip_address tcp_port id datype tol} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::keithley_m2700::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${id}" "${datype}" "${tol}"
+  ::scobj::keithley_m2700::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${datype} ${tol}
 }
 
 clientput "file evaluation of sct_keithley_m2700.tcl"
@@ -119,20 +119,31 @@ proc ::scobj::keithley_m2700::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -143,6 +154,7 @@ proc ::scobj::keithley_m2700::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -159,11 +171,7 @@ proc ::scobj::keithley_m2700::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/magneticField/green_magnet_labview_sct.tcl b/site_ansto/instrument/config/environment/magneticField/green_magnet_labview_sct.tcl
index d7fa10d9..3b101371 100644
--- a/site_ansto/instrument/config/environment/magneticField/green_magnet_labview_sct.tcl
+++ b/site_ansto/instrument/config/environment/magneticField/green_magnet_labview_sct.tcl
@@ -66,7 +66,7 @@ namespace eval ::scobj::green_magnet_labview {
 
 proc add_green_magnet_labview {name ip_address tcp_port} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::green_magnet_labview::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port}
+  ::scobj::green_magnet_labview::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port}
 }
 
 clientput "file evaluation of sct_green_magnet_labview.tcl"
@@ -102,39 +102,8 @@ proc ::scobj::green_magnet_labview::read_config {} {
           continue
         }
         if { [string equal -nocase [dict get $v "driver"] "green_magnet_labview"] } {
-          if { ![string equal -nocase "${simulation_flag}" "false"] } {
-            set asyncqueue "null"
-            ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
-          } elseif { [dict exists $v "asyncqueue"] } {
-            set asyncqueue [dict get $v "asyncqueue"]
-            if { [string equal -nocase ${asyncqueue} "sct"] } {
-              set ip_address [dict get $v ip]
-              set tcp_port [dict get $v port]
-              }
-          } else {
-            if { [dict exists $v "asyncprotocol"] } {
-              set asyncprotocol [dict get $v "asyncprotocol"]
-            } else {
-              set asyncprotocol ${name}_protocol
-              MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
-                ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
-                ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
-              }
-            }
-            set asyncqueue ${name}_queue
-            set ip_address [dict get $v ip]
-            set tcp_port [dict get $v port]
-            MakeAsyncQueue ${asyncqueue} ${asyncprotocol} ${ip_address} ${tcp_port}
-            if { [dict exists $v "timeout"] } {
-              ${asyncqueue} timeout "[dict get $v "timeout"]"
-            }
-          }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue}
-          }
+          ::scobj::green_magnet_labview::sics_log 9 "No sctcontroller for green_magnet_labview"
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/magneticField/oxford12tlv_sct.tcl b/site_ansto/instrument/config/environment/magneticField/oxford12tlv_sct.tcl
index a9848bc8..ddafe965 100644
--- a/site_ansto/instrument/config/environment/magneticField/oxford12tlv_sct.tcl
+++ b/site_ansto/instrument/config/environment/magneticField/oxford12tlv_sct.tcl
@@ -85,7 +85,7 @@ namespace eval ::scobj::oxford12tlv {
 
 proc add_oxford12tlv {name ip_address tcp_port id datype interval} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::oxford12tlv::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${id}" "${datype}" "${interval}"
+  ::scobj::oxford12tlv::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${datype} ${interval}
 }
 
 clientput "file evaluation of sct_oxford12tlv.tcl"
@@ -124,20 +124,31 @@ proc ::scobj::oxford12tlv::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -148,6 +159,7 @@ proc ::scobj::oxford12tlv::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -164,11 +176,7 @@ proc ::scobj::oxford12tlv::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/magneticField/tsi_smc_sct.tcl b/site_ansto/instrument/config/environment/magneticField/tsi_smc_sct.tcl
index 0f0b4b2b..17a8f3f2 100644
--- a/site_ansto/instrument/config/environment/magneticField/tsi_smc_sct.tcl
+++ b/site_ansto/instrument/config/environment/magneticField/tsi_smc_sct.tcl
@@ -619,7 +619,7 @@ namespace eval ::scobj::tsi_smc {
 
 proc add_tsi_smc {name ip_address tcp_port {id 1}} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::tsi_smc::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${{id}" "${1}}"
+  ::scobj::tsi_smc::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id}
 }
 
 clientput "file evaluation of sct_tsi_smc.tcl"
@@ -658,20 +658,31 @@ proc ::scobj::tsi_smc::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -682,6 +693,7 @@ proc ::scobj::tsi_smc::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -698,11 +710,7 @@ proc ::scobj::tsi_smc::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/nhq_200_sct.tcl b/site_ansto/instrument/config/environment/nhq_200_sct.tcl
index 0f191b3f..bd7be084 100644
--- a/site_ansto/instrument/config/environment/nhq_200_sct.tcl
+++ b/site_ansto/instrument/config/environment/nhq_200_sct.tcl
@@ -927,7 +927,7 @@ namespace eval ::scobj::nhq_200 {
 
 proc add_nhq_200 {name ip_address tcp_port} {
   set simulation_flag "[string tolower [SplitReply [detector_simulation]]]"
-  ::scobj::nhq_200::add_driver ${name} "NXdetector" "${simulation_flag}" ${ip_address} ${tcp_port}
+  ::scobj::nhq_200::add_driver ${name} "NXdetector" ${simulation_flag} ${ip_address} ${tcp_port}
 }
 
 clientput "file evaluation of sct_nhq_200.tcl"
@@ -966,20 +966,31 @@ proc ::scobj::nhq_200::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -990,12 +1001,9 @@ proc ::scobj::nhq_200::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue}
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/omron_hldc_sct.tcl b/site_ansto/instrument/config/environment/omron_hldc_sct.tcl
index 15c979f5..71abde15 100644
--- a/site_ansto/instrument/config/environment/omron_hldc_sct.tcl
+++ b/site_ansto/instrument/config/environment/omron_hldc_sct.tcl
@@ -291,7 +291,7 @@ namespace eval ::scobj::omron_hldc {
 
 proc add_omron_hldc {name ip_address tcp_port} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::omron_hldc::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port}
+  ::scobj::omron_hldc::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port}
 }
 
 clientput "file evaluation of sct_omron_hldc.tcl"
@@ -330,20 +330,31 @@ proc ::scobj::omron_hldc::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -354,12 +365,9 @@ proc ::scobj::omron_hldc::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue}
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/protekmm_sct.tcl b/site_ansto/instrument/config/environment/protekmm_sct.tcl
index f1fda9ee..e051dd3e 100644
--- a/site_ansto/instrument/config/environment/protekmm_sct.tcl
+++ b/site_ansto/instrument/config/environment/protekmm_sct.tcl
@@ -80,7 +80,7 @@ namespace eval ::scobj::protekmm {
 
 proc add_protekmm {name ip_address tcp_port id datype} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::protekmm::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${id}" "${datype}"
+  ::scobj::protekmm::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${datype}
 }
 
 clientput "file evaluation of sct_protekmm.tcl"
@@ -119,20 +119,31 @@ proc ::scobj::protekmm::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} protek608 ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -143,6 +154,7 @@ proc ::scobj::protekmm::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -159,11 +171,7 @@ proc ::scobj::protekmm::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/eurotherm_m2000_sct.tcl b/site_ansto/instrument/config/environment/temperature/eurotherm_m2000_sct.tcl
index fdee0377..ec24dde8 100644
--- a/site_ansto/instrument/config/environment/temperature/eurotherm_m2000_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/eurotherm_m2000_sct.tcl
@@ -80,7 +80,7 @@ namespace eval ::scobj::eurotherm_m2000 {
 
 proc add_eurotherm_m2000 {name ip_address tcp_port id datype dev_id tol} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::eurotherm_m2000::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${id}" "${datype}" "${dev_id}" "${tol}"
+  ::scobj::eurotherm_m2000::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${datype} ${dev_id} ${tol}
 }
 
 clientput "file evaluation of sct_eurotherm_m2000.tcl"
@@ -119,20 +119,31 @@ proc ::scobj::eurotherm_m2000::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -143,6 +154,7 @@ proc ::scobj::eurotherm_m2000::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -159,11 +171,7 @@ proc ::scobj::eurotherm_m2000::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/julabo_lh45_gen_sct.tcl b/site_ansto/instrument/config/environment/temperature/julabo_lh45_gen_sct.tcl
index 97c496b6..702f8967 100644
--- a/site_ansto/instrument/config/environment/temperature/julabo_lh45_gen_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/julabo_lh45_gen_sct.tcl
@@ -714,8 +714,8 @@ proc ::scobj::julabo_lh45_gen::add_driver {name device_class simulation_flag ip_
         ::scobj::julabo_lh45_gen::sics_log 9 "makesctcontroller sct_${name} aqadapter ${tcp_port}"
         makesctcontroller sct_${name} aqadapter ${tcp_port}
       } else {
-        ::scobj::julabo_lh45_gen::sics_log 9 "makesctcontroller sct_${name} std ${ip_address}:${tcp_port} \"\\r\""
-        makesctcontroller sct_${name} std ${ip_address}:${tcp_port} "\r"
+        ::scobj::julabo_lh45_gen::sics_log 9 "makesctcontroller sct_${name} std ${ip_address}:${tcp_port} \\r"
+        makesctcontroller sct_${name} std ${ip_address}:${tcp_port} \r
       }
     } else {
       ::scobj::julabo_lh45_gen::sics_log 9 "simulation_flag=${simulation_flag} => Null sctcontroller for julabo_lh45_gen"
@@ -738,7 +738,7 @@ namespace eval ::scobj::julabo_lh45_gen {
 
 proc add_julabo_lh45_gen {name ip_address tcp_port {id 1} {ctrl_sensor "bath"} {tol 5.0}} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::julabo_lh45_gen::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${{id}" "${1}}" "${{ctrl_sensor}" "${"bath"}}" "${{tol}" "${5.0}}"
+  ::scobj::julabo_lh45_gen::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${ctrl_sensor} ${tol}
 }
 
 clientput "file evaluation of sct_julabo_lh45_gen.tcl"
@@ -777,20 +777,50 @@ proc ::scobj::julabo_lh45_gen::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
+              set arg_list [list]
+              set missing_list [list]
+              array unset default_map
+              array set default_map [list terminator \r]
+              foreach arg {terminator} {
+                if {[dict exists $u $arg]} {
+                  lappend arg_list "[dict get $u $arg]"
+                } elseif {[dict exists $v $arg]} {
+                  lappend arg_list "[dict get $v $arg]"
+                } elseif {[info exists default_map($arg)]} {
+                  lappend arg_list $default_map($arg)
+                } else {
+                  ${ns}::sics_log 9 "Missing configuration value $arg"
+                  lappend missing_list $arg
+                }
               }
+              if { [llength $missing_list] > 0 } {
+                  error "$name is missing configuration values $missing_list"
+              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port} {*}$arg_list
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -801,6 +831,7 @@ proc ::scobj::julabo_lh45_gen::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -817,11 +848,7 @@ proc ::scobj::julabo_lh45_gen::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/lakeshore_218_sct.tcl b/site_ansto/instrument/config/environment/temperature/lakeshore_218_sct.tcl
index 06a5bcde..d0448846 100644
--- a/site_ansto/instrument/config/environment/temperature/lakeshore_218_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/lakeshore_218_sct.tcl
@@ -419,7 +419,7 @@ namespace eval ::scobj::lakeshore_218 {
 
 proc add_lakeshore_218 {name ip_address tcp_port} {
   set simulation_flag "[string tolower [SplitReply [detector_simulation]]]"
-  ::scobj::lakeshore_218::add_driver ${name} "NXdetector" "${simulation_flag}" ${ip_address} ${tcp_port}
+  ::scobj::lakeshore_218::add_driver ${name} "NXdetector" ${simulation_flag} ${ip_address} ${tcp_port}
 }
 
 clientput "file evaluation of sct_lakeshore_218.tcl"
@@ -458,20 +458,31 @@ proc ::scobj::lakeshore_218::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -482,12 +493,9 @@ proc ::scobj::lakeshore_218::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue}
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/lakeshore_m370_sct.tcl b/site_ansto/instrument/config/environment/temperature/lakeshore_m370_sct.tcl
index 45eaacc9..0199b9b1 100644
--- a/site_ansto/instrument/config/environment/temperature/lakeshore_m370_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/lakeshore_m370_sct.tcl
@@ -84,7 +84,7 @@ namespace eval ::scobj::lakeshore_m370 {
 
 proc add_lakeshore_m370 {name ip_address tcp_port id tol} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::lakeshore_m370::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${id}" "${tol}"
+  ::scobj::lakeshore_m370::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${tol}
 }
 
 clientput "file evaluation of sct_lakeshore_m370.tcl"
@@ -123,20 +123,31 @@ proc ::scobj::lakeshore_m370::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -147,6 +158,7 @@ proc ::scobj::lakeshore_m370::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -163,11 +175,7 @@ proc ::scobj::lakeshore_m370::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/ls336_sct.tcl b/site_ansto/instrument/config/environment/temperature/ls336_sct.tcl
index 27e7d7d8..380a46c3 100644
--- a/site_ansto/instrument/config/environment/temperature/ls336_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/ls336_sct.tcl
@@ -80,7 +80,7 @@ namespace eval ::scobj::ls336 {
 
 proc add_ls336 {name ip_address tcp_port id datype {tol1 1.0} {tol2 1.0}} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::ls336::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${id}" "${datype}" "${{tol1}" "${1.0}}" "${{tol2}" "${1.0}}"
+  ::scobj::ls336::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${datype} ${tol1} ${tol2}
 }
 
 clientput "file evaluation of sct_ls336.tcl"
@@ -119,20 +119,31 @@ proc ::scobj::ls336::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -143,6 +154,7 @@ proc ::scobj::ls336::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -159,11 +171,7 @@ proc ::scobj::ls336::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/ls340_sct.tcl b/site_ansto/instrument/config/environment/temperature/ls340_sct.tcl
index 8d5cfafc..40d3eb1e 100644
--- a/site_ansto/instrument/config/environment/temperature/ls340_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/ls340_sct.tcl
@@ -27,7 +27,7 @@ proc ::scobj::ls340::sics_log {debug_level debug_string} {
   } catch_message ]
 }
 
-proc ::scobj::ls340::mkDriver { sct_controller name device_class simulation_flag ip_address tcp_port id datype tol1 tol2 } {
+proc ::scobj::ls340::mkDriver { sct_controller name device_class simulation_flag ip_address tcp_port id datype {tol1 1.0} {tol2 1.0} } {
   ::scobj::ls340::sics_log 9 "::scobj::ls340::mkDriver ${sct_controller} ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${datype} ${tol1} ${tol2}"
   set ns "[namespace current]"
   set catch_status [ catch {
@@ -56,8 +56,8 @@ proc ::scobj::ls340::add_driver {name device_class simulation_flag ip_address tc
         ::scobj::ls340::sics_log 9 "makesctcontroller sct_${name} aqadapter ${tcp_port}"
         makesctcontroller sct_${name} aqadapter ${tcp_port}
       } else {
-        ::scobj::ls340::sics_log 9 "makesctcontroller sct_${name} std ${ip_address}:${tcp_port}"
-        makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+        ::scobj::ls340::sics_log 9 "makesctcontroller sct_${name} std ${ip_address}:${tcp_port} \\r\\n"
+        makesctcontroller sct_${name} std ${ip_address}:${tcp_port} \r\n
       }
     } else {
       ::scobj::ls340::sics_log 9 "simulation_flag=${simulation_flag} => Null sctcontroller for ls340"
@@ -80,7 +80,7 @@ namespace eval ::scobj::ls340 {
 
 proc add_ls340 {name ip_address tcp_port id datype {tol1 1.0} {tol2 1.0}} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::ls340::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${id}" "${datype}" "${{tol1}" "${1.0}}" "${{tol2}" "${1.0}}"
+  ::scobj::ls340::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${datype} ${tol1} ${tol2}
 }
 
 clientput "file evaluation of sct_ls340.tcl"
@@ -119,20 +119,50 @@ proc ::scobj::ls340::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
+              set arg_list [list]
+              set missing_list [list]
+              array unset default_map
+              array set default_map [list terminator \r\n]
+              foreach arg {terminator} {
+                if {[dict exists $u $arg]} {
+                  lappend arg_list "[dict get $u $arg]"
+                } elseif {[dict exists $v $arg]} {
+                  lappend arg_list "[dict get $v $arg]"
+                } elseif {[info exists default_map($arg)]} {
+                  lappend arg_list $default_map($arg)
+                } else {
+                  ${ns}::sics_log 9 "Missing configuration value $arg"
+                  lappend missing_list $arg
+                }
               }
+              if { [llength $missing_list] > 0 } {
+                  error "$name is missing configuration values $missing_list"
+              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port} {*}$arg_list
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -143,14 +173,19 @@ proc ::scobj::ls340::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
+          array unset default_map
+          array set default_map [list tol1 1.0 tol2 1.0]
           foreach arg {id datype tol1 tol2} {
             if {[dict exists $u $arg]} {
               lappend arg_list "[dict get $u $arg]"
             } elseif {[dict exists $v $arg]} {
               lappend arg_list "[dict get $v $arg]"
+            } elseif {[info exists default_map($arg)]} {
+              lappend arg_list $default_map($arg)
             } else {
               ${ns}::sics_log 9 "Missing configuration value $arg"
               lappend missing_list $arg
@@ -159,11 +194,7 @@ proc ::scobj::ls340::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/mercury_base_sct.tcl b/site_ansto/instrument/config/environment/temperature/mercury_base_sct.tcl
index 91a8e4e9..65aae3fc 100644
--- a/site_ansto/instrument/config/environment/temperature/mercury_base_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/mercury_base_sct.tcl
@@ -661,7 +661,7 @@ namespace eval ::scobj::mercury_base {
 
 proc add_mercury_base {name ip_address tcp_port {id 99} {tol 1}} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::mercury_base::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${{id}" "${99}}" "${{tol}" "${1}}"
+  ::scobj::mercury_base::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${tol}
 }
 
 clientput "file evaluation of sct_mercury_base.tcl"
@@ -700,20 +700,31 @@ proc ::scobj::mercury_base::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -724,6 +735,7 @@ proc ::scobj::mercury_base::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -740,11 +752,7 @@ proc ::scobj::mercury_base::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/mercury_level_sct.tcl b/site_ansto/instrument/config/environment/temperature/mercury_level_sct.tcl
index 05782d1b..8f59ed96 100644
--- a/site_ansto/instrument/config/environment/temperature/mercury_level_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/mercury_level_sct.tcl
@@ -243,7 +243,7 @@ namespace eval ::scobj::mercury_level {
 
 proc add_mercury_level {name ip_address tcp_port {id 99}} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::mercury_level::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${{id}" "${99}}"
+  ::scobj::mercury_level::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id}
 }
 
 clientput "file evaluation of sct_mercury_level.tcl"
@@ -282,20 +282,31 @@ proc ::scobj::mercury_level::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -306,6 +317,7 @@ proc ::scobj::mercury_level::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -322,11 +334,7 @@ proc ::scobj::mercury_level::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/mercury_pres_sct.tcl b/site_ansto/instrument/config/environment/temperature/mercury_pres_sct.tcl
index c7a8e102..cedc0894 100644
--- a/site_ansto/instrument/config/environment/temperature/mercury_pres_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/mercury_pres_sct.tcl
@@ -421,7 +421,7 @@ namespace eval ::scobj::mercury_pres {
 
 proc add_mercury_pres {name ip_address tcp_port {id 99} {tol 1}} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::mercury_pres::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${{id}" "${99}}" "${{tol}" "${1}}"
+  ::scobj::mercury_pres::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${tol}
 }
 
 clientput "file evaluation of sct_mercury_pres.tcl"
@@ -460,20 +460,31 @@ proc ::scobj::mercury_pres::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -484,6 +495,7 @@ proc ::scobj::mercury_pres::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -500,11 +512,7 @@ proc ::scobj::mercury_pres::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/mercury_scpi_sct.tcl b/site_ansto/instrument/config/environment/temperature/mercury_scpi_sct.tcl
index ceeaaad3..8def6080 100644
--- a/site_ansto/instrument/config/environment/temperature/mercury_scpi_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/mercury_scpi_sct.tcl
@@ -929,7 +929,7 @@ namespace eval ::scobj::mercury_scpi {
 
 proc add_mercury_scpi {name ip_address tcp_port {id 99} {permlink LT} {tol 1} {valve_tol 2}} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::mercury_scpi::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${{id}" "${99}}" "${{permlink}" "${LT}}" "${{tol}" "${1}}" "${{valve_tol}" "${2}}"
+  ::scobj::mercury_scpi::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${permlink} ${tol} ${valve_tol}
 }
 
 clientput "file evaluation of sct_mercury_scpi.tcl"
@@ -968,20 +968,31 @@ proc ::scobj::mercury_scpi::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -992,6 +1003,7 @@ proc ::scobj::mercury_scpi::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -1008,11 +1020,7 @@ proc ::scobj::mercury_scpi::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/mercury_temp_sct.tcl b/site_ansto/instrument/config/environment/temperature/mercury_temp_sct.tcl
index 7a3ca99b..731d88c1 100644
--- a/site_ansto/instrument/config/environment/temperature/mercury_temp_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/mercury_temp_sct.tcl
@@ -435,7 +435,7 @@ namespace eval ::scobj::mercury_temp {
 
 proc add_mercury_temp {name ip_address tcp_port {id 99} {tol 1}} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::mercury_temp::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${{id}" "${99}}" "${{tol}" "${1}}"
+  ::scobj::mercury_temp::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${tol}
 }
 
 clientput "file evaluation of sct_mercury_temp.tcl"
@@ -474,20 +474,31 @@ proc ::scobj::mercury_temp::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -498,6 +509,7 @@ proc ::scobj::mercury_temp::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -514,11 +526,7 @@ proc ::scobj::mercury_temp::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/mercury_valve_sct.tcl b/site_ansto/instrument/config/environment/temperature/mercury_valve_sct.tcl
index b792e5e8..690f3c37 100644
--- a/site_ansto/instrument/config/environment/temperature/mercury_valve_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/mercury_valve_sct.tcl
@@ -366,7 +366,7 @@ namespace eval ::scobj::mercury_valve {
 
 proc add_mercury_valve {name ip_address tcp_port {id 99} {valve_tol 2}} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::mercury_valve::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${{id}" "${99}}" "${{valve_tol}" "${2}}"
+  ::scobj::mercury_valve::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${valve_tol}
 }
 
 clientput "file evaluation of sct_mercury_valve.tcl"
@@ -405,20 +405,31 @@ proc ::scobj::mercury_valve::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -429,6 +440,7 @@ proc ::scobj::mercury_valve::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -445,11 +457,7 @@ proc ::scobj::mercury_valve::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/nprvasm2_sct.tcl b/site_ansto/instrument/config/environment/temperature/nprvasm2_sct.tcl
index 411f00ef..48ede97e 100644
--- a/site_ansto/instrument/config/environment/temperature/nprvasm2_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/nprvasm2_sct.tcl
@@ -80,7 +80,7 @@ namespace eval ::scobj::nprvasm2 {
 
 proc add_nprvasm2 {name ip_address tcp_port {tol 1.0}} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::nprvasm2::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${{tol}" "${1.0}}"
+  ::scobj::nprvasm2::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${tol}
 }
 
 clientput "file evaluation of sct_nprvasm2.tcl"
@@ -119,20 +119,31 @@ proc ::scobj::nprvasm2::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -143,6 +154,7 @@ proc ::scobj::nprvasm2::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -159,11 +171,7 @@ proc ::scobj::nprvasm2::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/pfeiffer_hg_sct.tcl b/site_ansto/instrument/config/environment/temperature/pfeiffer_hg_sct.tcl
index 5059f906..f31ce684 100644
--- a/site_ansto/instrument/config/environment/temperature/pfeiffer_hg_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/pfeiffer_hg_sct.tcl
@@ -524,7 +524,7 @@ namespace eval ::scobj::pfeiffer_hg {
 
 proc add_pfeiffer_hg {name ip_address tcp_port} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::pfeiffer_hg::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port}
+  ::scobj::pfeiffer_hg::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port}
 }
 
 clientput "file evaluation of sct_pfeiffer_hg.tcl"
@@ -563,20 +563,31 @@ proc ::scobj::pfeiffer_hg::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -587,12 +598,9 @@ proc ::scobj::pfeiffer_hg::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue}
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/watlow_mpm_sct.tcl b/site_ansto/instrument/config/environment/temperature/watlow_mpm_sct.tcl
index 48cc987b..cd63ec83 100644
--- a/site_ansto/instrument/config/environment/temperature/watlow_mpm_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/watlow_mpm_sct.tcl
@@ -80,7 +80,7 @@ namespace eval ::scobj::watlow_mpm {
 
 proc add_watlow_mpm {name ip_address tcp_port id datype dev_id tol} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::watlow_mpm::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${id}" "${datype}" "${dev_id}" "${tol}"
+  ::scobj::watlow_mpm::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${datype} ${dev_id} ${tol}
 }
 
 clientput "file evaluation of sct_watlow_mpm.tcl"
@@ -119,20 +119,31 @@ proc ::scobj::watlow_mpm::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -143,6 +154,7 @@ proc ::scobj::watlow_mpm::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -159,11 +171,7 @@ proc ::scobj::watlow_mpm::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/watlow_mrm_sct.tcl b/site_ansto/instrument/config/environment/temperature/watlow_mrm_sct.tcl
index 577fda50..cc20171d 100644
--- a/site_ansto/instrument/config/environment/temperature/watlow_mrm_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/watlow_mrm_sct.tcl
@@ -80,7 +80,7 @@ namespace eval ::scobj::watlow_mrm {
 
 proc add_watlow_mrm {name ip_address tcp_port id datype dev_id tol} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::watlow_mrm::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${id}" "${datype}" "${dev_id}" "${tol}"
+  ::scobj::watlow_mrm::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${datype} ${dev_id} ${tol}
 }
 
 clientput "file evaluation of sct_watlow_mrm.tcl"
@@ -119,20 +119,31 @@ proc ::scobj::watlow_mrm::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -143,6 +154,7 @@ proc ::scobj::watlow_mrm::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -159,11 +171,7 @@ proc ::scobj::watlow_mrm::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/watlow_mst4_sct.tcl b/site_ansto/instrument/config/environment/temperature/watlow_mst4_sct.tcl
index 7d0f2557..f3bbd5b9 100644
--- a/site_ansto/instrument/config/environment/temperature/watlow_mst4_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/watlow_mst4_sct.tcl
@@ -80,7 +80,7 @@ namespace eval ::scobj::watlow_mst4 {
 
 proc add_watlow_mst4 {name ip_address tcp_port id datype dev_id tol} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::watlow_mst4::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${id}" "${datype}" "${dev_id}" "${tol}"
+  ::scobj::watlow_mst4::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${datype} ${dev_id} ${tol}
 }
 
 clientput "file evaluation of sct_watlow_mst4.tcl"
@@ -119,20 +119,31 @@ proc ::scobj::watlow_mst4::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -143,6 +154,7 @@ proc ::scobj::watlow_mst4::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -159,11 +171,7 @@ proc ::scobj::watlow_mst4::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/west4100_sct.tcl b/site_ansto/instrument/config/environment/temperature/west4100_sct.tcl
index d72629bc..fa910d2d 100644
--- a/site_ansto/instrument/config/environment/temperature/west4100_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/west4100_sct.tcl
@@ -59,7 +59,7 @@ namespace eval ::scobj::west4100 {
 
 proc add_west4100 {name ip_address tcp_port dev_id} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::west4100::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${dev_id}"
+  ::scobj::west4100::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${dev_id}
 }
 
 clientput "file evaluation of sct_west4100.tcl"
@@ -95,34 +95,7 @@ proc ::scobj::west4100::read_config {} {
           continue
         }
         if { [string equal -nocase [dict get $v "driver"] "west4100"] } {
-          if { ![string equal -nocase "${simulation_flag}" "false"] } {
-            set asyncqueue "null"
-            ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
-          } elseif { [dict exists $v "asyncqueue"] } {
-            set asyncqueue [dict get $v "asyncqueue"]
-            if { [string equal -nocase ${asyncqueue} "sct"] } {
-              set ip_address [dict get $v ip]
-              set tcp_port [dict get $v port]
-              }
-          } else {
-            if { [dict exists $v "asyncprotocol"] } {
-              set asyncprotocol [dict get $v "asyncprotocol"]
-            } else {
-              set asyncprotocol ${name}_protocol
-              MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
-                ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
-                ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
-              }
-            }
-            set asyncqueue ${name}_queue
-            set ip_address [dict get $v ip]
-            set tcp_port [dict get $v port]
-            MakeAsyncQueue ${asyncqueue} ${asyncprotocol} ${ip_address} ${tcp_port}
-            if { [dict exists $v "timeout"] } {
-              ${asyncqueue} timeout "[dict get $v "timeout"]"
-            }
-          }
+          ::scobj::west4100::sics_log 9 "No sctcontroller for west4100"
           set arg_list [list]
           set missing_list [list]
           foreach arg {dev_id} {
@@ -138,11 +111,7 @@ proc ::scobj::west4100::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/environment/temperature/west_6100_sct.tcl b/site_ansto/instrument/config/environment/temperature/west_6100_sct.tcl
index df5a3576..70c3ee90 100644
--- a/site_ansto/instrument/config/environment/temperature/west_6100_sct.tcl
+++ b/site_ansto/instrument/config/environment/temperature/west_6100_sct.tcl
@@ -590,7 +590,7 @@ namespace eval ::scobj::west_6100 {
 
 proc add_west_6100 {name ip_address tcp_port dev_id} {
   set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
-  ::scobj::west_6100::add_driver ${name} "environment" "${simulation_flag}" ${ip_address} ${tcp_port} "${dev_id}"
+  ::scobj::west_6100::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${dev_id}
 }
 
 clientput "file evaluation of sct_west_6100.tcl"
@@ -629,20 +629,31 @@ proc ::scobj::west_6100::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} modbus_ap ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -653,6 +664,7 @@ proc ::scobj::west_6100::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
           set arg_list [list]
           set missing_list [list]
@@ -669,11 +681,7 @@ proc ::scobj::west_6100::read_config {} {
           if { [llength $missing_list] > 0 } {
               error "$name is missing configuration values $missing_list"
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue} {*}$arg_list
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list
         }
       }
     }
diff --git a/site_ansto/instrument/config/source/reactor_status_sct.tcl b/site_ansto/instrument/config/source/reactor_status_sct.tcl
index 14db0125..75b789f1 100644
--- a/site_ansto/instrument/config/source/reactor_status_sct.tcl
+++ b/site_ansto/instrument/config/source/reactor_status_sct.tcl
@@ -356,7 +356,7 @@ namespace eval ::scobj::reactor_status {
 
 proc add_reactor_status {name ip_address tcp_port} {
   set simulation_flag "[string tolower [SplitReply [opal_simulation]]]"
-  ::scobj::reactor_status::add_driver ${name} "NXsource" "${simulation_flag}" ${ip_address} ${tcp_port}
+  ::scobj::reactor_status::add_driver ${name} "NXsource" ${simulation_flag} ${ip_address} ${tcp_port}
 }
 
 clientput "file evaluation of sct_reactor_status.tcl"
@@ -395,20 +395,31 @@ proc ::scobj::reactor_status::read_config {} {
           if { ![string equal -nocase "${simulation_flag}" "false"] } {
             set asyncqueue "null"
             ${ns}::sics_log 9 "simulation_flag=${simulation_flag} => using null asyncqueue"
+            ${ns}::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
+            makesctcontroller sct_${name} aqadapter NULL
           } elseif { [dict exists $v "asyncqueue"] } {
             set asyncqueue [dict get $v "asyncqueue"]
             if { [string equal -nocase ${asyncqueue} "sct"] } {
               set ip_address [dict get $v ip]
               set tcp_port [dict get $v port]
-              }
+              makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
+            } else {
+              makesctcontroller sct_${name} aqadapter ${asyncqueue}
+            }
           } else {
             if { [dict exists $v "asyncprotocol"] } {
               set asyncprotocol [dict get $v "asyncprotocol"]
             } else {
               set asyncprotocol ${name}_protocol
               MakeAsyncProtocol ${asyncprotocol}
-              if { [dict exists $v "terminator"] } {
+              if { [dict exists $v "sendterminator"] } {
+                ${asyncprotocol} sendterminator "[dict get $v "sendterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} sendterminator "[dict get $v "terminator"]"
+              }
+              if { [dict exists $v "replyterminator"] } {
+                ${asyncprotocol} replyterminator "[dict get $v "replyterminator"]"
+              } elseif { [dict exists $v "terminator"] } {
                 ${asyncprotocol} replyterminator "[dict get $v "terminator"]"
               }
             }
@@ -419,12 +430,9 @@ proc ::scobj::reactor_status::read_config {} {
             if { [dict exists $v "timeout"] } {
               ${asyncqueue} timeout "[dict get $v "timeout"]"
             }
+            makesctcontroller sct_${name} aqadapter ${asyncqueue}
           }
-          if { [string equal -nocase ${asyncqueue} "sct"] } {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
-          } else {
-            ${ns}::add_driver ${name} ${device_class} ${simulation_flag} "aqadapter" ${asyncqueue}
-          }
+          ${ns}::mkDriver sct_${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port}
         }
       }
     }