From 4afb1a765cdc0cb6506c1125cefb3fb639498f63 Mon Sep 17 00:00:00 2001 From: Douglas Clowes Date: Fri, 25 Jun 2010 15:16:28 +1000 Subject: [PATCH] Oxford Intelligent Power Supply IPS120-10 r2964 | dcl | 2010-06-25 15:16:28 +1000 (Fri, 25 Jun 2010) | 2 lines --- .../magneticField/sct_oxford_ips.tcl | 685 ++++++++++++++++++ 1 file changed, 685 insertions(+) create mode 100644 site_ansto/instrument/config/environment/magneticField/sct_oxford_ips.tcl diff --git a/site_ansto/instrument/config/environment/magneticField/sct_oxford_ips.tcl b/site_ansto/instrument/config/environment/magneticField/sct_oxford_ips.tcl new file mode 100644 index 00000000..d3b47631 --- /dev/null +++ b/site_ansto/instrument/config/environment/magneticField/sct_oxford_ips.tcl @@ -0,0 +1,685 @@ +# Define procs in ::scobj::xxx namespace +# MakeSICSObj $obj SCT_ +# The MakeSICSObj cmd adds a /sics/$obj node. NOTE the /sics node is not browsable. + + +namespace eval ::scobj::ips120 { +# Environment controllers should have at least the following nodes +# /envcont/setpoint +# /envcont/sensor/value + proc debug_log {args} { + set fd [open "/tmp/ips120.log" a] + puts $fd "[clock format [clock seconds] -format "%T"] $args" + close $fd + } + +# issue a command to read a register and expect a value response + proc getValue {tc_root nextState cmd} { +debug_log "getValue $cmd sct=[sct] root=$tc_root nextState=$nextState" + sct send "@2$cmd" + return $nextState + } + +# issue a command with a value in the target property of the variable + proc setValue {tc_root nextState cmd} { +debug_log "setValue cmd=$cmd sct=[sct] $tc_root" + set par "[sct target]" + sct send "@2$cmd$par" +debug_log "setValue $cmd$par" + return $nextState + } + + proc chkWrite {tc_root} { + set data [sct result] +debug_log "chkWrite resp=$data sct=[sct] tc_root=$tc_root" + if {[string equal -nocase -length 7 $data "ASCERR:"]} { + sct geterror "$data" + } elseif {[string equal -nocase -length 1 $data "?"]} { + sct geterror "Error: $data" + } + return idle + } + + proc setPoint {tc_root nextState cmd} { + set catch_status [ catch { +debug_log "setPoint $tc_root $nextState $cmd sct=[sct]" + sct print "setPoint: sct=[sct] target=[sct target] writestatus=[sct writestatus]" + set err_msg "" + if { [hval $tc_root/Display/A] == 4 } { + set err_msg "Output is clamped (A=[hval $tc_root/Display/A])" + } elseif { [hval $tc_root/Display/C] != 3 } { + set err_msg "Control is not remote (C=[hval $tc_root/Display/C])" + } elseif { [hval $tc_root/Display/PstntField] == [sct target] } { + sct print "Persistent Field ([hval $tc_root/Display/PstntField]) already at target ([sct target])" + return idle + } + if { $err_msg != "" } { + sct print "error:$err_msg" + debug_log "error:$err_msg" + return -code error "$err_msg" + } + sct print "Driving Persistent Field ([hval $tc_root/Display/PstntField]) to target ([sct target])" + set par "[sct target]" + hset $tc_root/status "busy" + sct print "status: busy" + hset $tc_root/drive_state "START" + hsetprop $tc_root/setpoint driving 1 + } catch_message ] + if {$catch_status != 0} { + return -code error $catch_message + } + sct print "setPoint: [hget $tc_root/drive_state]" + return $nextState + } + + proc rdValue {tc_root} { +debug_log "rdValue tc_root=$tc_root sct=[sct]" + set data [sct result] + if {[ catch { +debug_log "rdValue $tc_root [sct] result=$data" + } catch_message ]} { +debug_log "rdValue $tc_root failure" + } + if {[string equal -nocase -length 7 $data "ASCERR:"]} { + sct geterror "$data" + set nextState idle + } elseif {[string equal -nocase -length 1 $data "?"]} { + sct geterror "Error: $data" + set nextState idle + } else { + if {[string index $data 0] == "R"} { + set data [string range $data 1 end] + set rslt [scan $data %f data] +debug_log "rdValue $tc_root IPS120 result=$data" + } + if {$data != [sct oldval]} { + sct oldval $data + sct update $data + sct utime readtime +debug_log "rdValue new data for $tc_root [sct] result=$data" + } + } + return idle + } + +# This is the command phase of the state machine that drives the controller. +# For each state, it sends the appropriate command to get values from, or set +# values in the controller in a sequence intended to transition the controller +# between states. + proc getState {tc_root nextState cmd} { +debug_log "getState $tc_root $nextState $cmd sct=[sct]" + if {[ catch { + set my_state "[SplitReply [hgetprop $tc_root/ips120_state my_state]]" + if {$my_state == "STATE_V"} { + set my_cmd "V" + } elseif {$my_state == "STATE_X"} { + set my_cmd "X" + } elseif {$my_state == "STATE_C"} { + set my_cmd "C3" + } elseif {$my_state == "STATE_A0"} { + set my_cmd "A0" + } elseif {$my_state == "STATE_A1"} { + set my_cmd "A1" + } elseif {$my_state == "STATE_A2"} { + set my_cmd "A2" + } elseif {$my_state == "STATE_H0"} { + set my_cmd "H0" + } elseif {$my_state == "STATE_H1"} { + set my_cmd "H1" + } elseif {$my_state == "STATE_I"} { + if { [hval $tc_root/Display/H] == 1 } { + set my_cmd "I[hval $tc_root/Display/OutputCurrent]" + } elseif { ([hval $tc_root/Display/H] == 0 || [hval $tc_root/Display/H] == 2) } { + set my_cmd "I[hval $tc_root/Display/PstntCurrent]" + } + } elseif {$my_state == "STATE_J"} { + set my_cmd "J[SplitReply [hgetprop $tc_root/setpoint target]]" + } elseif {$my_state == "STATE_F"} { + set my_cmd "F7" + } else { + hsetprop $tc_root/ips120_state my_state "STATE_X" + set my_cmd "X" + } + sct send "@2$my_cmd" +debug_log "getState end $tc_root state=$my_state, cmd=$my_cmd" + } catch_message ]} { +debug_log "getState error: $catch_message" + } +debug_log "getState returns: $nextState" + return $nextState + } + +# This is the response phase of the state machine that drives the controller. +# For each state, it reads the appropriate command response from the controller +# and, based on the response and internal variables performs a sequence +# intended to transition the controller between states. + + ## + # @brief Reads the current ips120 state and error messages. + proc rdState {tc_root} { + debug_log "rdState $tc_root sct=[sct] response=\"[sct result]\"" + set nextState {} + if {[ catch { + set data "[sct result]" + if {[string equal -nocase -length 7 $data "ASCERR:"]} { + sct geterror "$data" + set nextState idle + } elseif {[string equal -nocase -length 1 $data "?"]} { + sct geterror "Error: $data" + set nextState idle + } else { + set my_state "[SplitReply [hgetprop $tc_root/ips120_state my_state]]" +debug_log "rdState $tc_root state=$my_state, response=\"[sct result]\"" + if {$my_state == "STATE_V"} { + set my_version "[sct result]" + hsetprop $tc_root/ips120_state my_version "$my_version" + hsetprop $tc_root/ips120_state my_state "STATE_X" +debug_log "rdState $tc_root state=$my_state" + set nextState read + } elseif {$my_state == "STATE_X"} { + hsetprop $tc_root/ips120_state my_status "[sct result]" + set my_status "[SplitReply [hgetprop $tc_root/ips120_state my_status]]" +debug_log "rdState my_status=$my_status" + set rslt [scan $my_status "X%dA%dC%dH%dM%dP%d" the_x the_a the_c the_h the_m the_p] + if {$rslt == 6} { + if { [hval $tc_root/Display/X] != $the_x } { hset $tc_root/Display/X $the_x } + if { [hval $tc_root/Display/A] != $the_a } { hset $tc_root/Display/A $the_a } + if { [hval $tc_root/Display/C] != $the_c } { hset $tc_root/Display/C $the_c } + if { [hval $tc_root/Display/H] != $the_h } { hset $tc_root/Display/H $the_h } + if { [hval $tc_root/Display/M] != $the_m } { hset $tc_root/Display/M $the_m } + if { [hval $tc_root/Display/P] != $the_p } { hset $tc_root/Display/P $the_p } +debug_log "rdState $tc_root status($rslt)= X[format %02d $the_x] A$the_a C$the_c H$the_h M[format %02d $the_m] P[format %02d $the_p]" +# make decisions on next state + if { $the_c == 0 && $the_a == 4 && $the_m % 10 == 0 } { +# looks like power up TODO report an error? + debug_log "rdState: looks like power up c=$the_c a=$the_a m-$the_m" + } + if { [catch { + if { $the_h == 2 && "[hval $tc_root/Display/PstntCurrent]" != 0 && "[hval $tc_root/Display/OutputCurrent]" == 0 } { + if { [hval $tc_root/Display/Persistent] != 1 } { hset $tc_root/Display/Persistent 1 } + } else { + if { [hval $tc_root/Display/Persistent] != 0 } { hset $tc_root/Display/Persistent 0 } + } + } catch_message] } { +debug_log "rdState catch triggered on Persistent determination: $catch_message" + if { [hval $tc_root/Display/Persistent] != 0 } { hset $tc_root/Display/Persistent 0 } + } + if { [catch { + if { [hpropexists $tc_root/sensor/value geterror] } { hdelprop $tc_root/sensor/value geterror } + if { $the_h == 0 || $the_h == 2 } { + if { [hval $tc_root/sensor/value] != [hval $tc_root/Display/PstntField] } { + hset $tc_root/sensor/value [hval $tc_root/Display/PstntField] + } + } else { + if { [hval $tc_root/sensor/value] != [hval $tc_root/Display/OutputField] } { + hset $tc_root/sensor/value [hval $tc_root/Display/OutputField] + } + } + } catch_message] } { +debug_log "rdState catch triggered on Sensor determination: $catch_message" + if { [hpropexists $tc_root/sensor/value geterror] } { hdelprop $tc_root/sensor/value geterror } + if { [hval $tc_root/sensor/value] != 0 } { hset $tc_root/sensor/value 0 } + } + set my_driving [SplitReply [hgetprop $tc_root/setpoint driving]] + if { $the_c != 3 } { + hsetprop $tc_root/ips120_state my_state "STATE_C" + set nextState read + } elseif { $my_driving } { + if { [hval $tc_root/drive_state] == "IDLE" } { + } elseif { [hval $tc_root/drive_state] == "START" } { + if { [hval $tc_root/Display/H] == 1 && [hval $tc_root/Display/OutputCurrent] != [hval $tc_root/Display/TargetCurrent] } { + hsetprop $tc_root/ips120_state my_state "STATE_I" + set nextState read + } elseif { ([hval $tc_root/Display/H] == 0 || [hval $tc_root/Display/H] == 2) && [hval $tc_root/Display/PstntCurrent] != [hval $tc_root/Display/TargetCurrent] } { + hsetprop $tc_root/ips120_state my_state "STATE_I" + set nextState read + } elseif { $the_a != 1 } { + hsetprop $tc_root/ips120_state my_state "STATE_A1" + set nextState read + } elseif { $the_h != 1 } { + hsetprop $tc_root/ips120_state my_state "STATE_H1" + set nextState read + } else { + hsetprop $tc_root/ips120_state my_state "STATE_H1" + set nextState read + } + } elseif { [hval $tc_root/drive_state] == "RAMPING" } { + if { $the_m % 10 == 0 && [hval $tc_root/Display/OutputCurrent] == [hval $tc_root/Display/TargetCurrent] } { + hsetprop $tc_root/ips120_state my_state "STATE_H0" + set nextState read + } + } elseif { [hval $tc_root/drive_state] == "ZEROING" } { + if { $the_m % 10 == 0 && [hval $tc_root/Display/OutputCurrent] == 0 } { + hset $tc_root/drive_state "IDLE" + hset $tc_root/status "idle" + hsetprop $tc_root/setpoint driving 0 + set nextState read + } + } elseif { [hval $tc_root/drive_state] == "HOLDING" } { + if { [clock seconds] >= [SplitReply [hgetprop $tc_root/setpoint hold_time]] } { + if { $the_h == 0 } { + hset $tc_root/drive_state "ZEROING" + hsetprop $tc_root/ips120_state my_state "STATE_A2" + } elseif { $the_h == 2 } { + hset $tc_root/drive_state "ZEROING" + hsetprop $tc_root/ips120_state my_state "STATE_A2" + } elseif { $the_h == 1 } { + hset $tc_root/drive_state "RAMPING" + hsetprop $tc_root/ips120_state my_state "STATE_J" + set nextState read + } + } + } + } + } else { +debug_log "rdState $tc_root error scan status = $rslt on $my_status" + hsetprop $tc_root/ips120_state my_state "STATE_V" + set nextState idle + } + } elseif {$my_state == "STATE_C"} { + hsetprop $tc_root/ips120_state my_state "STATE_F" + set nextState read + } elseif {$my_state == "STATE_A0"} { + hsetprop $tc_root/ips120_state my_state "STATE_X" + set nextState idle + } elseif {$my_state == "STATE_A1"} { + hsetprop $tc_root/ips120_state my_state "STATE_X" + set nextState idle + } elseif {$my_state == "STATE_A2"} { + hsetprop $tc_root/ips120_state my_state "STATE_X" + set nextState idle + } elseif {$my_state == "STATE_H0"} { + hsetprop $tc_root/ips120_state my_state "STATE_X" + hsetprop $tc_root/setpoint hold_time [expr [clock seconds] + 30] + hset $tc_root/drive_state "HOLDING" + set nextState idle + } elseif {$my_state == "STATE_H1"} { + hsetprop $tc_root/ips120_state my_state "STATE_X" + hsetprop $tc_root/setpoint hold_time [expr [clock seconds] + 30] + hset $tc_root/drive_state "HOLDING" + set nextState idle + } elseif {$my_state == "STATE_I"} { + hsetprop $tc_root/ips120_state my_state "STATE_X" + set nextState idle + } elseif {$my_state == "STATE_J"} { + hsetprop $tc_root/ips120_state my_state "STATE_X" + set nextState idle + } elseif {$my_state == "STATE_F"} { + hsetprop $tc_root/ips120_state my_state "STATE_X" + } else { + hsetprop $tc_root/ips120_state my_state "STATE_X" + } +#DFC + if {0} { + if { $nextState == "" } { + set my_status "[SplitReply [hgetprop $tc_root/ips120_state my_status]]" + debug_log "rdState my_status=$my_status" + set rslt [scan $my_status "X%dA%dC%dH%dM%dP%d" the_x the_a the_c the_h the_m the_p] + debug_log "rdState $tc_root status($rslt)= X[format %02d $the_x] A$the_a C$the_c H$the_h M[format %02d $the_m] P[format %02d $the_p]" + set my_driving [SplitReply [hgetprop $tc_root/setpoint driving]] + debug_log "rdState $tc_root: driving=$my_driving" + if {[ catch { + set val "[hval $tc_root/setpoint]" + } message ]} { + set val 0 + debug_log "rdState $tc_root: setpoint=failure" + } + debug_log "rdState $tc_root: setpoint=$val" + if {[hpropexists $tc_root/setpoint target]} { + set tgt [SplitReply [hgetprop $tc_root/setpoint target]] + debug_log "rdState $tc_root: target=$tgt" + } else { + hsetprop $tc_root/setpoint target $val + set tgt [SplitReply [hgetprop $tc_root/setpoint target]] + debug_log "rdState $tc_root: initialised target to: target=$tgt" + } + if {$my_driving > 0} { + set field [hval $tc_root/sensor/value] + set tol [hval $tc_root/tolerance] + set lofield [expr {$tgt - $tol}] + set hifield [expr {$tgt + $tol}] + debug_log "rdState driving $tc_root until $field in ($lofield, $hifield)" + if {$field < $lofield} { + } elseif {$field > $hifield} { + } elseif { [expr $the_m % 10] == 0 } { + hset $tc_root/status "idle" + sct print "status: idle" + hset $tc_root/drive_state "IDLE" + hsetprop $tc_root/setpoint driving 0 + debug_log "rdState driving $tc_root finished at $field in ($lofield, $hifield)" + } + } + set nextState idle + } +#DFC + } else { + set nextState idle + } + } + } catch_message ]} { + debug_log "rdState error: $catch_message" + } + debug_log "rdState returns: $nextState" + return $nextState + } + + proc noResponse {} { + return idle + } + proc wrtValue {wcmd args} { + } + +# check that a target is within allowable limits + proc check {tc_root} { + set setpoint [sct target] + set lolimit [hval $tc_root/lowerlimit] + set hilimit [hval $tc_root/upperlimit] + if {$setpoint < $lolimit || $setpoint > $hilimit} { + error "setpoint violates limits" + } + return OK + } + +# Check that the sensor is reading within tolerance of the setpoint. +# Return 1 or 0 if it is or is not, respectively. + proc checktol {tc_root currtime timecheck} { +debug_log "checktol $tc_root $currtime $timecheck" + set field [hval $tc_root/sensor/value] + set lofield [expr {[$tc_root/setpoint] - [hval $tc_root/tolerance]}] + set hifield [expr {[$tc_root/setpoint] + [hval $tc_root/tolerance]}] + if { $field < $lofield || $field > $hifield} { + hset $tc_root/emon/isintol 0 + return 0 + } else { + set timeout [hval $tc_root/tolerance/settletime] + if { ($currtime - $timecheck) > $timeout } { + hset $tc_root/emon/isintol 1 + } + return 1 + } + } + +## +# @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} { + if {[sct driving]} { + return busy + } else { + sct print "drivestatus: idle" + return idle + } + } + + proc halt {tc_root} { +debug_log "halt $tc_root" + hset $tc_root/setpoint [hval $tc_root/sensor/value] + hset $tc_root/drive_state "IDLE" + hset $tc_root/status "idle" + hsetprop $tc_root/setpoint driving 0 + hsetprop $tc_root/ips120_state my_state "STATE_X" + return idle + } + +## +# @brief createNode() creates a node for the given nodename with the properties and virtual +# function names provided +# @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 ::scobj::ips120 + set ns "[namespace current]" + set nodeName "$scobj_hpath/$cmdGroup/$varName" + if {1 > [string length $cmdGroup]} { + set nodeName "$scobj_hpath/$varName" + } +debug_log "Creating node $nodeName" + hfactory $nodeName plain $permission $dataType + if {$readable > 0} { + hsetprop $nodeName read ${ns}::getValue $scobj_hpath $rdFunc $rdCmd + hsetprop $nodeName $rdFunc ${ns}::$rdFunc $scobj_hpath + set poll_period 30 + if { $readable >= 0 && $readable <= 9 } { + set poll_period [lindex [list 0 1 2 3 4 5 10 15 20 30] $readable] + } +debug_log "Registering node $nodeName for poll at $poll_period seconds" + $sct_controller poll $nodeName $poll_period + } + if {$writable == 1} { + set parts [split "$wrFunc" "."] + if { [llength $parts] == 2 } { + set func_name [lindex $parts 0] + set next_state [lindex $parts 1] + hsetprop $nodeName write ${ns}::$func_name $scobj_hpath $next_state $wrCmd + hsetprop $nodeName $next_state ${ns}::$next_state $scobj_hpath + } else { + hsetprop $nodeName write ${ns}::$wrFunc $scobj_hpath noResponse $wrCmd + hsetprop $nodeName noResponse ${ns}::noResponse + } + hsetprop $nodeName writestatus UNKNOWN +debug_log "Registering node $nodeName for write callback" + $sct_controller write $nodeName + } + switch -exact $dataType { + "none" { } + "int" { hsetprop $nodeName oldval -1 } + "float" { hsetprop $nodeName oldval -1.0 } + default { hsetprop $nodeName oldval UNKNOWN } + } + if {1 < [string length $allowedValues]} { + hsetprop $nodeName values $allowedValues + } + # Drive adapter interface + 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 + } + } message ] + if {$catch_status != 0} { + return -code error "in createNode $message" + } + return OK +} + + proc mk_sct_oxford_ips120 {sct_controller klass tempobj tol} { + set catch_status [ catch { +# set ns ::scobj::ips120 + set ns "[namespace current]" + + MakeSICSObj $tempobj SCT_OBJECT + sicslist setatt $tempobj klass $klass + sicslist setatt $tempobj long_name $tempobj + + set scobj_hpath /sics/$tempobj + + set deviceCommand {\ + {} setpoint 0 1 1 float user {} {rdValue} {J} {setPoint} {}\ + sensor value 0 0 0 float internal {} {rdValue} {} {} {}\ + Display OutputCurrent 1 0 0 float internal {R0} {rdValue} {} {} {}\ + Display TargetCurrent 1 0 0 float internal {R5} {rdValue} {} {} {}\ + Display SweepCurrent 5 0 0 float internal {R6} {rdValue} {} {} {}\ + Display OutputField 1 0 0 float internal {R7} {rdValue} {} {} {}\ + Display TargetField 1 0 0 float internal {R8} {rdValue} {} {} {}\ + Display SweepField 5 0 0 float internal {R9} {rdValue} {} {} {}\ + Display LimitVolts 5 0 0 float internal {R15} {rdValue} {} {} {}\ + Display PstntCurrent 1 0 0 float internal {R16} {rdValue} {} {} {}\ + Display TripCurrent 3 0 0 float internal {R17} {rdValue} {} {} {}\ + Display PstntField 1 0 0 float internal {R18} {rdValue} {} {} {}\ + Display TripField 3 0 0 float internal {R19} {rdValue} {} {} {}\ + Display HeaterCurrent 2 0 0 float internal {R20} {rdValue} {} {} {}\ + Display SafeCurrentNeg 5 0 0 float internal {R21} {rdValue} {} {} {}\ + Display SafeCurrentPos 5 0 0 float internal {R22} {rdValue} {} {} {}\ + Display LeadResistance 5 0 0 float internal {R23} {rdValue} {} {} {}\ + Display CoilInductance 5 0 0 float internal {R24} {rdValue} {} {} {}\ + Display Persistent 0 0 0 int internal {} {} {} {} {}\ + Display A 0 0 0 text internal {} {} {} {} {}\ + Display C 0 0 0 text internal {} {} {} {} {}\ + Display H 0 0 0 text internal {} {} {} {} {}\ + Display M 0 0 0 text internal {} {} {} {} {}\ + Display P 0 0 0 text internal {} {} {} {} {}\ + Display X 0 0 0 text internal {} {} {} {} {}\ + Control A 0 1 0 int user {} {} {A} {setValue.chkWrite} {0,1,2,4}\ + Control C 0 1 0 int user {} {} {C} {setValue.chkWrite} {0,1,2,3}\ + Control H 0 1 0 int user {} {} {H} {setValue.chkWrite} {0,1}\ + Control I 0 1 0 float user {} {} {I} {setValue.chkWrite} {}\ + Control J 0 1 0 float user {} {} {J} {setValue.chkWrite} {}\ + Control M 0 1 0 int user {} {} {M} {setValue.chkWrite} {0,1,4,5,8,9}\ + Control P 0 1 0 int user {} {} {P} {setValue.chkWrite} {0,1,2,4}\ + Control Q 0 1 0 int user {} {} {Q} {setValue} {0,2,4,6}\ + Control S 0 1 0 float user {} {} {S} {setValue.chkWrite} {}\ + Control T 0 1 0 float user {} {} {T} {setValue.chkWrite} {}\ + } + + hfactory $scobj_hpath/sensor plain spy none + hfactory $scobj_hpath/Display plain spy none + hfactory $scobj_hpath/Control plain spy none + + foreach {cmdGroup varName readable writable drivable dataType permission rdCmd rdFunc wrCmd wrFunc allowedValues} $deviceCommand { + createNode $scobj_hpath $sct_controller $cmdGroup $varName $readable $writable $drivable $dataType $permission $rdCmd $rdFunc $wrCmd $wrFunc $allowedValues $klass + } + + hsetprop $scobj_hpath/sensor/value lowerlimit -12 + hsetprop $scobj_hpath/sensor/value upperlimit 12 + hsetprop $scobj_hpath/sensor/value units "T" + + hfactory $scobj_hpath/apply_tolerance plain user int + hsetprop $scobj_hpath/apply_tolerance values 0,1 + hset $scobj_hpath/apply_tolerance 1 + + hfactory $scobj_hpath/tolerance plain user float + hsetprop $scobj_hpath/tolerance units "T" + hfactory $scobj_hpath/tolerance/settletime plain user float + hset $scobj_hpath/tolerance/settletime 5.0 + hsetprop $scobj_hpath/tolerance/settletime units "s" + hset $scobj_hpath/tolerance $tol + + hfactory $scobj_hpath/status plain spy text + hset $scobj_hpath/status "idle" + hsetprop $scobj_hpath/status values busy,idle + + hfactory $scobj_hpath/ips120_state plain spy text + hsetprop $scobj_hpath/ips120_state read ${ns}::getState $scobj_hpath rdState "X" + hsetprop $scobj_hpath/ips120_state rdState ${ns}::rdState $scobj_hpath + hsetprop $scobj_hpath/ips120_state oldval "UNKNOWN" + hsetprop $scobj_hpath/ips120_state my_state "STATE_V" + hsetprop $scobj_hpath/ips120_state my_status "UNKNOWN" + hsetprop $scobj_hpath/ips120_state my_version "UNKNOWN" + + hfactory $scobj_hpath/drive_state plain mugger text + hset $scobj_hpath/drive_state "UNKNOWN" + + hfactory $scobj_hpath/remote_ctrl plain spy text + hset $scobj_hpath/remote_ctrl "UNKNOWN" + + hfactory $scobj_hpath/ips120_lasterror plain user text + hset $scobj_hpath/ips120_lasterror "" + + hfactory $scobj_hpath/lowerlimit plain mugger float + hsetprop $scobj_hpath/lowerlimit units "T" + hset $scobj_hpath/lowerlimit -11 + + hfactory $scobj_hpath/upperlimit plain mugger float + hsetprop $scobj_hpath/upperlimit units "T" + hset $scobj_hpath/upperlimit 11 + + hfactory $scobj_hpath/emon plain spy none + hfactory $scobj_hpath/emon/monmode plain user text + hsetprop $scobj_hpath/emon/monmode values idle,drive,monitor,error + hset $scobj_hpath/emon/monmode "idle" + hfactory $scobj_hpath/emon/isintol plain user int + hset $scobj_hpath/emon/isintol 1 + hfactory $scobj_hpath/emon/errhandler plain user text + hset $scobj_hpath/emon/errhandler "pause" + + if {[SplitReply [environment_simulation]]=="false"} { +# $sct_controller poll $scobj_hpath/setpoint +# $sct_controller write $scobj_hpath/setpoint +# $sct_controller poll $scobj_hpath/sensor/value + $sct_controller poll $scobj_hpath/ips120_state 1 halt read + } + + ::scobj::hinitprops $tempobj + hsetprop $scobj_hpath klass NXenvironment +# ::scobj::set_required_props $scobj_hpath + hsetprop $scobj_hpath type part + foreach snsr {sensor} { + foreach {rootpath hpath klass priv} "\ + $scobj_hpath $snsr NXsensor spy\ + $scobj_hpath $snsr/value sensor user\ + " { + hsetprop $rootpath/$hpath klass $klass + hsetprop $rootpath/$hpath privilege $priv + hsetprop $rootpath/$hpath control true + hsetprop $rootpath/$hpath data true + hsetprop $rootpath/$hpath nxsave true + } + hsetprop $scobj_hpath/$snsr type part + hsetprop $scobj_hpath/$snsr/value nxalias tc1_${snsr}_value + hsetprop $scobj_hpath/$snsr/value mutable true + hsetprop $scobj_hpath/$snsr/value sdsinfo ::nexus::scobj::sdsinfo + } + hsetprop $scobj_hpath privilege spy + ::scobj::hinitprops $tempobj setpoint + if {[SplitReply [environment_simulation]]=="false"} { + ansto_makesctdrive ${tempobj}_driveable $scobj_hpath/setpoint $scobj_hpath/sensor/value $sct_controller + } + } catch_message ] + if {$catch_status != 0} { + return -code error $catch_message + } + } + namespace export mk_sct_oxford_ips120 +} + +## +# @brief Create a Oxford ips120 power supply controller +# +# @param name, the name of the power supply controller (eg tc1) +# @param IP, the IP address of the device, this can be a hostname, (eg ca1-kowari) +# @param port, the IP protocol port number of the device +# @param _tol (optional), this is the initial tolerance setting +proc add_ips120 {name IP port {_tol 5.0}} { + set fd [open "/tmp/ips120.log" a] + if {[SplitReply [environment_simulation]]=="false"} { + puts $fd "makesctcontroller sct_ips120 oxford ${IP}:$port" + makesctcontroller sct_ips120 oxford ${IP}:$port + } + puts $fd "mk_sct_oxford_ips120 sct_ips120 environment $name $_tol" + mk_sct_oxford_ips120 sct_ips120 environment $name $_tol + puts $fd "makesctemon $name /sics/$name/emon/monmode /sics/$name/emon/isintol /sics/$name/emon/errhandler" + makesctemon $name /sics/$name/emon/monmode /sics/$name/emon/isintol /sics/$name/emon/errhandler + close $fd +} + +puts stdout "file evaluation of sct_oxford_ips.tcl" +set fd [open "/tmp/ips120.log" w] +puts $fd "file evaluation of sct_oxford_ips.tcl" +close $fd + +namespace import ::scobj::ips120::* + +#add_ips120 ips120 137.157.201.213 502 5 +add_ips120 ips120 localhost 30509 0.001