diff --git a/site_ansto/instrument/config/beamline/sct_he3_polanal.tcl b/site_ansto/instrument/config/beamline/sct_he3_polanal.tcl index c16a6a23..89211c28 100644 --- a/site_ansto/instrument/config/beamline/sct_he3_polanal.tcl +++ b/site_ansto/instrument/config/beamline/sct_he3_polanal.tcl @@ -211,8 +211,8 @@ proc ::scobj::he3_polanal::mkDriver { sct_controller name device_class simulatio sicslist setatt ${name} long_name ${name} set scobj_hpath /sics/${name} - if {[string equal -nocase ${has_anal} "true"]} { + if {[string equal -nocase ${has_anal} "true"]} { hfactory ${scobj_hpath}/analyser plain spy none hfactory ${scobj_hpath}/analyser/amplitude plain user float @@ -314,8 +314,8 @@ proc ::scobj::he3_polanal::mkDriver { sct_controller name device_class simulatio hsetprop ${scobj_hpath}/analyser klass "@none" hsetprop ${scobj_hpath}/analyser type "part" } - if {[string equal -nocase ${has_anal} "true"]} { + if {[string equal -nocase ${has_anal} "true"]} { hfactory ${scobj_hpath}/analyser_start plain spy none hfactory ${scobj_hpath}/analyser_start/amplitude plain user float @@ -402,8 +402,8 @@ proc ::scobj::he3_polanal::mkDriver { sct_controller name device_class simulatio hsetprop ${scobj_hpath}/analyser_start klass "@none" hsetprop ${scobj_hpath}/analyser_start type "part" } - if {[string equal -nocase ${has_pol} "true"]} { + if {[string equal -nocase ${has_pol} "true"]} { hfactory ${scobj_hpath}/polariser plain spy none hfactory ${scobj_hpath}/polariser/amplitude plain user float @@ -505,8 +505,8 @@ proc ::scobj::he3_polanal::mkDriver { sct_controller name device_class simulatio hsetprop ${scobj_hpath}/polariser klass "@none" hsetprop ${scobj_hpath}/polariser type "part" } - if {[string equal -nocase ${has_pol} "true"]} { + if {[string equal -nocase ${has_pol} "true"]} { hfactory ${scobj_hpath}/polariser_start plain spy none hfactory ${scobj_hpath}/polariser_start/amplitude plain user float diff --git a/site_ansto/instrument/config/environment/temperature/sct_oxford_mercury.tcl b/site_ansto/instrument/config/environment/temperature/sct_oxford_mercury.tcl index 22ebad6b..a693a605 100644 --- a/site_ansto/instrument/config/environment/temperature/sct_oxford_mercury.tcl +++ b/site_ansto/instrument/config/environment/temperature/sct_oxford_mercury.tcl @@ -1,891 +1,1589 @@ -# vim: ts=8 sw=2 sta sts=2 et ai si -# This is a template driver for a mercury temperaure controller from Oxford Instruments +# Generated driver for oxford_mercury +# vim: ft=tcl tabstop=8 softtabstop=2 shiftwidth=2 nocindent smartindent # -# Author: Douglas Clowes -# Date: August 2012 -# -if { "[lindex [split [info nameofexecutable] "/"] end]" == "tclsh"} { -# This block is to suppress spurious error/warning messages when loaded in Nagelfar - set catch_status [ catch { - puts "TCLSH" - proc environment_simulation {} { return "" } - proc SplitReply {str} { return "" } - proc makesctcontroller {args} { } - proc MakeSICSObj {args} { } - proc sicslist {args} { } - proc hfactory {args} { } - proc hdelprop {args} { } - proc hsetprop {args} { } - proc hgetprop {args} { } - proc hpropexists {args} { } - proc hlistprop {args} { } - proc hset {args} { } - proc hget {args} { } - proc hval {args} { } - proc hinfo {args} { } - proc hlist {args} { } - proc sct {args} { } - proc debug_log {args} { } - proc pathname {args} { } - proc basename {args} { } - proc channel {args} { } - proc ns {args} { } - } catch_message ] - if {$catch_status != 0} { - puts "error in main $catch_message" - return -code error "in main $catch_message" - } + +namespace eval ::scobj::oxford_mercury { + set debug_threshold 5 +# preamble hook code starts + proc make_config {sct_controller} { + set syscat [${sct_controller} transact READ:SYS:CAT] + set result "" + set devs [regexp -inline -all {DEV:D[[:alnum:]\.]*:[[:alnum:]]*} ${syscat}] + foreach dev [lsort ${devs}] { + set typ [string index [lindex [split ${dev} :] end] 0] + set typ [string map {A V} ${typ}] + clientput "${dev} ${typ}" + set result "${result}${typ}" + } + clientput "Result: ${result}" + return ${result} + } +# preamble hook code ends } -set vendor "oxford" -set device "mercury" - -namespace eval ::scobj::[set vendor]_[set device] { - proc ns {} { - return "[namespace current]" - } - # All of this takes place in a namespace based on the vendor and device - # Debug prints and vendor/device save - clientput "Namespace: [namespace current]" - clientput "Vendor:[set vendor]" - clientput "Device:[set device]" - set [namespace current]::vendor [set ::vendor] - set [namespace current]::device [set ::device] - set [namespace current]::ven_dev "[set ::vendor]_[set ::device]" - clientput "[namespace current]::vendor [set [namespace current]::vendor]" - clientput "[namespace current]::device [set [namespace current]::device]" - clientput "[namespace current]::ven_dev [set [namespace current]::ven_dev]" - - proc debug_log {debug_level arg_string} { - # write a timestamped string message to a log file for debugging - set debug_threshold 0 - if {$debug_level >= $debug_threshold} { - set fd [open "[set [namespace current]::log_file]" "a"] - set line "[clock format [clock seconds] -format "%T"] $arg_string" - puts $fd "$line" - close $fd +proc ::scobj::oxford_mercury::debug_log {tc_root debug_level debug_string} { + set catch_status [ catch { + set debug_threshold [hgetpropval ${tc_root} debug_threshold] + if {${debug_level} >= ${debug_threshold}} { + set now [clock seconds] + set ts [clock format ${now} -format "%Y%m%d"] + set log_file_name "../log/oxford_mercury_[basename ${tc_root}]_${ts}.log" + set fd [open "${log_file_name}" "a"] + set ts [clock format ${now} -format "%T"] + puts ${fd} "${ts} ${debug_string}" + close ${fd} } - } + } catch_message ] +} - proc channel {arg} { - # strip the trailing digits from the arg and return them as a string - set result 0 - for { set i 0 } { $i < [string length $arg] } { incr i } { - if { ! [string match {[0-9]} [string index $arg end-$i]] } { - break +proc ::scobj::oxford_mercury::sics_log {debug_level debug_string} { + set catch_status [ catch { + set debug_threshold ${::scobj::oxford_mercury::debug_threshold} + if {${debug_level} >= ${debug_threshold}} { + sicslog "::scobj::oxford_mercury::${debug_string}" + } + } catch_message ] +} + +# checklimits function for driveable interface +proc ::scobj::oxford_mercury::checklimits {tc_root} { + set catch_status [ catch { + debug_log ${tc_root} 1 "checklimits tc_root=${tc_root} sct=[sct] target=[sct target]" + set setpoint [sct target] + if { [hpropexists [sct] lowerlimit] } { + set lolimit [sct lowerlimit] + } else { + # lowerlimit not set, use target + set lolimit [sct target] + } + if { [hpropexists [sct] upperlimit] } { + set hilimit [sct upperlimit] + } else { + # upperlimit not set, use target + set hilimit [sct target] + } +# checklimits hook code goes here + if { ${setpoint} < ${lolimit} || ${setpoint} > ${hilimit} } { + sct driving 0 + error "setpoint ${setpoint} violates limits (${lolimit}..${hilimit}) on [sct]" + } + return OK + } catch_message ] + handle_exception ${catch_status} ${catch_message} +} + +# check function for hset change +proc ::scobj::oxford_mercury::checkrange {tc_root} { + set catch_status [ catch { + debug_log ${tc_root} 1 "checkrange tc_root=${tc_root} sct=[sct] target=[sct target]" + set setpoint [sct target] + if { [hpropexists [sct] lowerlimit] } { + set lolimit [sct lowerlimit] + } else { + # lowerlimit not set, use target + set lolimit [sct target] + } + if { [hpropexists [sct] upperlimit] } { + set hilimit [sct upperlimit] + } else { + # upperlimit not set, use target + set hilimit [sct target] + } +# checkrange hook code goes here + if { ${setpoint} < ${lolimit} || ${setpoint} > ${hilimit} } { + error "setpoint ${setpoint} violates limits (${lolimit}..${hilimit}) on [sct]" + } + return OK + } catch_message ] + handle_exception ${catch_status} ${catch_message} +} + +# checkstatus function for driveable interface +proc ::scobj::oxford_mercury::checkstatus {tc_root} { + set catch_status [ catch { +# checkstatus hook code goes here + if {[sct driving]} { + set sp "[sct target]" + if {[hpropexists [sct] simulated] && [sct simulated] == "true"} { + set pv "${sp}" + hupdateif ${tc_root}/[sct driveable] ${sp} + } else { + set pv "[hval ${tc_root}/[sct driveable]]" } - set result [string range "$arg" end-$i end] + if { abs(${pv} - ${sp}) <= [sct tolerance] } { + if { [hpropexists [sct] settle_time] } { + if { [hpropexists [sct] settle_time_start] } { + if { [sct utime] - [sct settle_time_start] >= [sct settle_time]} { + sct driving 0 + return "idle" + } + return "busy" + } else { + sct utime settle_time_start + return "busy" + } + } + sct driving 0 + return "idle" + } + if { [hpropexists [sct] settle_time_start] } { + hdelprop [sct] settle_time_start + } + return "busy" + } else { + return "idle" } - debug_log 1 "Extract channel $result from argument $arg" - return $result - } + } catch_message ] + handle_exception ${catch_status} ${catch_message} +} - proc setPoint {tc_root nextState cmd} { - # send a command to set a value - debug_log 1 "setPoint tc_root=$tc_root sct=[sct] $cmd [sct target]" +# function to request the read of a parameter on a device +proc ::scobj::oxford_mercury::getValue {tc_root nextState cmd_str} { + set catch_status [ catch { + debug_log ${tc_root} 1 "getValue tc_root=${tc_root} sct=[sct] cmd=${cmd_str}" + if { [hpropexists [sct] geterror] } { + hdelprop [sct] geterror + } + set cmd "${cmd_str}" +# getValue hook code goes here + debug_log ${tc_root} 1 "getValue sct send ${cmd}" + if {![string equal -nocase -length 10 ${cmd} "@@NOSEND@@"]} { + sct send "${cmd}" + } + return ${nextState} + } catch_message ] + handle_exception ${catch_status} ${catch_message} +} + +# halt function for driveable interface +proc ::scobj::oxford_mercury::halt {tc_root} { + set catch_status [ catch { + debug_log ${tc_root} 1 "halt tc_root=${tc_root} sct=[sct] driving=[sct driving]" + ### TODO hset [sct] [hval [sct]] +# halt hook code goes here + sct driving 0 + return "idle" + } catch_message ] + handle_exception ${catch_status} ${catch_message} +} + +# function to check the write parameter on a device +proc ::scobj::oxford_mercury::noResponse {tc_root} { + set catch_status [ catch { + debug_log ${tc_root} 1 "noResponse tc_root=${tc_root} sct=[sct] resp=[sct result]" +# noResponse hook code goes here + return "idle" + } catch_message ] + handle_exception ${catch_status} ${catch_message} +} + +# function to parse the read of a parameter on a device +proc ::scobj::oxford_mercury::rdText {tc_root} { + set catch_status [ catch { + debug_log ${tc_root} 1 "rdText tc_root=${tc_root} sct=[sct] result=[sct result]" + if { [hpropexists [sct] geterror] } { + hdelprop [sct] geterror + } + set data [sct result] + set nextState "idle" + if {[string equal -nocase -length 7 ${data} "ASCERR:"]} { + # the protocol driver has reported an error + sct geterror "${data}" + error "[sct geterror]" + } +# rdText hook code starts + scan [lindex [split "$data" ":"] end] "%s" data +# rdText hook code ends + if { [hpropexists [sct] geterror] } { + debug_log ${tc_root} 9 "[sct] error: [sct geterror]" + error "[sct geterror]" + } + if { ${data} != [sct oldval] } { + debug_log ${tc_root} 1 "[sct] changed to new:${data}, from old:[sct oldval]" + sct oldval ${data} + sct update ${data} + sct utime readtime + } + return ${nextState} + } catch_message ] + handle_exception ${catch_status} ${catch_message} +} + +# function to parse the read of a parameter on a device +proc ::scobj::oxford_mercury::rdValue {tc_root} { + set catch_status [ catch { + debug_log ${tc_root} 1 "rdValue tc_root=${tc_root} sct=[sct] result=[sct result]" + if { [hpropexists [sct] geterror] } { + hdelprop [sct] geterror + } + set data [sct result] + set nextState "idle" + if {[string equal -nocase -length 7 ${data} "ASCERR:"]} { + # the protocol driver has reported an error + sct geterror "${data}" + error "[sct geterror]" + } +# rdValue hook code starts + set value [lindex [split "${data}" ":"] end] + if {[string equal -nocase [string index ${value} end] K]} { + set value [string range ${value} 0 end-1] + } + if {[string equal -nocase ${value} NaN]} { + set value 0 + } + if {[string equal -nocase ${value} inf] || [string equal -nocase ${value} -inf]} { + set value 0 + } + if {![string is double ${value}]} { + set value 0 + } + scan ${value} "%g" data +# rdValue hook code ends + if { [hpropexists [sct] geterror] } { + debug_log ${tc_root} 9 "[sct] error: [sct geterror]" + error "[sct geterror]" + } + if { ${data} != [sct oldval] } { + debug_log ${tc_root} 1 "[sct] changed to new:${data}, from old:[sct oldval]" + sct oldval ${data} + sct update ${data} + sct utime readtime + } + return ${nextState} + } catch_message ] + handle_exception ${catch_status} ${catch_message} +} + +# function to write a parameter value on a device +proc ::scobj::oxford_mercury::setPoint {tc_root nextState cmd_str} { + set catch_status [ catch { + debug_log ${tc_root} 1 "setPoint tc_root=${tc_root} sct=[sct] cmd=${cmd_str}" if { [hpropexists [sct] geterror] } { hdelprop [sct] geterror } set par [sct target] - set command "$cmd:$par" - - debug_log 1 "setPoint tc_root=$tc_root sct=[sct] Write $command" - sct send "$command" - sct driving 1 - sct time_check [clock seconds] - if {$par != [sct oldval]} { - sct oldval $par - sct update $par - sct utime readtime - debug_log 1 "setPoint: new data for $tc_root [sct] result=$par" - } - return $nextState - } - - proc chkWrite {tc_root} { - # process the response to the write - # - not all devices will respond to writes - set data [sct result] - debug_log 1 "chkWrite tc_root=$tc_root sct=[sct] resp=$data" - if {[string equal -nocase -length 7 $data "ASCERR:"]} { - # the protocol driver has reported an error - sct geterror "$data" - } elseif {[string equal -nocase -length 1 $data "?"]} { - # the device has reported an error - sct geterror "Error: $data" - } else { - # the write was successful, record the data - set data [sct target] - if {$data != [sct oldval]} { - sct oldval $data - sct update $data - sct utime readtime - debug_log 1 "chkWrite new data for $tc_root [sct] result=$data" + set cmd "${cmd_str}${par}" +# setPoint hook code goes here + if { [hpropexists [sct] driving] } { + if { [hpropexists [sct] writestatus] && [sct writestatus] == "start" } { + sct driving 1 } } - return idle - } - - proc noResponse {tc_root} { - set data "[sct result]" - debug_log 1 "noResponse tc_root=$tc_root sct=[sct] resp=$data" - return idle - } - - proc getValue {tc_root nextState cmd} { - # send a command to request a value - debug_log 1 "getValue tc_root=$tc_root sct=[sct] $cmd" - if { [hpropexists [sct] geterror] } { - hdelprop [sct] geterror + debug_log ${tc_root} 1 "setPoint sct send ${cmd}" + if {![string equal -nocase -length 10 ${cmd} "@@NOSEND@@"]} { + sct send "${cmd}" } - if { [string equal -nocase -length 4 "$cmd" "XXXX"] } { - set cmd "$cmd [channel [pathname [sct]]]" - } - debug_log 1 "getValue sct send $cmd" - sct send "$cmd" - return $nextState - } - - proc rdValue {tc_root} { - # process the received response to the read request - debug_log 1 "[ns]::rdValue tc_root=$tc_root sct=[sct] result=[sct result]" - set data [sct result] - if {[string equal -nocase -length 7 $data "ASCERR:"]} { - # the protocol driver has reported an error - sct geterror "$data" - } elseif {[string equal -nocase -length 1 $data "?"]} { - # the device has reported an error - sct geterror "Error: $data" - } else { - if { [string equal -nocase [basename [sct]] "XXXX"] } { - return "idle" - } - scan [lindex [split "$data" ":"] end] "%g" data - if {$data != [sct oldval]} { - debug_log 1 "[sct] changed to new:$data, from old:[sct oldval]" - sct oldval $data - sct update $data - sct utime readtime - } - } - return "idle" - } - - proc rdText {tc_root} { - # process the received response to the read request - debug_log 1 "[ns]::rdText tc_root=$tc_root sct=[sct] result=[sct result]" - set data [sct result] - if {[string equal -nocase -length 7 $data "ASCERR:"]} { - # the protocol driver has reported an error - sct geterror "$data" - } elseif {[string equal -nocase -length 1 $data "?"]} { - # the device has reported an error - sct geterror "Error: $data" - } else { - if { [string equal -nocase [basename [sct]] "XXXX"] } { - return "idle" - } - scan [lindex [split "$data" ":"] end] "%s" data - if {$data != [sct oldval]} { - debug_log 1 "[sct] changed to new:$data, from old:[sct oldval]" - sct oldval $data - sct update $data - sct utime readtime - } - } - return "idle" - } - - proc rdTextAll {tc_root} { - # process the received response to the read request - debug_log 1 "[ns]::rdText tc_root=$tc_root sct=[sct] result=[sct result]" - set data [sct result] - if {[string equal -nocase -length 7 $data "ASCERR:"]} { - # the protocol driver has reported an error - sct geterror "$data" - } elseif {[string equal -nocase -length 1 $data "?"]} { - # the device has reported an error - sct geterror "Error: $data" - } else { - if { [string equal -nocase [basename [sct]] "XXXX"] } { - return "idle" - } - #scan [lindex [split "$data" ":"] end] "%s" data - if {$data != [sct oldval]} { - debug_log 1 "[sct] changed to new:$data, from old:[sct oldval]" - sct oldval $data - sct update $data - sct utime readtime - } - } - return "idle" - } - - proc getTemp {tc_root nextState cmd} { - debug_log 1 "getTemp tc_root=$tc_root sct=[sct] $cmd" - if { ! [hpropexists [sct] my_state] } { - sct my_state 0 - } - if { [sct my_state] == 0 } { - set command "CSET?" - } else { - set command "RDGK? [sct channel]" - } - debug_log 1 "getTemp sct send $command" - sct send "$command" - return "$nextState" - } - - proc rdTemp {tc_root} { - debug_log 1 "rdTemp tc_root=$tc_root sct=[sct] result=[sct result]" - if { [sct my_state] == 0 } { - set response "[split [sct result] ","]" - sct channel [lindex $response 0] - sct filter [lindex $response 1] - sct my_state 1 - return "read" - } else { - set data "[sct result]" - if {$data != [sct oldval]} { - debug_log 1 "[sct] changed to new:$data, from old:[sct oldval]" - sct oldval $data - sct update $data - sct utime readtime - } - sct my_state 0 - return "idle" - } - } - - proc gtLoop {tc_root nextState cmd} { - debug_log 1 "gtLoop tc_root=$tc_root sct=[sct] nextState=$nextState cmd=$cmd" - debug_log 1 "gtLoop tc_root=$tc_root pathname=[pathname [sct]] basename=[basename [sct]]" - if { ! [hpropexists [sct] my_state] } { - debug_log 1 "gtLoop setting my_state to zero because it doesn't exist" - sct my_state 0 - } - if { [sct my_state] == 0 } { - set command "RAMP?" - } else { - set command "SETP?" - } - debug_log 1 "gtLoop sct=[sct] command=$command" - sct send "$command" - return "$nextState" - return idle - } - - proc rdLoop {tc_root} { - debug_log 1 "rdLoop tc_root=$tc_root sct=[sct] result=[sct result]" - debug_log 1 "rdLoop tc_root=$tc_root pathname=[pathname [sct]] basename=[basename [sct]]" - set nextState "read" - if { [sct my_state] == 0 } { - debug_log 1 "rdLoop sct=[sct] RAMP - result=[sct result]" - set nextState "read" - } else { - debug_log 1 "rdLoop sct=[sct] SETP - result=[sct result]" - set nextState "idle" - sct my_state -1 - } - sct my_state "[expr {[sct my_state] + 1}]" - return $nextState - } - - proc wrLoop {tc_root nextState cmd} { - debug_log 1 "wrLoop tc_root=$tc_root sct=[sct] nextState=$nextState cmd=$cmd" - if { ! [hpropexists [sct] my_state] } { - debug_log 1 "wrLoop setting my_state to zero because it doesn't exist" - sct my_state 0 - } - if { [sct writestatus] == "start" } { - debug_log 1 "wrLoop setting my_state to zero because writestatus is [sct writestatus]" - sct my_state 0 - } - debug_log 1 "wrLoop target=[sct target] writestatus=[sct writestatus] my_state=[sct my_state]" - if { [sct my_state] == 0 } { - set my_rate [hval [sct]/ramp_rate] - if { $my_rate > 0.0 } { - set command "RAMP 0,0;RAMP?" - } else { - set command "RAMP 1,$my_rate;RAMP?" - } - } else { - set command "SETP [hval [sct]/setpoint];SETP?" - } - debug_log 1 "wrLoop sct=[sct] command=$command" - sct send "$command" - return "$nextState" - } - - proc ckLoop {tc_root} { - debug_log 1 "ckLoop tc_root=$tc_root sct=[sct] result=[sct result]" - debug_log 1 "ckLoop target=[sct target] writestatus=[sct writestatus] my_state=[sct my_state]" - set nextState "write" - if { [sct my_state] == 0 } { - debug_log 1 "ckLoop sct=[sct] RAMP - result=[sct result]" - [ns]::rdValue $tc_root - set nextState "write" - } else { - debug_log 1 "ckLoop sct=[sct] SETP - result=[sct result]" - [ns]::rdValue $tc_root - sct my_state -1 - set nextState "idle" - } - sct my_state "[expr {[sct my_state] + 1}]" - return $nextState - } - - ## - # @brief getState() sends commands/requests to the device under control - # - # @param tc_root the path to the device_state node - # @param nextState the next sct state (rdState) - # @param cmd empty argument - # - # @return the next sct state (rdState) - # - proc getState {tc_root nextState cmd} { - if { [hpropexists [sct] geterror] } { - hdelprop [sct] geterror - } - debug_log 1 "getState $tc_root sct=[sct] state=[hval [sct]] substate=[sct substate] next=$nextState" - set my_state [hval [sct]] - set my_substate [sct substate] - if {$my_state == "STATE_INIT"} { - if { $my_substate == 0 } { - set command "*IDN?" - } elseif { $my_substate == 1 } { - set command "*TST?" - } - } elseif { $my_state == "STATE_CURVE"} { - if { $my_substate == 0 } { - set my_substate 1000 - sct substate $my_substate - } - if { ($my_substate % 1000) == 0 } { - set command "CRVHDR? [expr {int($my_substate / 1000)}]" - } else { - set command "CRVPT? [expr {int($my_substate / 1000)}],[expr {($my_substate % 1000)}]" - } - } elseif { $my_state == "STATE_IDLE"} { - if { $my_substate == 0 } { - set command "*ESE?" - } elseif { $my_substate == 1 } { - set command "*ESR?" - } elseif { $my_substate == 2 } { - set command "*STB?" - } - } - debug_log 1 "getState sct send $command" - sct send $command - return "$nextState" - } - - ## - # @brief rdState() handles events from the device under control - # - # @param tc_root the path to the device_state node - # - proc rdState {tc_root} { - if { [hpropexists [sct] geterror] } { - hdelprop [sct] geterror - } - debug_log 1 "rdState $tc_root sct=[sct] state=[hval [sct]] substate=[sct substate] response=\"[sct result]\"" - set nextState "read" - set my_state [hval [sct]] - set my_substate [sct substate] - if {$my_state == "STATE_INIT"} { - if { $my_substate == 0 } { # IDN - sct identity [sct result] - incr my_substate - } elseif { $my_substate == 1 } { - sct selftest [sct result] - incr my_substate - } - if { $my_substate > 1 } { - #hset [sct] "STATE_IDLE" - hset [sct] "STATE_CURVE" - set my_substate 0 - } - } elseif { $my_state == "STATE_CURVE"} { - if { ($my_substate % 1000) == 0 } { - debug_log 1 "Curve: [expr {$my_substate / 1000}] Header: [sct result]" - } else { - debug_log 1 "Curve: [expr {$my_substate / 1000}] Point: [expr {$my_substate % 1000}] Value: [sct result]" - set rslt [scan "[sct result]" "%f,%f" units temperature] - debug_log 1 "Curve: [expr {$my_substate / 1000}] Point: [expr {$my_substate % 1000}] Result: $rslt Units: $units Temp: $temperature" - if { $units == 0.0 && $temperature == 0.0 } { - set my_substate [expr { (($my_substate / 1000)) * 1000 + 999}] - } - } - if { ($my_substate % 1000) >= 200 } { - if { ($my_substate / 1000) >= 20 } { - hset [sct] "STATE_IDLE" - set my_substate 0 - } else { - set my_substate [expr { (($my_substate / 1000) + 1) * 1000 }] - } - } else { - set my_substate [expr { $my_substate + 1 }] - } - } elseif { $my_state == "STATE_IDLE"} { - if { $my_substate == 0 } { # ESE - sct the_ese [sct result] - incr my_substate - } elseif { $my_substate == 1 } { # ESR - sct the_esr [sct result] - incr my_substate - } elseif { $my_substate == 2 } { # STB - sct the_stb [sct result] - incr my_substate - } - if { $my_substate > 2 } { - set my_substate 0 - set nextState "idle" - } - } - sct substate $my_substate - if { $my_state != [hval [sct]] } { - debug_log 1 "device_state $my_state to [hval [sct]]" - } - return "$nextState" - } - - proc chkTarget {tc_root par} { - set target {} - if {[hpropexists [sct] values]} { - set values [split [SplitReply [sct values]] ","] - foreach value $values { - #sct print "Testing $par against $value" - set lo_hi [split $value ":"] - if {[llength $lo_hi] == 2} { - if {[lindex $lo_hi 0] <= $par && [lindex $lo_hi 1] >= $par} { - #sct print "Success $par between [lindex $lo_hi 0] and [lindex $lo_hi 1]" - set target "$par" - break - } - } else { - if {[string toupper "$par"] == [string toupper "$value"]} { - #sct print "Success $par matches $value" - set target "$par" - break - } - } - } - if {"$target" == ""} { - #sct print "Failure $par no matches in $values" - return -code error "Invalid value: \"$par\"" - } - } else { - set target "$par" - } - return $target - } - -## -# @brief Implement the checkstatus command for the drivable interface -# -# NOTE: The drive adapter initially sets the writestatus to "start" and will -# only call this when writestatus!="start" - proc drivestatus {tc_root} { - #debug_log 1 "drivestatus tc_root=$tc_root, sct=[sct], setpoint=[hval [sct]], temp=[hval [pathname [sct]]/sensor], driving=[sct driving]" - if {[sct driving]} { - # tolerance - set temp [hval [pathname [sct]]/sensor] - set loval [expr {[hval [sct]] - [sct tolerance]}] - set hival [expr {[hval [sct]] + [sct tolerance]}] - if {$loval <= $temp && $temp <= $hival} { - # settle time - set timeout [sct settletime] - set timecheck [sct time_check] - set currtime [clock seconds] - #debug_log 1 "drivestatus tc_root=$tc_root, sct=[sct], setpoint=[hval [sct]], temp=[hval [pathname [sct]]/sensor], temp=($loval, $temp, $hival), time=($timecheck, $currtime, $timeout)" - if { ($currtime - $timecheck) >= $timeout } { - debug_log 1 "drivestatus tc_root=$tc_root, sct=[sct], finished driving" - sct driving 0 - } - } else { - sct time_check [clock seconds] - } - return busy - } else { - debug_log 1 "drivestatus tc_root=$tc_root, sct=[sct], now idle" - return idle - } - } - - proc halt {tc_root} { - debug_log 1 "halt $tc_root" - foreach loop {Loop1 Loop2 Loop3 Loop4} { - set catch_status [ catch { - hset $tc_root/$loop/setpoint [hval $tc_root/$loop/sensor] - hsetprop $tc_root/$loop/setpoint driving 0 - } catch_message ] - } - debug_log 1 "halt $tc_root done driving" - return idle - } - - proc check {tc_root} { - debug_log 1 "check tc_root=$tc_root, sct=[sct], target=[sct target]" - set catch_status [ catch { - set target [chkTarget $tc_root [sct target]] - if { "$target" == "" } { - error "setpoint violates limits" - } - } catch_message ] - if {$catch_status != 0} { - return -code error $catch_message - } - return OK - } - - proc wrNode {tc_root cmd level} { - set space [string repeat " " $level] - set val [hval $tc_root] - if {"$val" == ""} { - set line "$tc_root ([hinfo $tc_root])" - } else { - set line "$tc_root ([hinfo $tc_root]) = $val" - } - sct print "$space* $line" - if {"[string tolower "$cmd"]" == "-prop"} { - set props [hlistprop $tc_root] - #sct print "<<$props>>" - foreach prop $props { - #sct print "prop: $prop" - set flds [split $prop "="] - #sct print "flds: $flds" - if {[llength $flds] > 1} { - set fld0 [lindex $flds 0] - #sct print "fld0: $fld0" - if {[hpropexists $tc_root $fld0]} { - sct print "$space - [hgetprop $tc_root $fld0]" - } - } - } - } - foreach node [hlist $tc_root] { - [ns]::wrNode $tc_root/$node "$cmd" [expr {$level + 1}] - } - } - - proc wrTree {tc_root nextState cmd} { - debug_log 1 "wrTree root=$tc_root sct=[sct] cmd=$cmd target=[sct target]" - sct print "$tc_root" - [ns]::wrNode $tc_root "[sct target]" 1 - return idle - } - - ## - # @brief createNode() creates a node for the given nodename with the properties given - # - # @param scobj_hpath string variable holding the path to the object's base node in sics (/sample/tc1) - # @param sct_controller name of the scriptcontext object (typically sct_xxx_yyy) - # @param cmdGroup subdirectory (below /sample/tc*/) in which the node is to be created - # @param varName name of the actual node typically representing one device command - # @param readable set to 1 if the node represents a query command, 0 if it is not - # @param writable set to 1 if the node represents a request for a change in settings sent to the device - # @param drivable if set to 1 it prepares the node to provide a drivable interface - # @param dataType data type of the node, must be one of none, int, float, text - # @param permission defines what user group may read/write to this node (is one of spy, user, manager) - # @param rdCmd actual device query command to be sent to the device - # @param rdFunc nextState Function to be called after the getValue function, typically rdValue() - # @param wrCmd actual device write command to be sent to the device - # @param wrFunc Function to be called to send the wrCmd to the device, typically setValue() - # @param allowedValues allowed values for the node data - does not permit other - # @param klass Nexus class name (?) - # @return OK - proc createNode {scobj_hpath sct_controller\ - cmdGroup varName\ - readable writable drivable\ - dataType permission\ - rdCmd rdFunc\ - wrCmd wrFunc\ - allowedValues klass} { - - set catch_status [ catch { - set ns "[ns]" - set nodeName "$scobj_hpath/$cmdGroup/$varName" - if {1 > [string length $cmdGroup]} { - set nodeName "$scobj_hpath/$varName" - } - debug_log 1 "Creating node $nodeName" - hfactory $nodeName plain $permission $dataType - if {$readable > 0} { - # the node is readable so set it up to be polled using the rdFunc - # rdFunc is getValueFunc.rdValueFunc with both explicit functions - # or rdValueFunc where "getValue" is the implied getValueFunc - set parts [split "$rdFunc" "."] - if { [llength $parts] == 2 } { - set func_name [lindex $parts 0] - set next_state [lindex $parts 1] - } else { - set func_name "getValue" - set next_state [lindex $parts 0] - } - hsetprop $nodeName read ${ns}::$func_name $scobj_hpath $next_state $rdCmd - hsetprop $nodeName $next_state ${ns}::$next_state $scobj_hpath - # set the poll rate as a period in seconds - # TODO allow directly settable value in seconds - set poll_period 5 - if { $readable >= 0 && $readable <= 300 } { - set poll_period [expr {int($readable)}] - } - debug_log 1 "Registering node $nodeName for poll at $poll_period seconds" - $sct_controller poll $nodeName $poll_period - } - if {$writable == 1} { - # the node is writable so set it up to invoke a callback when written - # rdFunc is putValueFunc.chkWriteFunc with both explicit functions - # or putValueFunc where "noResponse" is the implied chkWriteFunc - set parts [split "$wrFunc" "."] - if { [llength $parts] == 2 } { - set func_name [lindex $parts 0] - set next_state [lindex $parts 1] - } else { - set func_name [lindex $parts 0] - set next_state "noResponse" - } - hsetprop $nodeName write ${ns}::$func_name $scobj_hpath $next_state $wrCmd - hsetprop $nodeName $next_state ${ns}::$next_state $scobj_hpath - hsetprop $nodeName writestatus UNKNOWN - debug_log 1 "Registering node $nodeName for write callback" - $sct_controller write $nodeName - } - # Initialise the previous value to test against - switch -exact $dataType { - "none" { } - "int" { hsetprop $nodeName oldval -1 } - "float" { hsetprop $nodeName oldval -1.0 } - default { hsetprop $nodeName oldval UNKNOWN } - } - # Set the allowed values property - if {1 < [string length $allowedValues]} { - hsetprop $nodeName values $allowedValues - } - # Drive adapter interface - # TODO make it a separate function and pass in all this stuff - if {$drivable == 1} { - hsetprop $nodeName check ${ns}::check $scobj_hpath - hsetprop $nodeName driving 0 - hsetprop $nodeName checklimits ${ns}::check $scobj_hpath - hsetprop $nodeName checkstatus ${ns}::drivestatus $scobj_hpath - hsetprop $nodeName halt ${ns}::halt $scobj_hpath - } else { - hsetprop $nodeName driving 0 - } - } catch_message ] - if {$catch_status != 0} { - debug_log 5 "error in [ns]::createNode $catch_message" - return -code error "in [ns]::createNode $catch_message" - } - return OK - } - - proc mk_sct_driver {sct_controller the_klass the_name tol CID CTYPE} { - debug_log 1 "mk_sct_driver $sct_controller $the_klass $the_name $tol $CID $CTYPE" - set catch_status [ catch { - - MakeSICSObj $the_name SCT_OBJECT - sicslist setatt $the_name klass $the_klass - sicslist setatt $the_name long_name $the_name - - set scobj_hpath /sics/$the_name - - hfactory $scobj_hpath/Loop1 plain spy none - hfactory $scobj_hpath/Loop2 plain spy none - hfactory $scobj_hpath/Loop3 plain spy none - hfactory $scobj_hpath/Loop4 plain spy none - hfactory $scobj_hpath/Level plain spy none - - set deviceCommand {\ - Loop1 setpoint 5 1 1 float user {READ:DEV:MB1.T1:TEMP:LOOP:TSET} {rdValue} {SET:DEV:MB1.T1:TEMP:LOOP:TSET} {setPoint} {1:333}\ - Loop1 sensor 1 0 0 float user {READ:DEV:MB1.T1:TEMP:SIG:TEMP} {rdValue} {} {} {}\ - Loop1 nick 5 0 0 text user {READ:DEV:MB1.T1:TEMP:NICK} {rdText} {} {} {}\ - Loop1 temp 0 0 0 text user {READ:DEV:MB1.T1:TEMP} {rdTextAll} {} {} {}\ - Loop1 loop 0 0 0 text user {READ:DEV:MB1.T1:TEMP:LOOP} {rdTextAll} {} {} {}\ - Loop1 heater 0 0 0 text user {READ:DEV:MB0.H1:HTR} {rdTextAll} {} {} {}\ - Loop1 power 5 0 0 float user {READ:DEV:MB0.H1:HTR:SIG:POWR} {rdValue} {} {} {}\ - Loop2 setpoint 5 1 1 float user {READ:DEV:DB6.T1:TEMP:LOOP:TSET} {rdValue} {SET:DEV:DB6.T1:TEMP:LOOP:TSET} {setPoint} {1:333}\ - Loop2 sensor 1 0 0 float user {READ:DEV:DB6.T1:TEMP:SIG:TEMP} {rdValue} {} {} {}\ - Loop2 nick 5 0 0 text user {READ:DEV:DB6.T1:TEMP:NICK} {rdText} {} {} {}\ - Loop2 temp 0 0 0 text user {READ:DEV:DB6.T1:TEMP} {rdTextAll} {} {} {}\ - Loop2 loop 0 0 0 text user {READ:DEV:DB6.T1:TEMP:LOOP} {rdTextAll} {} {} {}\ - Loop2 heater 0 0 0 text user {READ:DEV:DB1.H1:HTR} {rdTextAll} {} {} {}\ - Loop2 power 5 0 0 float user {READ:DEV:DB1.H1:HTR:SIG:POWR} {rdValue} {} {} {}\ - Loop3 setpoint 5 1 1 float user {READ:DEV:DB7.T1:TEMP:LOOP:TSET} {rdValue} {SET:DEV:DB7.T1:TEMP:LOOP:TSET} {setPoint} {1:333}\ - Loop3 sensor 1 0 0 float user {READ:DEV:DB7.T1:TEMP:SIG:TEMP} {rdValue} {} {} {}\ - Loop3 nick 5 0 0 text user {READ:DEV:DB7.T1:TEMP:NICK} {rdText} {} {} {}\ - Loop3 temp 0 0 0 text user {READ:DEV:DB7.T1:TEMP} {rdTextAll} {} {} {}\ - Loop3 loop 0 0 0 text user {READ:DEV:DB7.T1:TEMP:LOOP} {rdTextAll} {} {} {}\ - Loop3 heater 0 0 0 text user {READ:DEV:DB2.H1:HTR} {rdTextAll} {} {} {}\ - Loop3 power 5 0 0 float user {READ:DEV:DB2.H1:HTR:SIG:POWR} {rdValue} {} {} {}\ - Loop4 setpoint 5 1 1 float user {READ:DEV:DB8.T1:TEMP:LOOP:TSET} {rdValue} {SET:DEV:DB8.T1:TEMP:LOOP:TSET} {setPoint} {1:333}\ - Loop4 sensor 1 0 0 float user {READ:DEV:DB8.T1:TEMP:SIG:TEMP} {rdValue} {} {} {}\ - Loop4 nick 5 0 0 text user {READ:DEV:DB8.T1:TEMP:NICK} {rdText} {} {} {}\ - Loop4 temp 0 0 0 text user {READ:DEV:DB8.T1:TEMP} {rdTextAll} {} {} {}\ - Loop4 loop 0 0 0 text user {READ:DEV:DB7.T1:TEMP:LOOP} {rdTextAll} {} {} {}\ - Loop4 heater 0 0 0 text user {READ:DEV:DB3.H1:HTR} {rdTextAll} {} {} {}\ - Loop4 power 5 0 0 float user {READ:DEV:DB3.H1:HTR:SIG:POWR} {rdValue} {} {} {}\ - Level Nitrogen 15 0 0 float user {READ:DEV:DB5.L1:LVL:SIG:NIT:LEV} {rdValue} {} {} {}\ - Level Helium 15 0 0 float user {READ:DEV:DB5.L1:LVL:SIG:HEL:LEV} {rdValue} {} {} {}\ - } - - foreach {cmdGroup varName\ - readable writable drivable\ - dataType permission\ - rdCmd rdFunc\ - wrCmd wrFunc\ - allowedValues} $deviceCommand { - [ns]::createNode $scobj_hpath $sct_controller\ - $cmdGroup $varName\ - $readable $writable $drivable\ - $dataType $permission\ - $rdCmd $rdFunc\ - $wrCmd $wrFunc\ - $allowedValues $the_klass - } - - foreach cmdGroup { Loop1 Loop2 Loop3 Loop4 } { - set pathName "$scobj_hpath/$cmdGroup" - hsetprop $pathName type part - hsetprop $pathName klass NXsensor - hsetprop $pathName privilege spy - hsetprop $pathName control true - hsetprop $pathName data true - hsetprop $pathName nxsave true - hsetprop $pathName/setpoint tolerance $tol - hsetprop $pathName/setpoint settletime 5 - foreach varName { setpoint sensor nick } { - set nodeName "$pathName/$varName" - hsetprop $nodeName nxalias ${the_name}_${cmdGroup}_${varName}_value - hsetprop $nodeName long_name $varName - hsetprop $nodeName klass sensor - hsetprop $nodeName priviledge user - hsetprop $nodeName control true - hsetprop $nodeName data true - hsetprop $nodeName nxsave true - hsetprop $nodeName mutable true - hsetprop $nodeName sdsinfo ::nexus::scobj::sdsinfo - } - } - - foreach cmdGroup { Level } { - set pathName "$scobj_hpath/$cmdGroup" - hsetprop $pathName type part - hsetprop $pathName klass NXsensor - hsetprop $pathName privilege spy - hsetprop $pathName control true - hsetprop $pathName data true - hsetprop $pathName nxsave true - foreach varName { Nitrogen Helium } { - set nodeName "$pathName/$varName" - hsetprop $nodeName long_name $varName - hsetprop $nodeName klass sensor - hsetprop $nodeName priviledge user - hsetprop $nodeName control true - hsetprop $nodeName data true - hsetprop $nodeName nxsave true - hsetprop $nodeName nxalias ${the_name}_${cmdGroup}_${varName}_value - hsetprop $nodeName mutable true - hsetprop $nodeName sdsinfo ::nexus::scobj::sdsinfo - } - } - - hfactory $scobj_hpath/device_state plain spy none - hset $scobj_hpath/device_state "STATE_INIT" - hsetprop $scobj_hpath/device_state substate 0 - - set point 0 - set catch_status_2 [ catch { - hsetprop $scobj_hpath privilege spy - hsetprop $scobj_hpath long_name $the_name - hsetprop $scobj_hpath sicsdev $the_name - hsetprop $scobj_hpath nxalias $the_name - hsetprop $scobj_hpath control true - hsetprop $scobj_hpath data true - hsetprop $scobj_hpath nxsave true - hsetprop $scobj_hpath mutable true - hsetprop $scobj_hpath klass parameter - hsetprop $scobj_hpath sdsinfo ::nexus::scobj::sdsinfo - set point 1 -if {0} { - ::scobj::hinitprops $the_name Loop1 - set point 2 - ::scobj::hinitprops $the_name Loop2/setpoint - set point 3 - ::scobj::hinitprops $the_name Loop3/setpoint - set point 4 - ::scobj::hinitprops $the_name Loop4/setpoint - set point 5 -} - } catch_message_2 ] - if {$catch_status_2 != 0} { - debug_log 5 "error in [ns]::mk_sct_driver($point) $catch_message_2" - return -code error "in [ns]::mk_sct_driver($point) $catch_message_2" - } - hsetprop $scobj_hpath/Loop1/setpoint permlink data_set ${CTYPE}${CID}SP1 - hsetprop $scobj_hpath/Loop1/setpoint @description ${CTYPE}${CID}SP1 - hsetprop $scobj_hpath/Loop1/setpoint permlink data_set ${CTYPE}${CID}SP1 - hsetprop $scobj_hpath/Loop1/setpoint @description ${CTYPE}${CID}SP1 - hsetprop $scobj_hpath/Loop2/setpoint permlink data_set ${CTYPE}${CID}SP2 - hsetprop $scobj_hpath/Loop2/setpoint @description ${CTYPE}${CID}SP2 - hsetprop $scobj_hpath/Loop3/setpoint permlink data_set ${CTYPE}${CID}SP3 - hsetprop $scobj_hpath/Loop3/setpoint @description ${CTYPE}${CID}SP3 - hsetprop $scobj_hpath/Loop4/setpoint permlink data_set ${CTYPE}${CID}SP4 - hsetprop $scobj_hpath/Loop4/setpoint @description ${CTYPE}${CID}SP4 - - hsetprop $scobj_hpath/Loop1/sensor permlink data_set ${CTYPE}${CID}S1 - hsetprop $scobj_hpath/Loop1/sensor @description ${CTYPE}${CID}S1 - hsetprop $scobj_hpath/Loop2/sensor permlink data_set ${CTYPE}${CID}S2 - hsetprop $scobj_hpath/Loop2/sensor @description ${CTYPE}${CID}S2 - hsetprop $scobj_hpath/Loop3/sensor permlink data_set ${CTYPE}${CID}S3 - hsetprop $scobj_hpath/Loop3/sensor @description ${CTYPE}${CID}S3 - hsetprop $scobj_hpath/Loop4/sensor permlink data_set ${CTYPE}${CID}S4 - hsetprop $scobj_hpath/Loop4/sensor @description ${CTYPE}${CID}S4 - - if {[SplitReply [environment_simulation]]=="false"} { - hsetprop $scobj_hpath/Loop1/setpoint type drivable - hsetprop $scobj_hpath/Loop2/setpoint type drivable - hsetprop $scobj_hpath/Loop3/setpoint type drivable - hsetprop $scobj_hpath/Loop4/setpoint type drivable - ansto_makesctdrive ${the_name}_loop1 $scobj_hpath/Loop1/setpoint $scobj_hpath/Loop1/sensor $sct_controller - ansto_makesctdrive ${the_name}_loop2 $scobj_hpath/Loop2/setpoint $scobj_hpath/Loop2/sensor $sct_controller - ansto_makesctdrive ${the_name}_loop3 $scobj_hpath/Loop3/setpoint $scobj_hpath/Loop3/sensor $sct_controller - ansto_makesctdrive ${the_name}_loop4 $scobj_hpath/Loop4/setpoint $scobj_hpath/Loop4/sensor $sct_controller - } - } catch_message ] - if {$catch_status != 0} { - debug_log 5 "error in [ns]::mk_sct_driver $catch_message" - return -code error "in [ns]::mk_sct_driver $catch_message" - } - } - - proc add_[set vendor]_[set device] {the_name IP port CID CTYPE terminator {_tol 5.0}} { - set [ns]::log_file "../log/[set [ns]::ven_dev]_[set the_name].log" - set fd [open [set [ns]::log_file] "w"] - close $fd - debug_log 1 "add_[set [ns]::vendor]_[set [ns]::device] ${the_name} ${IP} ${port} ${_tol}" - clientput "Namespace: [namespace current]" - clientput "::vendor $::vendor" - clientput "::device $::device" - clientput "[namespace current]::vendor [set [namespace current]::vendor]" - clientput "[namespace current]::device [set [namespace current]::device]" - clientput "[namespace current]::ven_dev [set [namespace current]::ven_dev]" - clientput "[namespace current]::log_file [set [namespace current]::log_file]" - if {[SplitReply [environment_simulation]]=="false"} { - debug_log 1 "makesctcontroller sct_${the_name} std ${IP}:${port} $terminator" - makesctcontroller sct_${the_name} std ${IP}:${port} $terminator - } - debug_log 1 "::scobj::oxford_mercury::mk_sct_driver sct_${the_name} environment ${the_name} ${_tol} $CID $CTYPE" - ::scobj::oxford_mercury::mk_sct_driver sct_${the_name} environment ${the_name} ${_tol} $CID $CTYPE - } - - - namespace export add_[set vendor]_[set device] + return ${nextState} + } catch_message ] + handle_exception ${catch_status} ${catch_message} } -namespace import ::scobj::[set vendor]_[set device]::* +# function to write a parameter value on a device +proc ::scobj::oxford_mercury::setValue {tc_root nextState cmd_str} { + set catch_status [ catch { + debug_log ${tc_root} 1 "setValue tc_root=${tc_root} sct=[sct] cmd=${cmd_str}" + if { [hpropexists [sct] geterror] } { + hdelprop [sct] geterror + } + set par [sct target] + set cmd "${cmd_str}${par}" +# setValue hook code goes here + if { [hpropexists [sct] driving] } { + if { [hpropexists [sct] writestatus] && [sct writestatus] == "start" } { + sct driving 1 + } + } + debug_log ${tc_root} 1 "setValue sct send ${cmd}" + if {![string equal -nocase -length 10 ${cmd} "@@NOSEND@@"]} { + sct send "${cmd}" + } + return ${nextState} + } catch_message ] + handle_exception ${catch_status} ${catch_message} +} +# function to write a parameter value on a device +proc ::scobj::oxford_mercury::setValve {tc_root nextState cmd_str} { + set catch_status [ catch { + debug_log ${tc_root} 1 "setValve tc_root=${tc_root} sct=[sct] cmd=${cmd_str}" + if { [hpropexists [sct] geterror] } { + hdelprop [sct] geterror + } + set par [sct target] + set cmd "${cmd_str}${par}" +# setValve hook code goes here + if { [hpropexists [sct] driving] } { + if { [hpropexists [sct] writestatus] && [sct writestatus] == "start" } { + sct driving 1 + } + } + debug_log ${tc_root} 1 "setValve sct send ${cmd}" + if {![string equal -nocase -length 10 ${cmd} "@@NOSEND@@"]} { + sct send "${cmd}" + } + return ${nextState} + } catch_message ] + handle_exception ${catch_status} ${catch_message} +} +proc ::scobj::oxford_mercury::mkDriver { sct_controller name device_class simulation_flag ip_address tcp_port id {cards NNNNNNNN} {assoc 00000000} {ttol 1} {ptol 5} {vtol 5} } { + ::scobj::oxford_mercury::sics_log 9 "::scobj::oxford_mercury::mkDriver ${sct_controller} ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${cards} ${assoc} ${ttol} ${ptol} ${vtol}" + set ns "[namespace current]" + set catch_status [ catch { + + MakeSICSObj ${name} SCT_OBJECT + + sicslist setatt ${name} klass ${device_class} + sicslist setatt ${name} long_name ${name} + + set scobj_hpath /sics/${name} + + hsetprop ${scobj_hpath} assoc "${assoc}" + hsetprop ${scobj_hpath} cards "${cards}" + hsetprop ${scobj_hpath} data "true" + hsetprop ${scobj_hpath} klass "@none" + hsetprop ${scobj_hpath} type "part" + + if {[string equal -nocase [string index ${cards} 4] L]} { + hfactory ${scobj_hpath}/Level plain spy none + + hfactory ${scobj_hpath}/Level/Helium plain user float + hsetprop ${scobj_hpath}/Level/Helium read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB5.L1:LVL:SIG:HEL:LEV} + hsetprop ${scobj_hpath}/Level/Helium rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Level/Helium control true + hsetprop ${scobj_hpath}/Level/Helium data true + hsetprop ${scobj_hpath}/Level/Helium mutable true + hsetprop ${scobj_hpath}/Level/Helium nxsave true + hsetprop ${scobj_hpath}/Level/Helium permlink data_set "T[format "%02d" ${id}]He" + hsetprop ${scobj_hpath}/Level/Helium @description "T[format "%02d" ${id}]He" + hsetprop ${scobj_hpath}/Level/Helium oldval 0.0 + hsetprop ${scobj_hpath}/Level/Helium klass "parameter" + hsetprop ${scobj_hpath}/Level/Helium sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Level/Helium type "part" + hsetprop ${scobj_hpath}/Level/Helium nxalias "${name}_Level_Helium" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Level/Helium 15 + hsetprop ${scobj_hpath}/Level/Helium simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Level/Helium simulated true + } + + hfactory ${scobj_hpath}/Level/Nitrogen plain user float + hsetprop ${scobj_hpath}/Level/Nitrogen read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB5.L1:LVL:SIG:NIT:LEV} + hsetprop ${scobj_hpath}/Level/Nitrogen rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Level/Nitrogen control true + hsetprop ${scobj_hpath}/Level/Nitrogen data true + hsetprop ${scobj_hpath}/Level/Nitrogen mutable true + hsetprop ${scobj_hpath}/Level/Nitrogen nxsave true + hsetprop ${scobj_hpath}/Level/Nitrogen permlink data_set "T[format "%02d" ${id}]N2" + hsetprop ${scobj_hpath}/Level/Nitrogen @description "T[format "%02d" ${id}]N2" + hsetprop ${scobj_hpath}/Level/Nitrogen oldval 0.0 + hsetprop ${scobj_hpath}/Level/Nitrogen klass "parameter" + hsetprop ${scobj_hpath}/Level/Nitrogen sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Level/Nitrogen type "part" + hsetprop ${scobj_hpath}/Level/Nitrogen nxalias "${name}_Level_Nitrogen" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Level/Nitrogen 15 + hsetprop ${scobj_hpath}/Level/Nitrogen simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Level/Nitrogen simulated true + } + + hfactory ${scobj_hpath}/Level/nick plain user text + hsetprop ${scobj_hpath}/Level/nick read ${ns}::getValue ${scobj_hpath} rdText {READ:DEV:DB5.L1:LVL:NICK} + hsetprop ${scobj_hpath}/Level/nick rdText ${ns}::rdText ${scobj_hpath} + hsetprop ${scobj_hpath}/Level/nick control true + hsetprop ${scobj_hpath}/Level/nick data true + hsetprop ${scobj_hpath}/Level/nick mutable true + hsetprop ${scobj_hpath}/Level/nick nxsave true + hsetprop ${scobj_hpath}/Level/nick oldval UNKNOWN + hsetprop ${scobj_hpath}/Level/nick klass "parameter" + hsetprop ${scobj_hpath}/Level/nick sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Level/nick type "part" + hsetprop ${scobj_hpath}/Level/nick nxalias "${name}_Level_nick" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Level/nick 15 + hsetprop ${scobj_hpath}/Level/nick simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Level/nick simulated true + } + hsetprop ${scobj_hpath}/Level data "true" + hsetprop ${scobj_hpath}/Level klass "@none" + hsetprop ${scobj_hpath}/Level type "part" + } + + if {[string equal -nocase [string index ${cards} 4] P]} { + hfactory ${scobj_hpath}/Pres5 plain spy none + + hfactory ${scobj_hpath}/Pres5/nick plain user text + hsetprop ${scobj_hpath}/Pres5/nick read ${ns}::getValue ${scobj_hpath} rdText {READ:DEV:DB5.P1:PRES:NICK} + hsetprop ${scobj_hpath}/Pres5/nick rdText ${ns}::rdText ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres5/nick control true + hsetprop ${scobj_hpath}/Pres5/nick data true + hsetprop ${scobj_hpath}/Pres5/nick mutable true + hsetprop ${scobj_hpath}/Pres5/nick nxsave true + hsetprop ${scobj_hpath}/Pres5/nick oldval UNKNOWN + hsetprop ${scobj_hpath}/Pres5/nick klass "parameter" + hsetprop ${scobj_hpath}/Pres5/nick sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Pres5/nick type "part" + hsetprop ${scobj_hpath}/Pres5/nick nxalias "${name}_Pres5_nick" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Pres5/nick 15 + hsetprop ${scobj_hpath}/Pres5/nick simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Pres5/nick simulated true + } + + hfactory ${scobj_hpath}/Pres5/sensor plain user float + hsetprop ${scobj_hpath}/Pres5/sensor read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB5.P1:PRES:SIG:PRES} + hsetprop ${scobj_hpath}/Pres5/sensor rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres5/sensor control true + hsetprop ${scobj_hpath}/Pres5/sensor data true + hsetprop ${scobj_hpath}/Pres5/sensor mutable true + hsetprop ${scobj_hpath}/Pres5/sensor nxsave true + hsetprop ${scobj_hpath}/Pres5/sensor units mB + hsetprop ${scobj_hpath}/Pres5/sensor permlink data_set "P[format "%02d" ${id}]PS05" + hsetprop ${scobj_hpath}/Pres5/sensor @description "P[format "%02d" ${id}]PS05" + hsetprop ${scobj_hpath}/Pres5/sensor oldval 0.0 + hsetprop ${scobj_hpath}/Pres5/sensor klass "parameter" + hsetprop ${scobj_hpath}/Pres5/sensor sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Pres5/sensor type "part" + hsetprop ${scobj_hpath}/Pres5/sensor nxalias "${name}_Pres5_sensor" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Pres5/sensor 1 + hsetprop ${scobj_hpath}/Pres5/sensor simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Pres5/sensor simulated true + } + + if {[string equal -nocase [string index ${cards} 3] V] && [string equal -nocase [string index ${assoc} 4] 4]} { + hfactory ${scobj_hpath}/Pres5/setpoint plain user float + hsetprop ${scobj_hpath}/Pres5/setpoint read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB5.P1:PRES:LOOP:TSET} + hsetprop ${scobj_hpath}/Pres5/setpoint rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres5/setpoint write ${ns}::setPoint ${scobj_hpath} noResponse {SET:DEV:DB8.P1:PRES:LOOP:TSET:} + hsetprop ${scobj_hpath}/Pres5/setpoint noResponse ${ns}::noResponse ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres5/setpoint check ${ns}::checkrange ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres5/setpoint driving 0 + hsetprop ${scobj_hpath}/Pres5/setpoint checklimits ${ns}::checklimits ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres5/setpoint checkstatus ${ns}::checkstatus ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres5/setpoint halt ${ns}::halt ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres5/setpoint driveable Pres5/sensor + hsetprop ${scobj_hpath}/Pres5/setpoint control true + hsetprop ${scobj_hpath}/Pres5/setpoint data true + hsetprop ${scobj_hpath}/Pres5/setpoint mutable true + hsetprop ${scobj_hpath}/Pres5/setpoint nxsave true + hsetprop ${scobj_hpath}/Pres5/setpoint lowerlimit 0 + hsetprop ${scobj_hpath}/Pres5/setpoint upperlimit 333 + hsetprop ${scobj_hpath}/Pres5/setpoint tolerance ${ptol} + hsetprop ${scobj_hpath}/Pres5/setpoint units mB + hsetprop ${scobj_hpath}/Pres5/setpoint permlink data_set "P[format "%02d" ${id}]PSP05" + hsetprop ${scobj_hpath}/Pres5/setpoint @description "P[format "%02d" ${id}]PSP05" + hsetprop ${scobj_hpath}/Pres5/setpoint oldval 0.0 + hsetprop ${scobj_hpath}/Pres5/setpoint klass "parameter" + hsetprop ${scobj_hpath}/Pres5/setpoint sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Pres5/setpoint settle_time "15" + hsetprop ${scobj_hpath}/Pres5/setpoint type "drivable" + hsetprop ${scobj_hpath}/Pres5/setpoint nxalias "${name}_Pres5_setpoint" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Pres5/setpoint 5 + ${sct_controller} write ${scobj_hpath}/Pres5/setpoint + hsetprop ${scobj_hpath}/Pres5/setpoint simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Pres5/setpoint simulated true + } + } + + if {[string equal -nocase [string index ${cards} 3] V] && [string equal -nocase [string index ${assoc} 4] 4]} { + hfactory ${scobj_hpath}/Pres5/valve plain user float + hsetprop ${scobj_hpath}/Pres5/valve read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB4.G1:AUX:SIG:OPEN} + hsetprop ${scobj_hpath}/Pres5/valve rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres5/valve control true + hsetprop ${scobj_hpath}/Pres5/valve data true + hsetprop ${scobj_hpath}/Pres5/valve mutable true + hsetprop ${scobj_hpath}/Pres5/valve nxsave true + hsetprop ${scobj_hpath}/Pres5/valve oldval 0.0 + hsetprop ${scobj_hpath}/Pres5/valve klass "parameter" + hsetprop ${scobj_hpath}/Pres5/valve sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Pres5/valve type "part" + hsetprop ${scobj_hpath}/Pres5/valve nxalias "${name}_Pres5_valve" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Pres5/valve 5 + hsetprop ${scobj_hpath}/Pres5/valve simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Pres5/valve simulated true + } + } + hsetprop ${scobj_hpath}/Pres5 data "true" + hsetprop ${scobj_hpath}/Pres5 klass "@none" + hsetprop ${scobj_hpath}/Pres5 type "part" + if {[string equal -nocase [string index ${cards} 3] V] && [string equal -nocase [string index ${assoc} 4] 4]} { + ansto_makesctdrive ${name}_Pres5_setpoint ${scobj_hpath}/Pres5/setpoint ${scobj_hpath}/Pres5/sensor ${sct_controller} + } + } + + if {[string equal -nocase [string index ${cards} 7] P]} { + hfactory ${scobj_hpath}/Pres8 plain spy none + + hfactory ${scobj_hpath}/Pres8/nick plain user text + hsetprop ${scobj_hpath}/Pres8/nick read ${ns}::getValue ${scobj_hpath} rdText {READ:DEV:DB8.P1:PRES:NICK} + hsetprop ${scobj_hpath}/Pres8/nick rdText ${ns}::rdText ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres8/nick control true + hsetprop ${scobj_hpath}/Pres8/nick data true + hsetprop ${scobj_hpath}/Pres8/nick mutable true + hsetprop ${scobj_hpath}/Pres8/nick nxsave true + hsetprop ${scobj_hpath}/Pres8/nick oldval UNKNOWN + hsetprop ${scobj_hpath}/Pres8/nick klass "parameter" + hsetprop ${scobj_hpath}/Pres8/nick sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Pres8/nick type "part" + hsetprop ${scobj_hpath}/Pres8/nick nxalias "${name}_Pres8_nick" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Pres8/nick 15 + hsetprop ${scobj_hpath}/Pres8/nick simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Pres8/nick simulated true + } + + hfactory ${scobj_hpath}/Pres8/sensor plain user float + hsetprop ${scobj_hpath}/Pres8/sensor read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB8.P1:PRES:SIG:PRES} + hsetprop ${scobj_hpath}/Pres8/sensor rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres8/sensor control true + hsetprop ${scobj_hpath}/Pres8/sensor data true + hsetprop ${scobj_hpath}/Pres8/sensor mutable true + hsetprop ${scobj_hpath}/Pres8/sensor nxsave true + hsetprop ${scobj_hpath}/Pres8/sensor units mB + hsetprop ${scobj_hpath}/Pres8/sensor permlink data_set "P[format "%02d" ${id}]PS08" + hsetprop ${scobj_hpath}/Pres8/sensor @description "P[format "%02d" ${id}]PS08" + hsetprop ${scobj_hpath}/Pres8/sensor oldval 0.0 + hsetprop ${scobj_hpath}/Pres8/sensor klass "parameter" + hsetprop ${scobj_hpath}/Pres8/sensor sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Pres8/sensor type "part" + hsetprop ${scobj_hpath}/Pres8/sensor nxalias "${name}_Pres8_sensor" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Pres8/sensor 1 + hsetprop ${scobj_hpath}/Pres8/sensor simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Pres8/sensor simulated true + } + + if {[string equal -nocase [string index ${cards} 3] V] && [string equal -nocase [string index ${assoc} 7] 4]} { + hfactory ${scobj_hpath}/Pres8/setpoint plain user float + hsetprop ${scobj_hpath}/Pres8/setpoint read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB8.P1:PRES:LOOP:TSET} + hsetprop ${scobj_hpath}/Pres8/setpoint rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres8/setpoint write ${ns}::setPoint ${scobj_hpath} noResponse {SET:DEV:DB8.P1:PRES:LOOP:TSET:} + hsetprop ${scobj_hpath}/Pres8/setpoint noResponse ${ns}::noResponse ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres8/setpoint check ${ns}::checkrange ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres8/setpoint driving 0 + hsetprop ${scobj_hpath}/Pres8/setpoint checklimits ${ns}::checklimits ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres8/setpoint checkstatus ${ns}::checkstatus ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres8/setpoint halt ${ns}::halt ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres8/setpoint driveable Pres8/sensor + hsetprop ${scobj_hpath}/Pres8/setpoint control true + hsetprop ${scobj_hpath}/Pres8/setpoint data true + hsetprop ${scobj_hpath}/Pres8/setpoint mutable true + hsetprop ${scobj_hpath}/Pres8/setpoint nxsave true + hsetprop ${scobj_hpath}/Pres8/setpoint lowerlimit 0 + hsetprop ${scobj_hpath}/Pres8/setpoint upperlimit 333 + hsetprop ${scobj_hpath}/Pres8/setpoint tolerance ${ptol} + hsetprop ${scobj_hpath}/Pres8/setpoint units mB + hsetprop ${scobj_hpath}/Pres8/setpoint permlink data_set "P[format "%02d" ${id}]PSP08" + hsetprop ${scobj_hpath}/Pres8/setpoint @description "P[format "%02d" ${id}]PSP08" + hsetprop ${scobj_hpath}/Pres8/setpoint oldval 0.0 + hsetprop ${scobj_hpath}/Pres8/setpoint klass "parameter" + hsetprop ${scobj_hpath}/Pres8/setpoint sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Pres8/setpoint settle_time "15" + hsetprop ${scobj_hpath}/Pres8/setpoint type "drivable" + hsetprop ${scobj_hpath}/Pres8/setpoint nxalias "${name}_Pres8_setpoint" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Pres8/setpoint 5 + ${sct_controller} write ${scobj_hpath}/Pres8/setpoint + hsetprop ${scobj_hpath}/Pres8/setpoint simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Pres8/setpoint simulated true + } + } + + if {[string equal -nocase [string index ${cards} 3] V] && [string equal -nocase [string index ${assoc} 7] 4]} { + hfactory ${scobj_hpath}/Pres8/valve plain user float + hsetprop ${scobj_hpath}/Pres8/valve read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB4.G1:AUX:SIG:OPEN} + hsetprop ${scobj_hpath}/Pres8/valve rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Pres8/valve control true + hsetprop ${scobj_hpath}/Pres8/valve data true + hsetprop ${scobj_hpath}/Pres8/valve mutable true + hsetprop ${scobj_hpath}/Pres8/valve nxsave true + hsetprop ${scobj_hpath}/Pres8/valve oldval 0.0 + hsetprop ${scobj_hpath}/Pres8/valve klass "parameter" + hsetprop ${scobj_hpath}/Pres8/valve sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Pres8/valve type "part" + hsetprop ${scobj_hpath}/Pres8/valve nxalias "${name}_Pres8_valve" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Pres8/valve 5 + hsetprop ${scobj_hpath}/Pres8/valve simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Pres8/valve simulated true + } + } + hsetprop ${scobj_hpath}/Pres8 data "true" + hsetprop ${scobj_hpath}/Pres8 klass "@none" + hsetprop ${scobj_hpath}/Pres8 type "part" + if {[string equal -nocase [string index ${cards} 3] V] && [string equal -nocase [string index ${assoc} 7] 4]} { + ansto_makesctdrive ${name}_Pres8_setpoint ${scobj_hpath}/Pres8/setpoint ${scobj_hpath}/Pres8/sensor ${sct_controller} + } + } + + hfactory ${scobj_hpath}/Temp0 plain spy none + + hfactory ${scobj_hpath}/Temp0/nick plain user text + hsetprop ${scobj_hpath}/Temp0/nick read ${ns}::getValue ${scobj_hpath} rdText {READ:DEV:MB1.T1:TEMP:NICK} + hsetprop ${scobj_hpath}/Temp0/nick rdText ${ns}::rdText ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp0/nick control true + hsetprop ${scobj_hpath}/Temp0/nick data true + hsetprop ${scobj_hpath}/Temp0/nick mutable true + hsetprop ${scobj_hpath}/Temp0/nick nxsave true + hsetprop ${scobj_hpath}/Temp0/nick oldval UNKNOWN + hsetprop ${scobj_hpath}/Temp0/nick klass "parameter" + hsetprop ${scobj_hpath}/Temp0/nick sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp0/nick type "part" + hsetprop ${scobj_hpath}/Temp0/nick nxalias "${name}_Temp0_nick" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp0/nick 15 + hsetprop ${scobj_hpath}/Temp0/nick simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp0/nick simulated true + } + + hfactory ${scobj_hpath}/Temp0/power plain user float + hsetprop ${scobj_hpath}/Temp0/power read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:MB0.H1:HTR:SIG:POWR} + hsetprop ${scobj_hpath}/Temp0/power rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp0/power control true + hsetprop ${scobj_hpath}/Temp0/power data true + hsetprop ${scobj_hpath}/Temp0/power mutable true + hsetprop ${scobj_hpath}/Temp0/power nxsave true + hsetprop ${scobj_hpath}/Temp0/power oldval 0.0 + hsetprop ${scobj_hpath}/Temp0/power klass "parameter" + hsetprop ${scobj_hpath}/Temp0/power sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp0/power type "part" + hsetprop ${scobj_hpath}/Temp0/power nxalias "${name}_Temp0_power" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp0/power 5 + hsetprop ${scobj_hpath}/Temp0/power simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp0/power simulated true + } + + hfactory ${scobj_hpath}/Temp0/sensor plain user float + hsetprop ${scobj_hpath}/Temp0/sensor read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:MB1.T1:TEMP:SIG:TEMP} + hsetprop ${scobj_hpath}/Temp0/sensor rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp0/sensor control true + hsetprop ${scobj_hpath}/Temp0/sensor data true + hsetprop ${scobj_hpath}/Temp0/sensor mutable true + hsetprop ${scobj_hpath}/Temp0/sensor nxsave true + hsetprop ${scobj_hpath}/Temp0/sensor permlink data_set "T[format "%02d" ${id}]S00" + hsetprop ${scobj_hpath}/Temp0/sensor @description "T[format "%02d" ${id}]S00" + hsetprop ${scobj_hpath}/Temp0/sensor oldval 0.0 + hsetprop ${scobj_hpath}/Temp0/sensor klass "parameter" + hsetprop ${scobj_hpath}/Temp0/sensor sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp0/sensor type "part" + hsetprop ${scobj_hpath}/Temp0/sensor nxalias "${name}_Temp0_sensor" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp0/sensor 1 + hsetprop ${scobj_hpath}/Temp0/sensor simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp0/sensor simulated true + } + + hfactory ${scobj_hpath}/Temp0/setpoint plain user float + hsetprop ${scobj_hpath}/Temp0/setpoint read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:MB1.T1:TEMP:LOOP:TSET} + hsetprop ${scobj_hpath}/Temp0/setpoint rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp0/setpoint write ${ns}::setPoint ${scobj_hpath} noResponse {SET:DEV:MB1.T1:TEMP:LOOP:TSET:} + hsetprop ${scobj_hpath}/Temp0/setpoint noResponse ${ns}::noResponse ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp0/setpoint check ${ns}::checkrange ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp0/setpoint driving 0 + hsetprop ${scobj_hpath}/Temp0/setpoint checklimits ${ns}::checklimits ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp0/setpoint checkstatus ${ns}::checkstatus ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp0/setpoint halt ${ns}::halt ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp0/setpoint driveable Temp0/sensor + hsetprop ${scobj_hpath}/Temp0/setpoint control true + hsetprop ${scobj_hpath}/Temp0/setpoint data true + hsetprop ${scobj_hpath}/Temp0/setpoint mutable true + hsetprop ${scobj_hpath}/Temp0/setpoint nxsave true + hsetprop ${scobj_hpath}/Temp0/setpoint lowerlimit 0 + hsetprop ${scobj_hpath}/Temp0/setpoint upperlimit 333 + hsetprop ${scobj_hpath}/Temp0/setpoint tolerance ${ttol} + hsetprop ${scobj_hpath}/Temp0/setpoint permlink data_set "T[format "%02d" ${id}]SP00" + hsetprop ${scobj_hpath}/Temp0/setpoint @description "T[format "%02d" ${id}]SP00" + hsetprop ${scobj_hpath}/Temp0/setpoint oldval 0.0 + hsetprop ${scobj_hpath}/Temp0/setpoint klass "parameter" + hsetprop ${scobj_hpath}/Temp0/setpoint sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp0/setpoint settle_time "15" + hsetprop ${scobj_hpath}/Temp0/setpoint type "drivable" + hsetprop ${scobj_hpath}/Temp0/setpoint nxalias "${name}_Temp0_setpoint" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp0/setpoint 5 + ${sct_controller} write ${scobj_hpath}/Temp0/setpoint + hsetprop ${scobj_hpath}/Temp0/setpoint simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp0/setpoint simulated true + } + hsetprop ${scobj_hpath}/Temp0 data "true" + hsetprop ${scobj_hpath}/Temp0 klass "@none" + hsetprop ${scobj_hpath}/Temp0 type "part" + ansto_makesctdrive ${name}_Temp0_setpoint ${scobj_hpath}/Temp0/setpoint ${scobj_hpath}/Temp0/sensor ${sct_controller} + + if {[string equal -nocase [string index ${cards} 0] T]} { + hfactory ${scobj_hpath}/Temp1 plain spy none + + hfactory ${scobj_hpath}/Temp1/nick plain user text + hsetprop ${scobj_hpath}/Temp1/nick read ${ns}::getValue ${scobj_hpath} rdText {READ:DEV:DB1.T1:TEMP:NICK} + hsetprop ${scobj_hpath}/Temp1/nick rdText ${ns}::rdText ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp1/nick control true + hsetprop ${scobj_hpath}/Temp1/nick data true + hsetprop ${scobj_hpath}/Temp1/nick mutable true + hsetprop ${scobj_hpath}/Temp1/nick nxsave true + hsetprop ${scobj_hpath}/Temp1/nick oldval UNKNOWN + hsetprop ${scobj_hpath}/Temp1/nick klass "parameter" + hsetprop ${scobj_hpath}/Temp1/nick sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp1/nick type "part" + hsetprop ${scobj_hpath}/Temp1/nick nxalias "${name}_Temp1_nick" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp1/nick 15 + hsetprop ${scobj_hpath}/Temp1/nick simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp1/nick simulated true + } + + hfactory ${scobj_hpath}/Temp1/sensor plain user float + hsetprop ${scobj_hpath}/Temp1/sensor read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB1.T1:TEMP:SIG:TEMP} + hsetprop ${scobj_hpath}/Temp1/sensor rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp1/sensor control true + hsetprop ${scobj_hpath}/Temp1/sensor data true + hsetprop ${scobj_hpath}/Temp1/sensor mutable true + hsetprop ${scobj_hpath}/Temp1/sensor nxsave true + hsetprop ${scobj_hpath}/Temp1/sensor permlink data_set "T[format "%02d" ${id}]S01" + hsetprop ${scobj_hpath}/Temp1/sensor @description "T[format "%02d" ${id}]S01" + hsetprop ${scobj_hpath}/Temp1/sensor oldval 0.0 + hsetprop ${scobj_hpath}/Temp1/sensor klass "parameter" + hsetprop ${scobj_hpath}/Temp1/sensor sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp1/sensor type "part" + hsetprop ${scobj_hpath}/Temp1/sensor nxalias "${name}_Temp1_sensor" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp1/sensor 1 + hsetprop ${scobj_hpath}/Temp1/sensor simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp1/sensor simulated true + } + hsetprop ${scobj_hpath}/Temp1 data "true" + hsetprop ${scobj_hpath}/Temp1 klass "@none" + hsetprop ${scobj_hpath}/Temp1 type "part" + } + + if {[string equal -nocase [string index ${cards} 1] T]} { + hfactory ${scobj_hpath}/Temp2 plain spy none + + hfactory ${scobj_hpath}/Temp2/nick plain user text + hsetprop ${scobj_hpath}/Temp2/nick read ${ns}::getValue ${scobj_hpath} rdText {READ:DEV:DB2.T1:TEMP:NICK} + hsetprop ${scobj_hpath}/Temp2/nick rdText ${ns}::rdText ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp2/nick control true + hsetprop ${scobj_hpath}/Temp2/nick data true + hsetprop ${scobj_hpath}/Temp2/nick mutable true + hsetprop ${scobj_hpath}/Temp2/nick nxsave true + hsetprop ${scobj_hpath}/Temp2/nick oldval UNKNOWN + hsetprop ${scobj_hpath}/Temp2/nick klass "parameter" + hsetprop ${scobj_hpath}/Temp2/nick sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp2/nick type "part" + hsetprop ${scobj_hpath}/Temp2/nick nxalias "${name}_Temp2_nick" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp2/nick 15 + hsetprop ${scobj_hpath}/Temp2/nick simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp2/nick simulated true + } + + hfactory ${scobj_hpath}/Temp2/sensor plain user float + hsetprop ${scobj_hpath}/Temp2/sensor read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB2.T1:TEMP:SIG:TEMP} + hsetprop ${scobj_hpath}/Temp2/sensor rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp2/sensor control true + hsetprop ${scobj_hpath}/Temp2/sensor data true + hsetprop ${scobj_hpath}/Temp2/sensor mutable true + hsetprop ${scobj_hpath}/Temp2/sensor nxsave true + hsetprop ${scobj_hpath}/Temp2/sensor permlink data_set "T[format "%02d" ${id}]S02" + hsetprop ${scobj_hpath}/Temp2/sensor @description "T[format "%02d" ${id}]S02" + hsetprop ${scobj_hpath}/Temp2/sensor oldval 0.0 + hsetprop ${scobj_hpath}/Temp2/sensor klass "parameter" + hsetprop ${scobj_hpath}/Temp2/sensor sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp2/sensor type "part" + hsetprop ${scobj_hpath}/Temp2/sensor nxalias "${name}_Temp2_sensor" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp2/sensor 1 + hsetprop ${scobj_hpath}/Temp2/sensor simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp2/sensor simulated true + } + hsetprop ${scobj_hpath}/Temp2 data "true" + hsetprop ${scobj_hpath}/Temp2 klass "@none" + hsetprop ${scobj_hpath}/Temp2 type "part" + } + + if {[string equal -nocase [string index ${cards} 2] T]} { + hfactory ${scobj_hpath}/Temp3 plain spy none + + hfactory ${scobj_hpath}/Temp3/nick plain user text + hsetprop ${scobj_hpath}/Temp3/nick read ${ns}::getValue ${scobj_hpath} rdText {READ:DEV:DB3.T1:TEMP:NICK} + hsetprop ${scobj_hpath}/Temp3/nick rdText ${ns}::rdText ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp3/nick control true + hsetprop ${scobj_hpath}/Temp3/nick data true + hsetprop ${scobj_hpath}/Temp3/nick mutable true + hsetprop ${scobj_hpath}/Temp3/nick nxsave true + hsetprop ${scobj_hpath}/Temp3/nick oldval UNKNOWN + hsetprop ${scobj_hpath}/Temp3/nick klass "parameter" + hsetprop ${scobj_hpath}/Temp3/nick sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp3/nick type "part" + hsetprop ${scobj_hpath}/Temp3/nick nxalias "${name}_Temp3_nick" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp3/nick 15 + hsetprop ${scobj_hpath}/Temp3/nick simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp3/nick simulated true + } + + hfactory ${scobj_hpath}/Temp3/sensor plain user float + hsetprop ${scobj_hpath}/Temp3/sensor read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB3.T1:TEMP:SIG:TEMP} + hsetprop ${scobj_hpath}/Temp3/sensor rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp3/sensor control true + hsetprop ${scobj_hpath}/Temp3/sensor data true + hsetprop ${scobj_hpath}/Temp3/sensor mutable true + hsetprop ${scobj_hpath}/Temp3/sensor nxsave true + hsetprop ${scobj_hpath}/Temp3/sensor permlink data_set "T[format "%02d" ${id}]S03" + hsetprop ${scobj_hpath}/Temp3/sensor @description "T[format "%02d" ${id}]S03" + hsetprop ${scobj_hpath}/Temp3/sensor oldval 0.0 + hsetprop ${scobj_hpath}/Temp3/sensor klass "parameter" + hsetprop ${scobj_hpath}/Temp3/sensor sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp3/sensor type "part" + hsetprop ${scobj_hpath}/Temp3/sensor nxalias "${name}_Temp3_sensor" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp3/sensor 1 + hsetprop ${scobj_hpath}/Temp3/sensor simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp3/sensor simulated true + } + hsetprop ${scobj_hpath}/Temp3 data "true" + hsetprop ${scobj_hpath}/Temp3 klass "@none" + hsetprop ${scobj_hpath}/Temp3 type "part" + } + + if {[string equal -nocase [string index ${cards} 3] T]} { + hfactory ${scobj_hpath}/Temp4 plain spy none + + hfactory ${scobj_hpath}/Temp4/nick plain user text + hsetprop ${scobj_hpath}/Temp4/nick read ${ns}::getValue ${scobj_hpath} rdText {READ:DEV:DB4.T1:TEMP:NICK} + hsetprop ${scobj_hpath}/Temp4/nick rdText ${ns}::rdText ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp4/nick control true + hsetprop ${scobj_hpath}/Temp4/nick data true + hsetprop ${scobj_hpath}/Temp4/nick mutable true + hsetprop ${scobj_hpath}/Temp4/nick nxsave true + hsetprop ${scobj_hpath}/Temp4/nick oldval UNKNOWN + hsetprop ${scobj_hpath}/Temp4/nick klass "parameter" + hsetprop ${scobj_hpath}/Temp4/nick sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp4/nick type "part" + hsetprop ${scobj_hpath}/Temp4/nick nxalias "${name}_Temp4_nick" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp4/nick 15 + hsetprop ${scobj_hpath}/Temp4/nick simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp4/nick simulated true + } + + hfactory ${scobj_hpath}/Temp4/sensor plain user float + hsetprop ${scobj_hpath}/Temp4/sensor read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB4.T1:TEMP:SIG:TEMP} + hsetprop ${scobj_hpath}/Temp4/sensor rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp4/sensor control true + hsetprop ${scobj_hpath}/Temp4/sensor data true + hsetprop ${scobj_hpath}/Temp4/sensor mutable true + hsetprop ${scobj_hpath}/Temp4/sensor nxsave true + hsetprop ${scobj_hpath}/Temp4/sensor permlink data_set "T[format "%02d" ${id}]S04" + hsetprop ${scobj_hpath}/Temp4/sensor @description "T[format "%02d" ${id}]S04" + hsetprop ${scobj_hpath}/Temp4/sensor oldval 0.0 + hsetprop ${scobj_hpath}/Temp4/sensor klass "parameter" + hsetprop ${scobj_hpath}/Temp4/sensor sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp4/sensor type "part" + hsetprop ${scobj_hpath}/Temp4/sensor nxalias "${name}_Temp4_sensor" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp4/sensor 1 + hsetprop ${scobj_hpath}/Temp4/sensor simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp4/sensor simulated true + } + hsetprop ${scobj_hpath}/Temp4 data "true" + hsetprop ${scobj_hpath}/Temp4 klass "@none" + hsetprop ${scobj_hpath}/Temp4 type "part" + } + + if {[string equal -nocase [string index ${cards} 4] T]} { + hfactory ${scobj_hpath}/Temp5 plain spy none + + hfactory ${scobj_hpath}/Temp5/nick plain user text + hsetprop ${scobj_hpath}/Temp5/nick read ${ns}::getValue ${scobj_hpath} rdText {READ:DEV:DB5.T1:TEMP:NICK} + hsetprop ${scobj_hpath}/Temp5/nick rdText ${ns}::rdText ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp5/nick control true + hsetprop ${scobj_hpath}/Temp5/nick data true + hsetprop ${scobj_hpath}/Temp5/nick mutable true + hsetprop ${scobj_hpath}/Temp5/nick nxsave true + hsetprop ${scobj_hpath}/Temp5/nick oldval UNKNOWN + hsetprop ${scobj_hpath}/Temp5/nick klass "parameter" + hsetprop ${scobj_hpath}/Temp5/nick sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp5/nick type "part" + hsetprop ${scobj_hpath}/Temp5/nick nxalias "${name}_Temp5_nick" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp5/nick 15 + hsetprop ${scobj_hpath}/Temp5/nick simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp5/nick simulated true + } + + hfactory ${scobj_hpath}/Temp5/sensor plain user float + hsetprop ${scobj_hpath}/Temp5/sensor read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB5.T1:TEMP:SIG:TEMP} + hsetprop ${scobj_hpath}/Temp5/sensor rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp5/sensor control true + hsetprop ${scobj_hpath}/Temp5/sensor data true + hsetprop ${scobj_hpath}/Temp5/sensor mutable true + hsetprop ${scobj_hpath}/Temp5/sensor nxsave true + hsetprop ${scobj_hpath}/Temp5/sensor permlink data_set "T[format "%02d" ${id}]S05" + hsetprop ${scobj_hpath}/Temp5/sensor @description "T[format "%02d" ${id}]S05" + hsetprop ${scobj_hpath}/Temp5/sensor oldval 0.0 + hsetprop ${scobj_hpath}/Temp5/sensor klass "parameter" + hsetprop ${scobj_hpath}/Temp5/sensor sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp5/sensor type "part" + hsetprop ${scobj_hpath}/Temp5/sensor nxalias "${name}_Temp5_sensor" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp5/sensor 1 + hsetprop ${scobj_hpath}/Temp5/sensor simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp5/sensor simulated true + } + hsetprop ${scobj_hpath}/Temp5 data "true" + hsetprop ${scobj_hpath}/Temp5 klass "@none" + hsetprop ${scobj_hpath}/Temp5 type "part" + } + + if {[string equal -nocase [string index ${cards} 5] T]} { + hfactory ${scobj_hpath}/Temp6 plain spy none + + hfactory ${scobj_hpath}/Temp6/nick plain user text + hsetprop ${scobj_hpath}/Temp6/nick read ${ns}::getValue ${scobj_hpath} rdText {READ:DEV:DB6.T1:TEMP:NICK} + hsetprop ${scobj_hpath}/Temp6/nick rdText ${ns}::rdText ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp6/nick control true + hsetprop ${scobj_hpath}/Temp6/nick data true + hsetprop ${scobj_hpath}/Temp6/nick mutable true + hsetprop ${scobj_hpath}/Temp6/nick nxsave true + hsetprop ${scobj_hpath}/Temp6/nick oldval UNKNOWN + hsetprop ${scobj_hpath}/Temp6/nick klass "parameter" + hsetprop ${scobj_hpath}/Temp6/nick sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp6/nick type "part" + hsetprop ${scobj_hpath}/Temp6/nick nxalias "${name}_Temp6_nick" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp6/nick 15 + hsetprop ${scobj_hpath}/Temp6/nick simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp6/nick simulated true + } + + if {[string equal -nocase [string index ${cards} 0] H] && [string equal -nocase [string index ${assoc} 5] 1]} { + hfactory ${scobj_hpath}/Temp6/power plain user float + hsetprop ${scobj_hpath}/Temp6/power read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB1.H1:HTR:SIG:POWR} + hsetprop ${scobj_hpath}/Temp6/power rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp6/power control true + hsetprop ${scobj_hpath}/Temp6/power data true + hsetprop ${scobj_hpath}/Temp6/power mutable true + hsetprop ${scobj_hpath}/Temp6/power nxsave true + hsetprop ${scobj_hpath}/Temp6/power oldval 0.0 + hsetprop ${scobj_hpath}/Temp6/power klass "parameter" + hsetprop ${scobj_hpath}/Temp6/power sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp6/power type "part" + hsetprop ${scobj_hpath}/Temp6/power nxalias "${name}_Temp6_power" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp6/power 5 + hsetprop ${scobj_hpath}/Temp6/power simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp6/power simulated true + } + } + + hfactory ${scobj_hpath}/Temp6/sensor plain user float + hsetprop ${scobj_hpath}/Temp6/sensor read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB6.T1:TEMP:SIG:TEMP} + hsetprop ${scobj_hpath}/Temp6/sensor rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp6/sensor control true + hsetprop ${scobj_hpath}/Temp6/sensor data true + hsetprop ${scobj_hpath}/Temp6/sensor mutable true + hsetprop ${scobj_hpath}/Temp6/sensor nxsave true + hsetprop ${scobj_hpath}/Temp6/sensor permlink data_set "T[format "%02d" ${id}]S06" + hsetprop ${scobj_hpath}/Temp6/sensor @description "T[format "%02d" ${id}]S06" + hsetprop ${scobj_hpath}/Temp6/sensor oldval 0.0 + hsetprop ${scobj_hpath}/Temp6/sensor klass "parameter" + hsetprop ${scobj_hpath}/Temp6/sensor sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp6/sensor type "part" + hsetprop ${scobj_hpath}/Temp6/sensor nxalias "${name}_Temp6_sensor" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp6/sensor 1 + hsetprop ${scobj_hpath}/Temp6/sensor simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp6/sensor simulated true + } + + if {[string equal -nocase [string index ${cards} 0] H] && [string equal -nocase [string index ${assoc} 5] 1]} { + hfactory ${scobj_hpath}/Temp6/setpoint plain user float + hsetprop ${scobj_hpath}/Temp6/setpoint read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB6.T1:TEMP:LOOP:TSET} + hsetprop ${scobj_hpath}/Temp6/setpoint rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp6/setpoint write ${ns}::setPoint ${scobj_hpath} noResponse {SET:DEV:DB6.T1:TEMP:LOOP:TSET:} + hsetprop ${scobj_hpath}/Temp6/setpoint noResponse ${ns}::noResponse ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp6/setpoint check ${ns}::checkrange ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp6/setpoint driving 0 + hsetprop ${scobj_hpath}/Temp6/setpoint checklimits ${ns}::checklimits ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp6/setpoint checkstatus ${ns}::checkstatus ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp6/setpoint halt ${ns}::halt ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp6/setpoint driveable Temp6/sensor + hsetprop ${scobj_hpath}/Temp6/setpoint control true + hsetprop ${scobj_hpath}/Temp6/setpoint data true + hsetprop ${scobj_hpath}/Temp6/setpoint mutable true + hsetprop ${scobj_hpath}/Temp6/setpoint nxsave true + hsetprop ${scobj_hpath}/Temp6/setpoint lowerlimit 0 + hsetprop ${scobj_hpath}/Temp6/setpoint upperlimit 333 + hsetprop ${scobj_hpath}/Temp6/setpoint tolerance ${ttol} + hsetprop ${scobj_hpath}/Temp6/setpoint permlink data_set "T[format "%02d" ${id}]SP06" + hsetprop ${scobj_hpath}/Temp6/setpoint @description "T[format "%02d" ${id}]SP06" + hsetprop ${scobj_hpath}/Temp6/setpoint oldval 0.0 + hsetprop ${scobj_hpath}/Temp6/setpoint klass "parameter" + hsetprop ${scobj_hpath}/Temp6/setpoint sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp6/setpoint settle_time "15" + hsetprop ${scobj_hpath}/Temp6/setpoint type "drivable" + hsetprop ${scobj_hpath}/Temp6/setpoint nxalias "${name}_Temp6_setpoint" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp6/setpoint 5 + ${sct_controller} write ${scobj_hpath}/Temp6/setpoint + hsetprop ${scobj_hpath}/Temp6/setpoint simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp6/setpoint simulated true + } + } + hsetprop ${scobj_hpath}/Temp6 data "true" + hsetprop ${scobj_hpath}/Temp6 klass "@none" + hsetprop ${scobj_hpath}/Temp6 type "part" + if {[string equal -nocase [string index ${cards} 0] H] && [string equal -nocase [string index ${assoc} 5] 1]} { + ansto_makesctdrive ${name}_Temp6_setpoint ${scobj_hpath}/Temp6/setpoint ${scobj_hpath}/Temp6/sensor ${sct_controller} + } + } + + if {[string equal -nocase [string index ${cards} 6] T]} { + hfactory ${scobj_hpath}/Temp7 plain spy none + + hfactory ${scobj_hpath}/Temp7/nick plain user text + hsetprop ${scobj_hpath}/Temp7/nick read ${ns}::getValue ${scobj_hpath} rdText {READ:DEV:DB7.T1:TEMP:NICK} + hsetprop ${scobj_hpath}/Temp7/nick rdText ${ns}::rdText ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp7/nick control true + hsetprop ${scobj_hpath}/Temp7/nick data true + hsetprop ${scobj_hpath}/Temp7/nick mutable true + hsetprop ${scobj_hpath}/Temp7/nick nxsave true + hsetprop ${scobj_hpath}/Temp7/nick oldval UNKNOWN + hsetprop ${scobj_hpath}/Temp7/nick klass "parameter" + hsetprop ${scobj_hpath}/Temp7/nick sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp7/nick type "part" + hsetprop ${scobj_hpath}/Temp7/nick nxalias "${name}_Temp7_nick" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp7/nick 15 + hsetprop ${scobj_hpath}/Temp7/nick simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp7/nick simulated true + } + + if {[string equal -nocase [string index ${cards} 1] H] && [string equal -nocase [string index ${assoc} 6] 2]} { + hfactory ${scobj_hpath}/Temp7/power plain user float + hsetprop ${scobj_hpath}/Temp7/power read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB2.H1:HTR:SIG:POWR} + hsetprop ${scobj_hpath}/Temp7/power rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp7/power control true + hsetprop ${scobj_hpath}/Temp7/power data true + hsetprop ${scobj_hpath}/Temp7/power mutable true + hsetprop ${scobj_hpath}/Temp7/power nxsave true + hsetprop ${scobj_hpath}/Temp7/power oldval 0.0 + hsetprop ${scobj_hpath}/Temp7/power klass "parameter" + hsetprop ${scobj_hpath}/Temp7/power sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp7/power type "part" + hsetprop ${scobj_hpath}/Temp7/power nxalias "${name}_Temp7_power" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp7/power 5 + hsetprop ${scobj_hpath}/Temp7/power simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp7/power simulated true + } + } + + hfactory ${scobj_hpath}/Temp7/sensor plain user float + hsetprop ${scobj_hpath}/Temp7/sensor read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB7.T1:TEMP:SIG:TEMP} + hsetprop ${scobj_hpath}/Temp7/sensor rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp7/sensor control true + hsetprop ${scobj_hpath}/Temp7/sensor data true + hsetprop ${scobj_hpath}/Temp7/sensor mutable true + hsetprop ${scobj_hpath}/Temp7/sensor nxsave true + hsetprop ${scobj_hpath}/Temp7/sensor permlink data_set "T[format "%02d" ${id}]S07" + hsetprop ${scobj_hpath}/Temp7/sensor @description "T[format "%02d" ${id}]S07" + hsetprop ${scobj_hpath}/Temp7/sensor oldval 0.0 + hsetprop ${scobj_hpath}/Temp7/sensor klass "parameter" + hsetprop ${scobj_hpath}/Temp7/sensor sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp7/sensor type "part" + hsetprop ${scobj_hpath}/Temp7/sensor nxalias "${name}_Temp7_sensor" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp7/sensor 1 + hsetprop ${scobj_hpath}/Temp7/sensor simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp7/sensor simulated true + } + + if {[string equal -nocase [string index ${cards} 1] H] && [string equal -nocase [string index ${assoc} 6] 2]} { + hfactory ${scobj_hpath}/Temp7/setpoint plain user float + hsetprop ${scobj_hpath}/Temp7/setpoint read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB7.T1:TEMP:LOOP:TSET} + hsetprop ${scobj_hpath}/Temp7/setpoint rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp7/setpoint write ${ns}::setPoint ${scobj_hpath} noResponse {SET:DEV:DB7.T1:TEMP:LOOP:TSET:} + hsetprop ${scobj_hpath}/Temp7/setpoint noResponse ${ns}::noResponse ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp7/setpoint check ${ns}::checkrange ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp7/setpoint driving 0 + hsetprop ${scobj_hpath}/Temp7/setpoint checklimits ${ns}::checklimits ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp7/setpoint checkstatus ${ns}::checkstatus ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp7/setpoint halt ${ns}::halt ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp7/setpoint driveable Temp7/sensor + hsetprop ${scobj_hpath}/Temp7/setpoint control true + hsetprop ${scobj_hpath}/Temp7/setpoint data true + hsetprop ${scobj_hpath}/Temp7/setpoint mutable true + hsetprop ${scobj_hpath}/Temp7/setpoint nxsave true + hsetprop ${scobj_hpath}/Temp7/setpoint lowerlimit 0 + hsetprop ${scobj_hpath}/Temp7/setpoint upperlimit 333 + hsetprop ${scobj_hpath}/Temp7/setpoint tolerance ${ttol} + hsetprop ${scobj_hpath}/Temp7/setpoint permlink data_set "T[format "%02d" ${id}]SP07" + hsetprop ${scobj_hpath}/Temp7/setpoint @description "T[format "%02d" ${id}]SP07" + hsetprop ${scobj_hpath}/Temp7/setpoint oldval 0.0 + hsetprop ${scobj_hpath}/Temp7/setpoint klass "parameter" + hsetprop ${scobj_hpath}/Temp7/setpoint sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp7/setpoint settle_time "15" + hsetprop ${scobj_hpath}/Temp7/setpoint type "drivable" + hsetprop ${scobj_hpath}/Temp7/setpoint nxalias "${name}_Temp7_setpoint" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp7/setpoint 5 + ${sct_controller} write ${scobj_hpath}/Temp7/setpoint + hsetprop ${scobj_hpath}/Temp7/setpoint simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp7/setpoint simulated true + } + } + hsetprop ${scobj_hpath}/Temp7 data "true" + hsetprop ${scobj_hpath}/Temp7 klass "@none" + hsetprop ${scobj_hpath}/Temp7 type "part" + if {[string equal -nocase [string index ${cards} 1] H] && [string equal -nocase [string index ${assoc} 6] 2]} { + ansto_makesctdrive ${name}_Temp7_setpoint ${scobj_hpath}/Temp7/setpoint ${scobj_hpath}/Temp7/sensor ${sct_controller} + } + } + + if {[string equal -nocase [string index ${cards} 7] T]} { + hfactory ${scobj_hpath}/Temp8 plain spy none + + hfactory ${scobj_hpath}/Temp8/nick plain user text + hsetprop ${scobj_hpath}/Temp8/nick read ${ns}::getValue ${scobj_hpath} rdText {READ:DEV:DB8.T1:TEMP:NICK} + hsetprop ${scobj_hpath}/Temp8/nick rdText ${ns}::rdText ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp8/nick control true + hsetprop ${scobj_hpath}/Temp8/nick data true + hsetprop ${scobj_hpath}/Temp8/nick mutable true + hsetprop ${scobj_hpath}/Temp8/nick nxsave true + hsetprop ${scobj_hpath}/Temp8/nick oldval UNKNOWN + hsetprop ${scobj_hpath}/Temp8/nick klass "parameter" + hsetprop ${scobj_hpath}/Temp8/nick sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp8/nick type "part" + hsetprop ${scobj_hpath}/Temp8/nick nxalias "${name}_Temp8_nick" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp8/nick 15 + hsetprop ${scobj_hpath}/Temp8/nick simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp8/nick simulated true + } + + if {[string equal -nocase [string index ${cards} 2] H] && [string equal -nocase [string index ${assoc} 7] 3]} { + hfactory ${scobj_hpath}/Temp8/power plain user float + hsetprop ${scobj_hpath}/Temp8/power read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB3.H1:HTR:SIG:POWR} + hsetprop ${scobj_hpath}/Temp8/power rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp8/power control true + hsetprop ${scobj_hpath}/Temp8/power data true + hsetprop ${scobj_hpath}/Temp8/power mutable true + hsetprop ${scobj_hpath}/Temp8/power nxsave true + hsetprop ${scobj_hpath}/Temp8/power oldval 0.0 + hsetprop ${scobj_hpath}/Temp8/power klass "parameter" + hsetprop ${scobj_hpath}/Temp8/power sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp8/power type "part" + hsetprop ${scobj_hpath}/Temp8/power nxalias "${name}_Temp8_power" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp8/power 5 + hsetprop ${scobj_hpath}/Temp8/power simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp8/power simulated true + } + } + + hfactory ${scobj_hpath}/Temp8/sensor plain user float + hsetprop ${scobj_hpath}/Temp8/sensor read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB8.T1:TEMP:SIG:TEMP} + hsetprop ${scobj_hpath}/Temp8/sensor rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp8/sensor control true + hsetprop ${scobj_hpath}/Temp8/sensor data true + hsetprop ${scobj_hpath}/Temp8/sensor mutable true + hsetprop ${scobj_hpath}/Temp8/sensor nxsave true + hsetprop ${scobj_hpath}/Temp8/sensor permlink data_set "T[format "%02d" ${id}]S08" + hsetprop ${scobj_hpath}/Temp8/sensor @description "T[format "%02d" ${id}]S08" + hsetprop ${scobj_hpath}/Temp8/sensor oldval 0.0 + hsetprop ${scobj_hpath}/Temp8/sensor klass "parameter" + hsetprop ${scobj_hpath}/Temp8/sensor sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp8/sensor type "part" + hsetprop ${scobj_hpath}/Temp8/sensor nxalias "${name}_Temp8_sensor" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp8/sensor 1 + hsetprop ${scobj_hpath}/Temp8/sensor simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp8/sensor simulated true + } + + if {[string equal -nocase [string index ${cards} 2] H] && [string equal -nocase [string index ${assoc} 7] 3]} { + hfactory ${scobj_hpath}/Temp8/setpoint plain user float + hsetprop ${scobj_hpath}/Temp8/setpoint read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB8.T1:TEMP:LOOP:TSET} + hsetprop ${scobj_hpath}/Temp8/setpoint rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp8/setpoint write ${ns}::setPoint ${scobj_hpath} noResponse {SET:DEV:DB8.T1:TEMP:LOOP:TSET:} + hsetprop ${scobj_hpath}/Temp8/setpoint noResponse ${ns}::noResponse ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp8/setpoint check ${ns}::checkrange ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp8/setpoint driving 0 + hsetprop ${scobj_hpath}/Temp8/setpoint checklimits ${ns}::checklimits ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp8/setpoint checkstatus ${ns}::checkstatus ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp8/setpoint halt ${ns}::halt ${scobj_hpath} + hsetprop ${scobj_hpath}/Temp8/setpoint driveable Temp8/sensor + hsetprop ${scobj_hpath}/Temp8/setpoint control true + hsetprop ${scobj_hpath}/Temp8/setpoint data true + hsetprop ${scobj_hpath}/Temp8/setpoint mutable true + hsetprop ${scobj_hpath}/Temp8/setpoint nxsave true + hsetprop ${scobj_hpath}/Temp8/setpoint lowerlimit 0 + hsetprop ${scobj_hpath}/Temp8/setpoint upperlimit 333 + hsetprop ${scobj_hpath}/Temp8/setpoint tolerance ${ttol} + hsetprop ${scobj_hpath}/Temp8/setpoint permlink data_set "T[format "%02d" ${id}]SP08" + hsetprop ${scobj_hpath}/Temp8/setpoint @description "T[format "%02d" ${id}]SP08" + hsetprop ${scobj_hpath}/Temp8/setpoint oldval 0.0 + hsetprop ${scobj_hpath}/Temp8/setpoint klass "parameter" + hsetprop ${scobj_hpath}/Temp8/setpoint sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Temp8/setpoint settle_time "15" + hsetprop ${scobj_hpath}/Temp8/setpoint type "drivable" + hsetprop ${scobj_hpath}/Temp8/setpoint nxalias "${name}_Temp8_setpoint" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Temp8/setpoint 5 + ${sct_controller} write ${scobj_hpath}/Temp8/setpoint + hsetprop ${scobj_hpath}/Temp8/setpoint simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Temp8/setpoint simulated true + } + } + hsetprop ${scobj_hpath}/Temp8 data "true" + hsetprop ${scobj_hpath}/Temp8 klass "@none" + hsetprop ${scobj_hpath}/Temp8 type "part" + if {[string equal -nocase [string index ${cards} 2] H] && [string equal -nocase [string index ${assoc} 7] 3]} { + ansto_makesctdrive ${name}_Temp8_setpoint ${scobj_hpath}/Temp8/setpoint ${scobj_hpath}/Temp8/sensor ${sct_controller} + } + } + + if {[string equal -nocase [string index ${cards} 3] V]} { + hfactory ${scobj_hpath}/Valve plain spy none + + hfactory ${scobj_hpath}/Valve/nick plain user text + hsetprop ${scobj_hpath}/Valve/nick read ${ns}::getValue ${scobj_hpath} rdText {READ:DEV:DB4.G1:AUX:NICK} + hsetprop ${scobj_hpath}/Valve/nick rdText ${ns}::rdText ${scobj_hpath} + hsetprop ${scobj_hpath}/Valve/nick control true + hsetprop ${scobj_hpath}/Valve/nick data true + hsetprop ${scobj_hpath}/Valve/nick mutable true + hsetprop ${scobj_hpath}/Valve/nick nxsave true + hsetprop ${scobj_hpath}/Valve/nick oldval UNKNOWN + hsetprop ${scobj_hpath}/Valve/nick klass "parameter" + hsetprop ${scobj_hpath}/Valve/nick sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Valve/nick type "part" + hsetprop ${scobj_hpath}/Valve/nick nxalias "${name}_Valve_nick" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Valve/nick 15 + hsetprop ${scobj_hpath}/Valve/nick simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Valve/nick simulated true + } + + hfactory ${scobj_hpath}/Valve/sensor plain user float + hsetprop ${scobj_hpath}/Valve/sensor read ${ns}::getValue ${scobj_hpath} rdValue {READ:DEV:DB4.G1:AUX:SIG:OPEN} + hsetprop ${scobj_hpath}/Valve/sensor rdValue ${ns}::rdValue ${scobj_hpath} + hsetprop ${scobj_hpath}/Valve/sensor control true + hsetprop ${scobj_hpath}/Valve/sensor data true + hsetprop ${scobj_hpath}/Valve/sensor mutable true + hsetprop ${scobj_hpath}/Valve/sensor nxsave true + hsetprop ${scobj_hpath}/Valve/sensor oldval 0.0 + hsetprop ${scobj_hpath}/Valve/sensor klass "parameter" + hsetprop ${scobj_hpath}/Valve/sensor sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Valve/sensor type "part" + hsetprop ${scobj_hpath}/Valve/sensor nxalias "${name}_Valve_sensor" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} poll ${scobj_hpath}/Valve/sensor 5 + hsetprop ${scobj_hpath}/Valve/sensor simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Valve/sensor simulated true + } + + hfactory ${scobj_hpath}/Valve/setpoint plain user float + hsetprop ${scobj_hpath}/Valve/setpoint write ${ns}::setValve ${scobj_hpath} noResponse {SET:DEV:DB4.G1:AUX:SIG:OPEN:} + hsetprop ${scobj_hpath}/Valve/setpoint noResponse ${ns}::noResponse ${scobj_hpath} + hsetprop ${scobj_hpath}/Valve/setpoint check ${ns}::checkrange ${scobj_hpath} + hsetprop ${scobj_hpath}/Valve/setpoint driving 0 + hsetprop ${scobj_hpath}/Valve/setpoint checklimits ${ns}::checklimits ${scobj_hpath} + hsetprop ${scobj_hpath}/Valve/setpoint checkstatus ${ns}::checkstatus ${scobj_hpath} + hsetprop ${scobj_hpath}/Valve/setpoint halt ${ns}::halt ${scobj_hpath} + hsetprop ${scobj_hpath}/Valve/setpoint driveable Valve/sensor + hsetprop ${scobj_hpath}/Valve/setpoint control true + hsetprop ${scobj_hpath}/Valve/setpoint data true + hsetprop ${scobj_hpath}/Valve/setpoint mutable true + hsetprop ${scobj_hpath}/Valve/setpoint nxsave true + hsetprop ${scobj_hpath}/Valve/setpoint lowerlimit 0 + hsetprop ${scobj_hpath}/Valve/setpoint upperlimit 100 + hsetprop ${scobj_hpath}/Valve/setpoint tolerance ${vtol} + hsetprop ${scobj_hpath}/Valve/setpoint oldval 0.0 + hsetprop ${scobj_hpath}/Valve/setpoint klass "parameter" + hsetprop ${scobj_hpath}/Valve/setpoint sdsinfo "::nexus::scobj::sdsinfo" + hsetprop ${scobj_hpath}/Valve/setpoint settle_time "30" + hsetprop ${scobj_hpath}/Valve/setpoint type "drivable" + hsetprop ${scobj_hpath}/Valve/setpoint nxalias "${name}_Valve_setpoint" + + if {[string equal -nocase "${simulation_flag}" "false"]} { + ${sct_controller} write ${scobj_hpath}/Valve/setpoint + hsetprop ${scobj_hpath}/Valve/setpoint simulated false + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford_mercury" + hsetprop ${scobj_hpath}/Valve/setpoint simulated true + } + hsetprop ${scobj_hpath}/Valve data "true" + hsetprop ${scobj_hpath}/Valve klass "@none" + hsetprop ${scobj_hpath}/Valve type "part" + ansto_makesctdrive ${name}_Valve_setpoint ${scobj_hpath}/Valve/setpoint ${scobj_hpath}/Valve/sensor ${sct_controller} + } + hsetprop ${scobj_hpath} klass ${device_class} + hsetprop ${scobj_hpath} data true + hsetprop ${scobj_hpath} debug_threshold 5 +# mkDriver hook code goes here + } catch_message ] + handle_exception ${catch_status} ${catch_message} +} + +proc ::scobj::oxford_mercury::add_driver {name device_class simulation_flag ip_address tcp_port id {cards NNNNNNNN} {assoc 00000000} {ttol 1} {ptol 5} {vtol 5}} { + set catch_status [ catch { + ::scobj::oxford_mercury::sics_log 9 "::scobj::oxford_mercury::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${cards} ${assoc} ${ttol} ${ptol} ${vtol}" + if {[string equal -nocase "${simulation_flag}" "false"]} { + if {[string equal -nocase "aqadapter" "${ip_address}"]} { + ::scobj::oxford_mercury::sics_log 9 "makesctcontroller sct_${name} aqadapter ${tcp_port}" + makesctcontroller sct_${name} aqadapter ${tcp_port} + } else { + ::scobj::oxford_mercury::sics_log 9 "makesctcontroller sct_${name} std ${ip_address}:${tcp_port}" + makesctcontroller sct_${name} std ${ip_address}:${tcp_port} + } + } else { + ::scobj::oxford_mercury::sics_log 9 "simulation_flag=${simulation_flag} => Null sctcontroller for oxford_mercury" + ::scobj::oxford_mercury::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL" + makesctcontroller sct_${name} aqadapter NULL + } + ::scobj::oxford_mercury::sics_log 1 "::scobj::oxford_mercury::mkDriver sct_${name} ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${cards} ${assoc} ${ttol} ${ptol} ${vtol}" + ::scobj::oxford_mercury::mkDriver sct_${name} ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${cards} ${assoc} ${ttol} ${ptol} ${vtol} + } catch_message ] + handle_exception ${catch_status} ${catch_message} +} + +namespace eval ::scobj::oxford_mercury { + namespace export debug_threshold + namespace export debug_log + namespace export sics_log + namespace export mkDriver + namespace export add_driver +} + +proc add_oxford_mercury {name ip_address tcp_port id {cards NNNNNNNN} {assoc 00000000} {ttol 1} {ptol 5} {vtol 5}} { + set simulation_flag "[string tolower [SplitReply [environment_simulation]]]" + ::scobj::oxford_mercury::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${cards} ${assoc} ${ttol} ${ptol} ${vtol} +} + +clientput "file evaluation of sct_oxford_mercury.tcl" +::scobj::oxford_mercury::sics_log 9 "file evaluation of sct_oxford_mercury.tcl" + +proc ::scobj::oxford_mercury::read_config {} { + set catch_status [ catch { + set ns "::scobj::oxford_mercury" + dict for {k u} $::config_dict { + if { [dict exists $u "implementation"] } { + set simulation_flag "[string tolower [SplitReply [environment_simulation]]]" + set device_class "environment" + if { !([dict exists $u "name"] && [dict exists $u "enabled"]) } { + continue + } + set enabled [string tolower [dict get $u "enabled"]] + if { ! ([string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"]) } { + continue + } + if { [dict exists $u "simulation_group"] } { + set simulation_flag [SplitReply [[string tolower [dict get $u "simulation_group"]]]] + } + if { [dict exists $u "device_class"] } { + set device_class "[dict get $u "device_class"]" + } + set name [dict get $u name] + set implementation [dict get $u "implementation"] + if { !([dict exists $::config_dict $implementation]) } { + continue + } + set v [dict get $::config_dict $implementation] + if { !([dict exists $v "driver"]) } { + continue + } + if { [string equal -nocase [dict get $v "driver"] "oxford_mercury"] } { + 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 "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"]" + } + } + 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"]" + } + makesctcontroller sct_${name} aqadapter ${asyncqueue} + } + set arg_list [list] + set missing_list [list] + array unset default_map + array set default_map [list cards NNNNNNNN assoc 00000000 ttol 1 ptol 5 vtol 5] + foreach arg {id cards assoc ttol ptol vtol} { + 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" + } + ${ns}::mkDriver sct_${name} ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} {*}$arg_list + } + } + } + } catch_message ] + handle_exception ${catch_status} ${catch_message} +} + +if { [info exists ::config_dict] } { + ::scobj::oxford_mercury::read_config +} else { + ::scobj::oxford_mercury::sics_log 5 "No config dict" +}