linse/sics
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'RELEASE-3_1' into RELEASE-3_2

Browse Source 
Conflicts:
	sics/site_ansto/instrument/hipd/wombat_configuration.tcl
	sics/site_ansto/instrument/hrpd/echidna_configuration.tcl
	sics/site_ansto/instrument/kookaburra/kookaburra_configuration.tcl
	sics/site_ansto/instrument/reflectometer/platypus_configuration.tcl
	sics/site_ansto/instrument/sans/config/environment/sct_antonparr_MCR500.tcl
	sics/site_ansto/instrument/tas/taipan_configuration.tcl
This commit is contained in:
Douglas Clowes
2015-03-05 13:53:47 +11:00
parent b75e0b5efb 06c51416dd
commit f269a17ef3
41 changed files with 1967 additions and 310 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
site_ansto/hardsup/sct_asyncqueue.c
View File

@ -324,7 +324,7 @@ static int scaqaAsconInit(Ascon *a, SConnection *pCon, int argc, char *argv[])
for (i = 0; i < argc; ++i) {
SCPrintf(pCon, eStatus, "scaqaAsconInit: arg[%d] = %s\n", i, argv[i]);
}
if (argc < 1) {
if (argc < 2) {
SCPrintf(pCon, eError, "Insufficient arguments to scaqaAsconInit: %d\n", argc);
return 0;
}

124
site_ansto/instrument/TEST_SICS/fakeOLV/FakeOLV.py Executable file
View File

@ -0,0 +1,124 @@
#!/usr/bin/python
# vim: ft=python ts=8 sts=4 sw=4 et autoindent smartindent nocindent
# author: Douglas Clowes (douglas.clowes@ansto.gov.au) 2015
'''
Fake Oxford LabView program for the 10/12 Tesla magnet driver
'''
from twisted.internet import reactor, protocol
from twisted.internet.task import LoopingCall
devices = []
class FakeOLV(protocol.Protocol):
'''Fake Oxford Labview Protocol Object'''
def __init__(self):
self.setpoint = 0.0
self.field = 0.0
self.rate = 0.0
self.hsw = 0
self.t_1 = 120.0
self.t_2 = 120.0
self.t_3 = 120.0
self.dsp = 0.0
self.dpv = 0.0
self.hsp = 0.0
self.hpv = 0.0
def dataReceived(self, data):
print "RECEIVED ", data
reply = ""
cmd_pars = data.split()
if len(cmd_pars) < 1:
return
cmd = cmd_pars[0].lower()
if cmd.startswith("set"):
reply = self.set_command(cmd, cmd_pars)
elif cmd.startswith("get"):
reply = self.get_command(cmd)
else:
reply = "Error Command!"
print "REPLY ", reply
self.transport.write(reply + "\r\n")
def set_command(self, cmd, cmd_pars):
'''Execute a setXX command'''
reply = ""
if len(cmd_pars) < 2:
reply = "Error Command!"
elif cmd == "setr":
self.rate = float(cmd_pars[1])
elif cmd == "seths":
if cmd_pars[1].lower() == "on":
self.hsw = 1
if cmd_pars[1].lower() == "off":
self.hsw = 0
elif cmd == "sethelioxtemp":
self.hsp = float(cmd_pars[1])
elif cmd == "setdiluttemp":
self.dsp = float(cmd_pars[1])
elif cmd == "setf":
self.setpoint = float(cmd_pars[1])
else:
reply = "Error Command!"
return reply
def get_command(self, cmd):
'''Execute a getXX command'''
reply = ""
if cmd == "getf":
current = self.field * 10.0
reply = "Field_Current=%.6f;" % current
reply += "Field_Tesla=%.6f" % self.field
elif cmd == "gett":
reply = "T1=120.000000;T2=120.000000;T3=120.000000"
elif cmd == "gethelioxtemp":
reply = "Temp=0.000000;SetPoint=0.000000 Cdeg"
elif cmd == "getdilutiontemp":
reply = "Temp=0.000000;SetPoint=0.000000"
else:
reply = "Error Command!"
return reply
def iterate(self):
'''Iterate the setpoints'''
if abs(self.field - self.setpoint) > 0.01:
self.field += 0.1 * (self.setpoint - self.field)
else:
self.field = self.setpoint
if abs(self.dsp - self.dpv) > 0.01:
self.dpv += 0.1 * (self.dsp - self.dpv)
else:
self.dpv = self.dsp
if abs(self.hsp - self.hpv) > 0.01:
self.hpv += 0.1 * (self.hsp - self.hpv)
else:
self.hpv = self.hsp
def connectionMade(self):
'''Add this new connection to the list of devices'''
print "connectionMade"
devices.append(self)
def connectionLost(self, reason):
'''Drop this old connection from the list of devices'''
print "connectionLost"
devices.remove(self)
def device_iterator():
'''Iterate over all connected devices and do them'''
#print "device_iterator"
for dev in devices:
dev.iterate()
def main():
'''Main program'''
dev_iter = LoopingCall(device_iterator)
dev_iter.start(1.0)
factory = protocol.ServerFactory()
factory.protocol = FakeOLV
reactor.listenTCP(55001, factory)
reactor.run()
if __name__ == "__main__":
main()

80
site_ansto/instrument/config/beamline/he3_polanal.sct
View File

@ -3,7 +3,7 @@ driver he3_polanal = {
protocol = std;
class = instrument;
simulation_group = rfgen_simulation;
make_args = '{has_pol true} {has_anal true}';
make_args = '{has_pol true} {has_anal true} {has_coil false}';
group polariser = {
conditional = '[string equal -nocase ${has_pol} "true"]';
@ -11,7 +11,7 @@ driver he3_polanal = {
var spin = {
readable = 900;
read_command = 'polariser';
read_function = rdValue;
read_function = read_spin;
writeable = 1;
write_command = 'polariser';
check_function = chkWrite;
@ -42,7 +42,7 @@ driver he3_polanal = {
var spin = {
readable = 900;
read_command = 'analyser';
read_function = rdValue;
read_function = read_spin;
writeable = 1;
write_command = 'analyser';
check_function = chkWrite;
@ -67,12 +67,82 @@ driver he3_polanal = {
var timestamp = { type = int; }
}
group magnet = {
conditional = '[string equal -nocase ${has_coil} "true"]';
type = float;
group sense = {
var x_voltage = {}
var x_current = {}
var y_voltage = {}
var y_current = {}
var z_voltage = {}
var z_current = {}
var sense = {
type = int; data = false; mutable = false; nxsave = false;
readable = 30;
read_command = 'magnet_xyz';
read_function = read_magnet;
writeable = 1;
write_function = fetch_magnet;
write_command = 'magnet_xyz';
}
}
group setpoint = {
var x_current_sp = {}
var y_current_sp = {}
var z_current_sp = {}
var store = {
type = int; data = false; mutable = false; nxsave = false;
writeable = 1;
write_function = write_magnet;
write_command = 'magnet_xyz';
}
}
}
code read_magnet = {
@TCL
set dlist [split [string trim ${data}]]
if {[llength $dlist] != 7} {
error "Syntax error: '${data}'"
}
set index 1
set path [pathname [sct]]
set ns [namespace current]
foreach node {x_voltage x_current y_voltage y_current z_voltage z_current} {
hsetprop ${path}/${node} result [lindex $dlist ${index}]
sct with ${path}/${node} "${ns}::rdValue ${tc_root}"
incr index
}
set data 0
@END
}
code fetch_magnet = {
@TCL
# Just do a fetch and go on to the read state
set cmd "${cmd_str}"
set nextState "read_magnet"
@END
}
code write_magnet = {
@TCL
# Just do a fetch and go on to the read state
set path [pathname [sct]]
set cmd "${cmd_str}"
set cmd "${cmd} [hval ${path}/x_current_sp]"
set cmd "${cmd} [hval ${path}/y_current_sp]"
set cmd "${cmd} [hval ${path}/z_current_sp]"
@END
}
code chkWrite = {%%
[namespace current]::rdValue ${tc_root}
[namespace current]::read_spin ${tc_root}
clientput [sct result]
%%}
code rdValue = {%%
code read_spin = {%%
set dlist [split [string trim ${data}]]
if {[llength ${dlist}] < 2} {
sct geterror "Syntax Error: '${data}'"

326
site_ansto/instrument/config/beamline/he3_polanal_sct.tcl
View File

@ -72,7 +72,7 @@ proc ::scobj::he3_polanal::chkWrite {tc_root} {
set catch_status [ catch {
debug_log ${tc_root} 1 "chkWrite tc_root=${tc_root} sct=[sct] resp=[sct result]"
# chkWrite hook code starts
[namespace current]::rdValue ${tc_root}
[namespace current]::read_spin ${tc_root}
clientput [sct result]
# chkWrite hook code ends
return "idle"
@ -80,6 +80,38 @@ proc ::scobj::he3_polanal::chkWrite {tc_root} {
handle_exception ${catch_status} ${catch_message}
}
# function to write a parameter value on a device
proc ::scobj::he3_polanal::fetch_magnet {tc_root nextState cmd_str} {
set catch_status [ catch {
debug_log ${tc_root} 1 "fetch_magnet 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}"
# fetch_magnet hook code starts
# Just do a fetch and go on to the read state
set cmd "${cmd_str}"
set nextState "read_magnet"
# fetch_magnet hook code ends
if { [hpropexists [sct] geterror] } {
debug_log ${tc_root} 9 "[sct] error: [sct geterror]"
error "[sct geterror]"
}
if { [hpropexists [sct] driving] } {
if { [hpropexists [sct] writestatus] && [sct writestatus] == "start" } {
sct driving 1
}
}
debug_log ${tc_root} 1 "fetch_magnet 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 request the read of a parameter on a device
proc ::scobj::he3_polanal::getValue {tc_root nextState cmd_str} {
set catch_status [ catch {
@ -122,7 +154,77 @@ proc ::scobj::he3_polanal::rdValue {tc_root} {
sct geterror "${data}"
error "[sct geterror]"
}
# rdValue hook code starts
# rdValue hook code goes here
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::he3_polanal::read_magnet {tc_root} {
set catch_status [ catch {
debug_log ${tc_root} 1 "read_magnet 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]"
}
# read_magnet hook code starts
set dlist [split [string trim ${data}]]
if {[llength $dlist] != 7} {
error "Syntax error: '${data}'"
}
set index 1
set path [pathname [sct]]
set ns [namespace current]
foreach node {x_voltage x_current y_voltage y_current z_voltage z_current} {
hsetprop ${path}/${node} result [lindex $dlist ${index}]
sct with ${path}/${node} "${ns}::rdValue ${tc_root}"
incr index
}
set data 0
# read_magnet 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::he3_polanal::read_spin {tc_root} {
set catch_status [ catch {
debug_log ${tc_root} 1 "read_spin 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]"
}
# read_spin hook code starts
set dlist [split [string trim ${data}]]
if {[llength ${dlist}] < 2} {
sct geterror "Syntax Error: '${data}'"
@ -148,7 +250,7 @@ proc ::scobj::he3_polanal::rdValue {tc_root} {
[namespace current]::do_update ${path}/time2 ${dlist} 5
[namespace current]::do_update ${path}/field ${dlist} 6
hupdateif ${path}/timestamp ${timestamp}
# rdValue hook code ends
# read_spin hook code ends
if { [hpropexists [sct] geterror] } {
debug_log ${tc_root} 9 "[sct] error: [sct geterror]"
error "[sct geterror]"
@ -200,8 +302,43 @@ proc ::scobj::he3_polanal::setValue {tc_root nextState cmd_str} {
handle_exception ${catch_status} ${catch_message}
}
proc ::scobj::he3_polanal::mkDriver { sct_controller name device_class simulation_flag ip_address tcp_port {has_pol true} {has_anal true} } {
::scobj::he3_polanal::sics_log 9 "::scobj::he3_polanal::mkDriver ${sct_controller} ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${has_pol} ${has_anal}"
# function to write a parameter value on a device
proc ::scobj::he3_polanal::write_magnet {tc_root nextState cmd_str} {
set catch_status [ catch {
debug_log ${tc_root} 1 "write_magnet 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}"
# write_magnet hook code starts
# Just do a fetch and go on to the read state
set path [pathname [sct]]
set cmd "${cmd_str}"
set cmd "${cmd} [hval ${path}/x_current_sp]"
set cmd "${cmd} [hval ${path}/y_current_sp]"
set cmd "${cmd} [hval ${path}/z_current_sp]"
# write_magnet hook code ends
if { [hpropexists [sct] geterror] } {
debug_log ${tc_root} 9 "[sct] error: [sct geterror]"
error "[sct geterror]"
}
if { [hpropexists [sct] driving] } {
if { [hpropexists [sct] writestatus] && [sct writestatus] == "start" } {
sct driving 1
}
}
debug_log ${tc_root} 1 "write_magnet 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::he3_polanal::mkDriver { sct_controller name device_class simulation_flag ip_address tcp_port {has_pol true} {has_anal true} {has_coil false} } {
::scobj::he3_polanal::sics_log 9 "::scobj::he3_polanal::mkDriver ${sct_controller} ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${has_pol} ${has_anal} ${has_coil}"
set ns "[namespace current]"
set catch_status [ catch {
@ -264,8 +401,8 @@ proc ::scobj::he3_polanal::mkDriver { sct_controller name device_class simulatio
hsetprop ${scobj_hpath}/analyser/phase nxalias "${name}_analyser_phase"
hfactory ${scobj_hpath}/analyser/spin plain user float
hsetprop ${scobj_hpath}/analyser/spin read ${ns}::getValue ${scobj_hpath} rdValue {analyser}
hsetprop ${scobj_hpath}/analyser/spin rdValue ${ns}::rdValue ${scobj_hpath}
hsetprop ${scobj_hpath}/analyser/spin read ${ns}::getValue ${scobj_hpath} read_spin {analyser}
hsetprop ${scobj_hpath}/analyser/spin read_spin ${ns}::read_spin ${scobj_hpath}
hsetprop ${scobj_hpath}/analyser/spin write ${ns}::setValue ${scobj_hpath} chkWrite {analyser}
hsetprop ${scobj_hpath}/analyser/spin chkWrite ${ns}::chkWrite ${scobj_hpath}
hsetprop ${scobj_hpath}/analyser/spin check ${ns}::checkrange ${scobj_hpath}
@ -404,6 +541,167 @@ proc ::scobj::he3_polanal::mkDriver { sct_controller name device_class simulatio
hsetprop ${scobj_hpath}/analyser_start type "part"
}
if {[string equal -nocase ${has_coil} "true"]} {
hfactory ${scobj_hpath}/magnet plain spy none
hsetprop ${scobj_hpath}/magnet data "true"
hsetprop ${scobj_hpath}/magnet klass "@none"
hsetprop ${scobj_hpath}/magnet type "part"
hfactory ${scobj_hpath}/magnet/sense plain spy none
hfactory ${scobj_hpath}/magnet/sense/sense plain user int
hsetprop ${scobj_hpath}/magnet/sense/sense read ${ns}::getValue ${scobj_hpath} read_magnet {magnet_xyz}
hsetprop ${scobj_hpath}/magnet/sense/sense read_magnet ${ns}::read_magnet ${scobj_hpath}
hsetprop ${scobj_hpath}/magnet/sense/sense write ${ns}::fetch_magnet ${scobj_hpath} noResponse {magnet_xyz}
hsetprop ${scobj_hpath}/magnet/sense/sense noResponse ${ns}::noResponse ${scobj_hpath}
hsetprop ${scobj_hpath}/magnet/sense/sense check ${ns}::checkrange ${scobj_hpath}
hsetprop ${scobj_hpath}/magnet/sense/sense control true
hsetprop ${scobj_hpath}/magnet/sense/sense data false
hsetprop ${scobj_hpath}/magnet/sense/sense mutable false
hsetprop ${scobj_hpath}/magnet/sense/sense nxsave false
hsetprop ${scobj_hpath}/magnet/sense/sense oldval 0
hsetprop ${scobj_hpath}/magnet/sense/sense sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/sense/sense type "part"
hsetprop ${scobj_hpath}/magnet/sense/sense nxalias "${name}_magnet_sense_sense"
if {[string equal -nocase "${simulation_flag}" "false"]} {
${sct_controller} poll ${scobj_hpath}/magnet/sense/sense 30
${sct_controller} write ${scobj_hpath}/magnet/sense/sense
hsetprop ${scobj_hpath}/magnet/sense/sense simulated false
} else {
::scobj::he3_polanal::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for he3_polanal"
hsetprop ${scobj_hpath}/magnet/sense/sense simulated true
}
hfactory ${scobj_hpath}/magnet/sense/x_current plain user float
hsetprop ${scobj_hpath}/magnet/sense/x_current control true
hsetprop ${scobj_hpath}/magnet/sense/x_current data true
hsetprop ${scobj_hpath}/magnet/sense/x_current mutable true
hsetprop ${scobj_hpath}/magnet/sense/x_current nxsave true
hsetprop ${scobj_hpath}/magnet/sense/x_current oldval 0.0
hsetprop ${scobj_hpath}/magnet/sense/x_current klass "parameter"
hsetprop ${scobj_hpath}/magnet/sense/x_current sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/sense/x_current type "part"
hsetprop ${scobj_hpath}/magnet/sense/x_current nxalias "${name}_magnet_sense_x_current"
hfactory ${scobj_hpath}/magnet/sense/x_voltage plain user float
hsetprop ${scobj_hpath}/magnet/sense/x_voltage control true
hsetprop ${scobj_hpath}/magnet/sense/x_voltage data true
hsetprop ${scobj_hpath}/magnet/sense/x_voltage mutable true
hsetprop ${scobj_hpath}/magnet/sense/x_voltage nxsave true
hsetprop ${scobj_hpath}/magnet/sense/x_voltage oldval 0.0
hsetprop ${scobj_hpath}/magnet/sense/x_voltage klass "parameter"
hsetprop ${scobj_hpath}/magnet/sense/x_voltage sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/sense/x_voltage type "part"
hsetprop ${scobj_hpath}/magnet/sense/x_voltage nxalias "${name}_magnet_sense_x_voltage"
hfactory ${scobj_hpath}/magnet/sense/y_current plain user float
hsetprop ${scobj_hpath}/magnet/sense/y_current control true
hsetprop ${scobj_hpath}/magnet/sense/y_current data true
hsetprop ${scobj_hpath}/magnet/sense/y_current mutable true
hsetprop ${scobj_hpath}/magnet/sense/y_current nxsave true
hsetprop ${scobj_hpath}/magnet/sense/y_current oldval 0.0
hsetprop ${scobj_hpath}/magnet/sense/y_current klass "parameter"
hsetprop ${scobj_hpath}/magnet/sense/y_current sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/sense/y_current type "part"
hsetprop ${scobj_hpath}/magnet/sense/y_current nxalias "${name}_magnet_sense_y_current"
hfactory ${scobj_hpath}/magnet/sense/y_voltage plain user float
hsetprop ${scobj_hpath}/magnet/sense/y_voltage control true
hsetprop ${scobj_hpath}/magnet/sense/y_voltage data true
hsetprop ${scobj_hpath}/magnet/sense/y_voltage mutable true
hsetprop ${scobj_hpath}/magnet/sense/y_voltage nxsave true
hsetprop ${scobj_hpath}/magnet/sense/y_voltage oldval 0.0
hsetprop ${scobj_hpath}/magnet/sense/y_voltage klass "parameter"
hsetprop ${scobj_hpath}/magnet/sense/y_voltage sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/sense/y_voltage type "part"
hsetprop ${scobj_hpath}/magnet/sense/y_voltage nxalias "${name}_magnet_sense_y_voltage"
hfactory ${scobj_hpath}/magnet/sense/z_current plain user float
hsetprop ${scobj_hpath}/magnet/sense/z_current control true
hsetprop ${scobj_hpath}/magnet/sense/z_current data true
hsetprop ${scobj_hpath}/magnet/sense/z_current mutable true
hsetprop ${scobj_hpath}/magnet/sense/z_current nxsave true
hsetprop ${scobj_hpath}/magnet/sense/z_current oldval 0.0
hsetprop ${scobj_hpath}/magnet/sense/z_current klass "parameter"
hsetprop ${scobj_hpath}/magnet/sense/z_current sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/sense/z_current type "part"
hsetprop ${scobj_hpath}/magnet/sense/z_current nxalias "${name}_magnet_sense_z_current"
hfactory ${scobj_hpath}/magnet/sense/z_voltage plain user float
hsetprop ${scobj_hpath}/magnet/sense/z_voltage control true
hsetprop ${scobj_hpath}/magnet/sense/z_voltage data true
hsetprop ${scobj_hpath}/magnet/sense/z_voltage mutable true
hsetprop ${scobj_hpath}/magnet/sense/z_voltage nxsave true
hsetprop ${scobj_hpath}/magnet/sense/z_voltage oldval 0.0
hsetprop ${scobj_hpath}/magnet/sense/z_voltage klass "parameter"
hsetprop ${scobj_hpath}/magnet/sense/z_voltage sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/sense/z_voltage type "part"
hsetprop ${scobj_hpath}/magnet/sense/z_voltage nxalias "${name}_magnet_sense_z_voltage"
hsetprop ${scobj_hpath}/magnet/sense data "true"
hsetprop ${scobj_hpath}/magnet/sense klass "@none"
hsetprop ${scobj_hpath}/magnet/sense type "part"
hfactory ${scobj_hpath}/magnet/setpoint plain spy none
hfactory ${scobj_hpath}/magnet/setpoint/store plain user int
hsetprop ${scobj_hpath}/magnet/setpoint/store write ${ns}::write_magnet ${scobj_hpath} noResponse {magnet_xyz}
hsetprop ${scobj_hpath}/magnet/setpoint/store noResponse ${ns}::noResponse ${scobj_hpath}
hsetprop ${scobj_hpath}/magnet/setpoint/store check ${ns}::checkrange ${scobj_hpath}
hsetprop ${scobj_hpath}/magnet/setpoint/store control true
hsetprop ${scobj_hpath}/magnet/setpoint/store data false
hsetprop ${scobj_hpath}/magnet/setpoint/store mutable false
hsetprop ${scobj_hpath}/magnet/setpoint/store nxsave false
hsetprop ${scobj_hpath}/magnet/setpoint/store oldval 0
hsetprop ${scobj_hpath}/magnet/setpoint/store sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/setpoint/store type "part"
hsetprop ${scobj_hpath}/magnet/setpoint/store nxalias "${name}_magnet_setpoint_store"
if {[string equal -nocase "${simulation_flag}" "false"]} {
${sct_controller} write ${scobj_hpath}/magnet/setpoint/store
hsetprop ${scobj_hpath}/magnet/setpoint/store simulated false
} else {
::scobj::he3_polanal::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for he3_polanal"
hsetprop ${scobj_hpath}/magnet/setpoint/store simulated true
}
hfactory ${scobj_hpath}/magnet/setpoint/x_current_sp plain user float
hsetprop ${scobj_hpath}/magnet/setpoint/x_current_sp control true
hsetprop ${scobj_hpath}/magnet/setpoint/x_current_sp data true
hsetprop ${scobj_hpath}/magnet/setpoint/x_current_sp mutable true
hsetprop ${scobj_hpath}/magnet/setpoint/x_current_sp nxsave true
hsetprop ${scobj_hpath}/magnet/setpoint/x_current_sp oldval 0.0
hsetprop ${scobj_hpath}/magnet/setpoint/x_current_sp klass "parameter"
hsetprop ${scobj_hpath}/magnet/setpoint/x_current_sp sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/setpoint/x_current_sp type "part"
hsetprop ${scobj_hpath}/magnet/setpoint/x_current_sp nxalias "${name}_magnet_setpoint_x_current_sp"
hfactory ${scobj_hpath}/magnet/setpoint/y_current_sp plain user float
hsetprop ${scobj_hpath}/magnet/setpoint/y_current_sp control true
hsetprop ${scobj_hpath}/magnet/setpoint/y_current_sp data true
hsetprop ${scobj_hpath}/magnet/setpoint/y_current_sp mutable true
hsetprop ${scobj_hpath}/magnet/setpoint/y_current_sp nxsave true
hsetprop ${scobj_hpath}/magnet/setpoint/y_current_sp oldval 0.0
hsetprop ${scobj_hpath}/magnet/setpoint/y_current_sp klass "parameter"
hsetprop ${scobj_hpath}/magnet/setpoint/y_current_sp sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/setpoint/y_current_sp type "part"
hsetprop ${scobj_hpath}/magnet/setpoint/y_current_sp nxalias "${name}_magnet_setpoint_y_current_sp"
hfactory ${scobj_hpath}/magnet/setpoint/z_current_sp plain user float
hsetprop ${scobj_hpath}/magnet/setpoint/z_current_sp control true
hsetprop ${scobj_hpath}/magnet/setpoint/z_current_sp data true
hsetprop ${scobj_hpath}/magnet/setpoint/z_current_sp mutable true
hsetprop ${scobj_hpath}/magnet/setpoint/z_current_sp nxsave true
hsetprop ${scobj_hpath}/magnet/setpoint/z_current_sp oldval 0.0
hsetprop ${scobj_hpath}/magnet/setpoint/z_current_sp klass "parameter"
hsetprop ${scobj_hpath}/magnet/setpoint/z_current_sp sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/setpoint/z_current_sp type "part"
hsetprop ${scobj_hpath}/magnet/setpoint/z_current_sp nxalias "${name}_magnet_setpoint_z_current_sp"
hsetprop ${scobj_hpath}/magnet/setpoint data "true"
hsetprop ${scobj_hpath}/magnet/setpoint klass "@none"
hsetprop ${scobj_hpath}/magnet/setpoint type "part"
}
if {[string equal -nocase ${has_pol} "true"]} {
hfactory ${scobj_hpath}/polariser plain spy none
@ -455,8 +753,8 @@ proc ::scobj::he3_polanal::mkDriver { sct_controller name device_class simulatio
hsetprop ${scobj_hpath}/polariser/phase nxalias "${name}_polariser_phase"
hfactory ${scobj_hpath}/polariser/spin plain user float
hsetprop ${scobj_hpath}/polariser/spin read ${ns}::getValue ${scobj_hpath} rdValue {polariser}
hsetprop ${scobj_hpath}/polariser/spin rdValue ${ns}::rdValue ${scobj_hpath}
hsetprop ${scobj_hpath}/polariser/spin read ${ns}::getValue ${scobj_hpath} read_spin {polariser}
hsetprop ${scobj_hpath}/polariser/spin read_spin ${ns}::read_spin ${scobj_hpath}
hsetprop ${scobj_hpath}/polariser/spin write ${ns}::setValue ${scobj_hpath} chkWrite {polariser}
hsetprop ${scobj_hpath}/polariser/spin chkWrite ${ns}::chkWrite ${scobj_hpath}
hsetprop ${scobj_hpath}/polariser/spin check ${ns}::checkrange ${scobj_hpath}
@ -605,7 +903,7 @@ proc ::scobj::he3_polanal::mkDriver { sct_controller name device_class simulatio
proc ::scobj::he3_polanal::add_driver {name device_class simulation_flag ip_address tcp_port} {
set catch_status [ catch {
::scobj::he3_polanal::sics_log 9 "::scobj::he3_polanal::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${has_pol} ${has_anal}"
::scobj::he3_polanal::sics_log 9 "::scobj::he3_polanal::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${has_pol} ${has_anal} ${has_coil}"
if {[string equal -nocase "${simulation_flag}" "false"]} {
if {[string equal -nocase "aqadapter" "${ip_address}"]} {
::scobj::he3_polanal::sics_log 9 "makesctcontroller sct_${name} aqadapter ${tcp_port}"
@ -619,8 +917,8 @@ proc ::scobj::he3_polanal::add_driver {name device_class simulation_flag ip_addr
::scobj::he3_polanal::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
makesctcontroller sct_${name} aqadapter NULL
}
::scobj::he3_polanal::sics_log 1 "::scobj::he3_polanal::mkDriver sct_${name} ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${has_pol} ${has_anal}"
::scobj::he3_polanal::mkDriver sct_${name} ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${has_pol} ${has_anal}
::scobj::he3_polanal::sics_log 1 "::scobj::he3_polanal::mkDriver sct_${name} ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${has_pol} ${has_anal} ${has_coil}"
::scobj::he3_polanal::mkDriver sct_${name} ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${has_pol} ${has_anal} ${has_coil}
} catch_message ]
handle_exception ${catch_status} ${catch_message}
}
@ -721,8 +1019,8 @@ proc ::scobj::he3_polanal::read_config {} {
set arg_list [list]
set missing_list [list]
array unset default_map
array set default_map [list has_pol true has_anal true]
foreach arg {has_pol has_anal} {
array set default_map [list has_pol true has_anal true has_coil false]
foreach arg {has_pol has_anal has_coil} {
if {[dict exists $u $arg]} {
lappend arg_list "[dict get $u $arg]"
} elseif {[dict exists $v $arg]} {

194
site_ansto/instrument/config/commands/hvcommands.tcl
View File

@ -1,5 +1,9 @@
set scaleval 1000.0
set scaleval 2000.0
set rampstep 100
set rampdelay 3
set motdir 1
set pulserstate 0
proc SetVoltScale {newscaleval} {
global scaleval
@ -11,17 +15,58 @@ proc VoltScale {involt} {
return [expr {($involt*1.0)/$scaleval}]
}
proc SetRampParms {_rampstep _rampdelay} {
global rampstep rampdelay
set rampstep $_rampstep
set rampdelay $_rampdelay
}
proc SetVolt {volt} {
global pulserstate
if {$volt== 0} {
PulserOff
set pulserstate 0
} else {
set pulservolt [VoltScale $volt]
sct_pulser send "VOLT:OFFS $pulservolt; OFFS?"
# sct_pulser send "VOLT:OFFS $pulservolt; OFFS?"
# PulserDC $pulservolt
if {$pulserstate==0} {
PulserDC $pulservolt
PulserOn
set pulserstate 1
} else {
sct_pulser send "VOLT:OFFS $pulservolt; OFFS?"
PulserOn
}
}
}
proc VoltSetStep {start step fin delay} {
set i [expr {$start*1.0}]
set loopvar 1
SetVolt $i
if {($start == $fin) || ($step == 0)} {break}
while {$loopvar} {
wait $delay
if {($start < $fin)} {
set i [expr {$i + abs($step)}]
if {$i >= $fin} {
set i $fin
set loopvar 0
}
}
if {($start > $fin)} {
set i [expr {$i - abs($step)}]
if {$i <= $fin} {
set i $fin
set loopvar 0
}
}
SetVolt $i
}
}
proc GetVolt {} {
sct_pulser transact VOLT:OFFS?
}
@ -29,25 +74,18 @@ proc GetVolt {} {
proc SingleVolt {volt oscno} {
histmem mode unlimited
newfile HISTOGRAM_XY
if {$volt== 0} {
PulserOff
} else {
set pulservolt [VoltScale $volt]
sct_pulser send "VOLT:OFFS $pulservolt; OFFS?"
pulserDC $pulservolt
PulserOn
}
oscmd start $oscno
hmm countblock
SetVolt $volt
oct oscillate_count $oscno
oct oscillate start
save 0
oscmd stop
}
proc SetDC {} {
pulseroff
#NOTE: Setting FUNC DC generates a remote ctrl error if the
# burst mode happens to be on
set resp [sct_pulser transact "BURS:STAT OFF;:FUNC DC;:VOLT:OFFS 0; OFFS?"]
set resp [sct_pulser send "BURS:STAT OFF;:FUNC DC;:VOLT:OFFS 0; OFFS?"]
pulseron
}
@ -61,54 +99,57 @@ proc VoltRamp {start step fin oscno} {
set j [expr {$i*$step+$start}]
if {$j> $fin && $step > 0} {break}
if {$j< $fin && $step < 0} {break}
if {$j== 0} {
PulserOff
} else {
set pulservolt [VoltScale $j]
pulserDC $pulservolt
PulserOn
}
oscmd start $oscno
hmm countblock
SetVolt $j
oct oscillate_count $oscno
oct oscillate start
save $i
incr i
}
oscmd stop
}
proc VoltTextureRamp {start step fin mot tstart tstep tfin oscno} {
histmem mode unlimited
proc SingleVTexScan {mot tstart tstep tfin oscno} {
global motdir
broadcast in singlevtexscan
set loopvar 1
set i_bool 0
histmem mode unlimited
if {$motdir == 1} {
set currentmot $tstart
set i 0
while {$loopvar} {
set j [expr {$i*$step+$start}]
if {$j> $fin && $step > 0} {break}
if {$j< $fin && $step < 0} {break}
if {$j== 0} {
PulserOff
} else {
set pulservolt [VoltScale $j]
pulserDC $pulservolt
PulserOn
set currentmot $tfin
set i [expr {int(($tfin-$tstart)/$tstep)}]
}
sampledescription voltage $j
broadcast voltage $j
newfile HISTOGRAM_XY
set m 0
while {1} {
set n [expr {$m*$tstep+$tstart}]
if {$n> $tfin && $tstep > 0} {break}
if {$n< $tfin && $tstep < 0} {break}
drive $mot $n
oscmd start $oscno
while {$i_bool==0} {
drive $mot $currentmot
oct oscillate_count $oscno
oct oscillate start
hmm countblock
save $m
incr m
}
oscmd stop
save $i
if {($motdir > 0)} {
set currentmot [expr {$currentmot + $tstep}]
if {$currentmot > $tfin} {set i_bool 1}
incr i
} else {
set currentmot [expr {$currentmot - $tstep}]
if {$currentmot < $tstart} {set i_bool 1}
incr i -1
}
}
set motdir [expr {(-1*$motdir)}]
}
proc VListTexScan {voltlist mot tstart tstep tfin oscno} {
global rampstep rampdelay
set curvolt [lindex $voltlist 0]
broadcast $curvolt
SetVolt $curvolt
foreach volt $voltlist {
broadcast $volt
VoltSetStep $curvolt $rampstep $volt $rampdelay
SingleVTexScan $mot $tstart $tstep $tfin $oscno
}
}
@ -124,12 +165,10 @@ proc SquarePulseTexture {motor start step numsteps volt freq bins oscno} {
for {set i 0} {$i < $numsteps} {incr i} {
drive $motor [expr $i*$step+$start]
oscmd start $oscno
hmm countblock
oct oscillate_count $oscno
oct oscillate start
save $i
}
oscmd stop
}
proc UniPulseTexture {motor start step numsteps volt freq bins oscno} {
@ -144,12 +183,10 @@ proc UniPulseTexture {motor start step numsteps volt freq bins oscno} {
for {set i 0} {$i < $numsteps} {incr i} {
drive $motor [expr $i*$step+$start]
oscmd start $oscno
hmm countblock
oct oscillate_count $oscno
oct oscillate start
save $i
}
oscmd stop
}
@ -162,8 +199,8 @@ proc BehlkePulseTexture {motor start step numsteps freq bins oscno} {
PulserOn
for {set i 0} {$i < $numsteps} {incr i} {
drive $motor [expr $i*$step+$start]
oscmd start $oscno
hmm countblock
oct oscillate_count $oscno
oct oscillate start
save $i
}
}
@ -189,12 +226,11 @@ proc SquarePulseVolt {start step fin freq bins oscno} {
PulserOn
# sct_pulser send "APPL:SQU $freq,$pulservolt,0"
}
oscmd start $oscno
hmm countblock
oct oscillate_count $oscno
oct oscillate start
save $i
incr i
}
oscmd stop
}
proc SquarePulseFreq {volt freqlist bins oscno} {
@ -209,12 +245,11 @@ proc SquarePulseFreq {volt freqlist bins oscno} {
PulserSquare $freq $pulservolt
PulserOn
# sct_pulser send "APPL:SQU $freq,$pulservolt,0"
oscmd start $oscno
hmm countblock
oct oscillate_count $oscno
oct oscillate start
save $i
incr i
}
oscmd stop
}
proc BehlkePulseFreq {freqlist bins oscno} {
@ -227,12 +262,11 @@ proc BehlkePulseFreq {freqlist bins oscno} {
wait 3
PulserSquareOffs $freq 2.5 2.5
PulserOn
oscmd start $oscno
hmm countblock
oct oscillate_count $oscno
oct oscillate start
save $i
incr i
}
oscmd stop
}
proc SinePulseFreq {volt freqlist bins oscno} {
@ -246,12 +280,11 @@ proc SinePulseFreq {volt freqlist bins oscno} {
wait 3
PulserSin $freq $pulservolt
PulserOn
oscmd start $oscno
hmm countblock
oct oscillate_count $oscno
oct oscillate start
save $i
incr i
}
oscmd stop
}
@ -271,12 +304,11 @@ proc UniPulseFreq {volt freqlist bins oscno} {
PulserSquareOffs $freq $pulservolt $pulseroffs
PulserOn
# sct_pulser send "APPL:SQU $freq,$pulservolt,[expr {$pulservolt/2}]"
oscmd start $oscno
hmm countblock
oct oscillate_count $oscno
oct oscillate start
save $i
incr i
}
oscmd stop
}
proc UniPulseFatigue {volt freq bins oscno reps runs} {
@ -290,13 +322,14 @@ proc UniPulseFatigue {volt freq bins oscno reps runs} {
for {set i 0} {$i<$runs} {incr i} {
newfile HISTOGRAM_XYT
for {set j 0} {$j<$reps} {incr j} {
oscmd start $oscno
hmm countblock
oct oscillate_count $oscno
oct oscillate start
save $j
}
oscmd stop
}
PulserOff
set pulserstate 0
Histmem_strobo_off
}
@ -315,6 +348,7 @@ proc PulserBurst {} {
if {[string first 1 $sval] >-1} {break}
}
PulserOff
set pulserstate 0
}
@ -338,6 +372,7 @@ proc VoltPulseRun {vlo vhi freq cycl} {
sct_pulser send "BURS:NCYC $prem; NCYC?"
PulserBurst
PulserOff
set pulserstate 0
sct_pulser send "BURS:STAT OFF; STAT?"
}
@ -376,6 +411,7 @@ proc OneTri {volt period} {
sct_pulser send "BURS:NCYC 1; NCYC?"
PulserBurst
PulserOff
set pulserstat 0
}
@ -384,6 +420,9 @@ publish GetVolt user
publish SetDC user
publish SetVolt user
publish SetVoltScale user
publish SingleVTexScan user
publish VListTexScan user
publish SetRampParms user
publish SingleVolt user
publish VoltRamp user
publish SquarePulseVolt user
@ -399,5 +438,6 @@ publish SquarePulseTexture user
publish BehlkePulseTexture user
publish BehlkePulseFreq user
publish UniPulseTexture user
publish VoltSetStep user

2
site_ansto/instrument/config/commands/pulser.tcl
View File

@ -54,7 +54,7 @@ proc PulserSquareOffs {Freq Volt Offs} {
proc PulserDC {Volt} {
#NOTE: Setting FUNC DC generates a remote ctrl error if the
# burst mode happens to be on
set resp [sct_pulser transact "BURS:STAT OFF;:FUNC DC;:VOLT:OFFS $Volt; OFFS?"]
set resp [sct_pulser send "BURS:STAT OFF;:FUNC DC;:VOLT:OFFS $Volt; OFFS?"]
broadcast $resp
}

4
site_ansto/instrument/config/counter/counter_common_1.tcl
View File

@ -35,8 +35,8 @@ proc ::counter::ic_initialize {args} {
# This must be sourced before the hmm_configuration.tcl until we separate the scan setup from the hmm setup
for {set i 0; set n 1} {$i < $isc_numchannels} {incr i; incr n} {
MakeCounter bm$n anstomonitor [ params host $isc_monitor_address port [lindex $isc_portlist $i] ]
bm$n send scan=1
bm$n send sample=10
bm$n send set scan=1
bm$n send set sample=10
append bm_list "bm$n "
}
}

860
site_ansto/instrument/config/environment/magneticField/sct_oxford10tlv.tcl Normal file
View File

@ -0,0 +1,860 @@
# Generated driver for oxford10tlv
# vim: ft=tcl tabstop=8 softtabstop=2 shiftwidth=2 nocindent smartindent
#
namespace eval ::scobj::oxford10tlv {
set debug_threshold 5
}
proc ::scobj::oxford10tlv::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/oxford10tlv_[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 ::scobj::oxford10tlv::sics_log {debug_level debug_string} {
set catch_status [ catch {
set debug_threshold ${::scobj::oxford10tlv::debug_threshold}
if {${debug_level} >= ${debug_threshold}} {
sicslog "::scobj::oxford10tlv::${debug_string}"
}
} catch_message ]
}
# check function for hset change
proc ::scobj::oxford10tlv::check_error {tc_root} {
set catch_status [ catch {
debug_log ${tc_root} 1 "check_error 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]
}
# check_error hook code starts
if { [hpropexists [sct] driving] } {
if { [hpropexists [sct] writestatus] && [sct writestatus] == "start" } {
set my_state [hval ${tc_root}/magnet/state]
if {${my_state} != "IDLE"} {
error "Cannot run/drive in state '${my_state}', must be 'IDLE'"
}
} else {
error "Use run/drive and not hset"
}
}
# check_error hook code ends
if { ${setpoint} < ${lolimit} || ${setpoint} > ${hilimit} } {
error "setpoint ${setpoint} violates limits (${lolimit}..${hilimit}) on [sct]"
}
return OK
} catch_message ]
handle_exception ${catch_status} ${catch_message}
}
# checklimits function for driveable interface
proc ::scobj::oxford10tlv::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::oxford10tlv::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::oxford10tlv::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]]"
}
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"
}
} catch_message ]
handle_exception ${catch_status} ${catch_message}
}
# function to request the read of a parameter on a device
proc ::scobj::oxford10tlv::fetch_state {tc_root nextState cmd_str} {
set catch_status [ catch {
debug_log ${tc_root} 1 "fetch_state tc_root=${tc_root} sct=[sct] cmd=${cmd_str}"
if { [hpropexists [sct] geterror] } {
hdelprop [sct] geterror
}
set cmd "${cmd_str}"
# fetch_state hook code starts
set my_state [hval [sct]]
set cmd "@@NOSEND@@"
if {${my_state} == "START"} {
set cmd "setHS ON\r\n@@NOREPLY@@"
sct utime start_time
hupdate [sct] "HTRON"
} elseif {${my_state} == "HTRON"} {
if {[hpropexists [sct] htron_delay]} {
set htron_delay [sct htron_delay]
if {$htron_delay < 10} {
set htron_delay 30
} elseif {$htron_delay > 60} {
set htron_delay 30
}
} else {
set htron_delay 30
}
if {[sct utime] - [sct start_time] > $htron_delay} {
set cmd "setF [hval ${tc_root}/magnet/setpoint]\r\n@@NOREPLY@@"
hupdate [sct] "DRIVE"
} else {
set nextState "idle"
}
} elseif {${my_state} == "DRIVE"} {
if {[hgetpropval ${tc_root}/magnet/setpoint driving] == 0} {
set cmd "setHS OFF\r\n@@NOREPLY@@"
sct utime start_time
hupdate [sct] "HTROFF"
} else {
set nextState "idle"
}
} elseif {${my_state} == "HTROFF"} {
if {[hpropexists [sct] htroff_delay]} {
set htroff_delay [sct htroff_delay]
if {$htroff_delay <= 10} {
set htroff_delay 30
} elseif {$htroff_delay >= 60} {
set htroff_delay 30
}
} else {
set htroff_delay 30
}
if {[sct utime] - [sct start_time] > $htroff_delay} {
hupdate [sct] "IDLE"
} else {
set nextState "idle"
}
} elseif {${my_state} == "IDLE"} {
set nextState "idle"
}
# fetch_state hook code ends
if { [hpropexists [sct] geterror] } {
debug_log ${tc_root} 9 "[sct] error: [sct geterror]"
error "[sct geterror]"
}
debug_log ${tc_root} 1 "fetch_state 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 request the read of a parameter on a device
proc ::scobj::oxford10tlv::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::oxford10tlv::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::oxford10tlv::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::oxford10tlv::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 goes here
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::oxford10tlv::read_field {tc_root} {
set catch_status [ catch {
debug_log ${tc_root} 1 "read_field 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]"
}
# read_field hook code starts
set s1 [string trimright [sct result] "\n"]
set s2 [split $s1 ";"]
if {[llength $s2] > 1} {
if {[string equal -nocase -length 14 "Field_Current=" [lindex $s2 0]]} {
#hupdateif ${tc_root}/magnet/current [string range [lindex $s2 0] 14 end]
set current [string range [lindex $s2 0] 14 end]
hsetprop ${tc_root}/magnet/current result ${current}
set ns [namespace current]
sct with ${tc_root}/magnet/current "${ns}::rdValue ${tc_root}"
}
if {[string equal -nocase -length 12 "Field_Tesla=" [lindex $s2 1]]} {
set data [string range [lindex $s2 1] 12 end]
}
}
# read_field 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::oxford10tlv::read_heater {tc_root} {
set catch_status [ catch {
debug_log ${tc_root} 1 "read_heater 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]"
}
# read_heater hook code goes here
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::oxford10tlv::read_rate {tc_root} {
set catch_status [ catch {
debug_log ${tc_root} 1 "read_rate 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]"
}
# read_rate hook code goes here
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::oxford10tlv::read_state {tc_root} {
set catch_status [ catch {
debug_log ${tc_root} 1 "read_state 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]"
}
# read_state hook code starts
return "idle"
# read_state 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::oxford10tlv::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::oxford10tlv::write_heater {tc_root nextState cmd_str} {
set catch_status [ catch {
debug_log ${tc_root} 1 "write_heater 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}"
# write_heater hook code starts
if {${par} == 0} {
set cmd "setHS OFF\r\n@@NOREPLY@@"
} elseif {${par} == 1} {
set cmd "setHS ON\r\n@@NOREPLY@@"
} else {
error "Invalid parameter '${par}' should be 0 or 1"
}
# Invoke the read function to set the value as if read back
sct result $par
read_heater ${tc_root}
# write_heater hook code ends
if { [hpropexists [sct] geterror] } {
debug_log ${tc_root} 9 "[sct] error: [sct geterror]"
error "[sct geterror]"
}
if { [hpropexists [sct] driving] } {
if { [hpropexists [sct] writestatus] && [sct writestatus] == "start" } {
sct driving 1
}
}
debug_log ${tc_root} 1 "write_heater 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::oxford10tlv::write_rate {tc_root nextState cmd_str} {
set catch_status [ catch {
debug_log ${tc_root} 1 "write_rate 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}"
# write_rate hook code starts
if {${par} >= 0 && ${par} <= 10} {
set cmd "setR ${par}\r\n@@NOREPLY@@"
} else {
error "Invalid parameter '${par}' should be 0 to 10"
}
# Invoke the read function to set the value as if read back
sct result $par
read_rate ${tc_root}
# write_rate hook code ends
if { [hpropexists [sct] geterror] } {
debug_log ${tc_root} 9 "[sct] error: [sct geterror]"
error "[sct geterror]"
}
if { [hpropexists [sct] driving] } {
if { [hpropexists [sct] writestatus] && [sct writestatus] == "start" } {
sct driving 1
}
}
debug_log ${tc_root} 1 "write_rate 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::oxford10tlv::write_setpoint {tc_root nextState cmd_str} {
set catch_status [ catch {
debug_log ${tc_root} 1 "write_setpoint 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}"
# write_setpoint hook code starts
hset ${tc_root}/magnet/state "START"
# Force the driving flag for the state check
sct driving 1
# Set the value on the field
hupdateif [sct] $par
# It's all over now
set cmd "@@NOSEND@@"
set nextState "idle"
# write_setpoint hook code ends
if { [hpropexists [sct] geterror] } {
debug_log ${tc_root} 9 "[sct] error: [sct geterror]"
error "[sct geterror]"
}
if { [hpropexists [sct] driving] } {
if { [hpropexists [sct] writestatus] && [sct writestatus] == "start" } {
sct driving 1
}
}
debug_log ${tc_root} 1 "write_setpoint 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::oxford10tlv::mkDriver { sct_controller name device_class simulation_flag ip_address tcp_port id datype interval } {
::scobj::oxford10tlv::sics_log 9 "::scobj::oxford10tlv::mkDriver ${sct_controller} ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${datype} ${interval}"
set ns "[namespace current]"
set catch_status [ catch {
MakeSICSObj ${name} SCT_OBJECT
sicslist setatt ${name} driver oxford10tlv
sicslist setatt ${name} klass ${device_class}
sicslist setatt ${name} long_name ${name}
set scobj_hpath /sics/${name}
hfactory ${scobj_hpath}/magnet plain spy none
hfactory ${scobj_hpath}/magnet/current plain user float
hsetprop ${scobj_hpath}/magnet/current control true
hsetprop ${scobj_hpath}/magnet/current data true
hsetprop ${scobj_hpath}/magnet/current mutable true
hsetprop ${scobj_hpath}/magnet/current nxsave true
hsetprop ${scobj_hpath}/magnet/current oldval 0.0
hsetprop ${scobj_hpath}/magnet/current klass "parameter"
hsetprop ${scobj_hpath}/magnet/current sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/current type "part"
hsetprop ${scobj_hpath}/magnet/current nxalias "${name}_magnet_current"
hfactory ${scobj_hpath}/magnet/field plain user float
hsetprop ${scobj_hpath}/magnet/field read ${ns}::getValue ${scobj_hpath} read_field {getF}
hsetprop ${scobj_hpath}/magnet/field read_field ${ns}::read_field ${scobj_hpath}
hsetprop ${scobj_hpath}/magnet/field control true
hsetprop ${scobj_hpath}/magnet/field data true
hsetprop ${scobj_hpath}/magnet/field mutable true
hsetprop ${scobj_hpath}/magnet/field nxsave true
hsetprop ${scobj_hpath}/magnet/field oldval 0.0
hsetprop ${scobj_hpath}/magnet/field klass "parameter"
hsetprop ${scobj_hpath}/magnet/field sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/field type "part"
hsetprop ${scobj_hpath}/magnet/field nxalias "${name}_magnet_field"
if {[string equal -nocase "${simulation_flag}" "false"]} {
${sct_controller} poll ${scobj_hpath}/magnet/field 5
hsetprop ${scobj_hpath}/magnet/field simulated false
} else {
::scobj::oxford10tlv::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford10tlv"
hsetprop ${scobj_hpath}/magnet/field simulated true
}
hfactory ${scobj_hpath}/magnet/htr_sw plain user int
hsetprop ${scobj_hpath}/magnet/htr_sw write ${ns}::write_heater ${scobj_hpath} noResponse {}
hsetprop ${scobj_hpath}/magnet/htr_sw noResponse ${ns}::noResponse ${scobj_hpath}
hsetprop ${scobj_hpath}/magnet/htr_sw check ${ns}::checkrange ${scobj_hpath}
hsetprop ${scobj_hpath}/magnet/htr_sw control true
hsetprop ${scobj_hpath}/magnet/htr_sw data true
hsetprop ${scobj_hpath}/magnet/htr_sw mutable true
hsetprop ${scobj_hpath}/magnet/htr_sw nxsave true
hsetprop ${scobj_hpath}/magnet/htr_sw values 0,1
hsetprop ${scobj_hpath}/magnet/htr_sw oldval 0
hsetprop ${scobj_hpath}/magnet/htr_sw klass "parameter"
hsetprop ${scobj_hpath}/magnet/htr_sw sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/htr_sw type "part"
hsetprop ${scobj_hpath}/magnet/htr_sw nxalias "${name}_magnet_htr_sw"
if {[string equal -nocase "${simulation_flag}" "false"]} {
${sct_controller} write ${scobj_hpath}/magnet/htr_sw
hsetprop ${scobj_hpath}/magnet/htr_sw simulated false
} else {
::scobj::oxford10tlv::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford10tlv"
hsetprop ${scobj_hpath}/magnet/htr_sw simulated true
}
hfactory ${scobj_hpath}/magnet/rate plain user float
hsetprop ${scobj_hpath}/magnet/rate write ${ns}::write_rate ${scobj_hpath} noResponse {}
hsetprop ${scobj_hpath}/magnet/rate noResponse ${ns}::noResponse ${scobj_hpath}
hsetprop ${scobj_hpath}/magnet/rate check ${ns}::checkrange ${scobj_hpath}
hsetprop ${scobj_hpath}/magnet/rate control true
hsetprop ${scobj_hpath}/magnet/rate data true
hsetprop ${scobj_hpath}/magnet/rate mutable true
hsetprop ${scobj_hpath}/magnet/rate nxsave true
hsetprop ${scobj_hpath}/magnet/rate oldval 0.0
hsetprop ${scobj_hpath}/magnet/rate klass "parameter"
hsetprop ${scobj_hpath}/magnet/rate sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/rate type "part"
hsetprop ${scobj_hpath}/magnet/rate nxalias "${name}_magnet_rate"
if {[string equal -nocase "${simulation_flag}" "false"]} {
${sct_controller} write ${scobj_hpath}/magnet/rate
hsetprop ${scobj_hpath}/magnet/rate simulated false
} else {
::scobj::oxford10tlv::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford10tlv"
hsetprop ${scobj_hpath}/magnet/rate simulated true
}
hfactory ${scobj_hpath}/magnet/setpoint plain user float
hsetprop ${scobj_hpath}/magnet/setpoint write ${ns}::write_setpoint ${scobj_hpath} noResponse {}
hsetprop ${scobj_hpath}/magnet/setpoint noResponse ${ns}::noResponse ${scobj_hpath}
hsetprop ${scobj_hpath}/magnet/setpoint check ${ns}::check_error ${scobj_hpath}
hsetprop ${scobj_hpath}/magnet/setpoint driving 0
hsetprop ${scobj_hpath}/magnet/setpoint checklimits ${ns}::checklimits ${scobj_hpath}
hsetprop ${scobj_hpath}/magnet/setpoint checkstatus ${ns}::checkstatus ${scobj_hpath}
hsetprop ${scobj_hpath}/magnet/setpoint halt ${ns}::halt ${scobj_hpath}
hsetprop ${scobj_hpath}/magnet/setpoint driveable magnet/field
hsetprop ${scobj_hpath}/magnet/setpoint control true
hsetprop ${scobj_hpath}/magnet/setpoint data true
hsetprop ${scobj_hpath}/magnet/setpoint mutable true
hsetprop ${scobj_hpath}/magnet/setpoint nxsave true
hsetprop ${scobj_hpath}/magnet/setpoint lowerlimit -10
hsetprop ${scobj_hpath}/magnet/setpoint upperlimit 10
hsetprop ${scobj_hpath}/magnet/setpoint tolerance 0.01
hsetprop ${scobj_hpath}/magnet/setpoint oldval 0.0
hsetprop ${scobj_hpath}/magnet/setpoint klass "parameter"
hsetprop ${scobj_hpath}/magnet/setpoint sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/setpoint settle_time "30"
hsetprop ${scobj_hpath}/magnet/setpoint type "drivable"
hsetprop ${scobj_hpath}/magnet/setpoint nxalias "${name}_magnet_setpoint"
if {[string equal -nocase "${simulation_flag}" "false"]} {
${sct_controller} write ${scobj_hpath}/magnet/setpoint
hsetprop ${scobj_hpath}/magnet/setpoint simulated false
} else {
::scobj::oxford10tlv::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford10tlv"
hsetprop ${scobj_hpath}/magnet/setpoint simulated true
}
hfactory ${scobj_hpath}/magnet/state plain user text
hsetprop ${scobj_hpath}/magnet/state read ${ns}::fetch_state ${scobj_hpath} read_state {}
hsetprop ${scobj_hpath}/magnet/state read_state ${ns}::read_state ${scobj_hpath}
hsetprop ${scobj_hpath}/magnet/state control true
hsetprop ${scobj_hpath}/magnet/state data false
hsetprop ${scobj_hpath}/magnet/state mutable false
hsetprop ${scobj_hpath}/magnet/state nxsave false
hsetprop ${scobj_hpath}/magnet/state oldval IDLE
hset ${scobj_hpath}/magnet/state IDLE
hsetprop ${scobj_hpath}/magnet/state htroff_delay "10"
hsetprop ${scobj_hpath}/magnet/state htron_delay "10"
hsetprop ${scobj_hpath}/magnet/state sdsinfo "::nexus::scobj::sdsinfo"
hsetprop ${scobj_hpath}/magnet/state type "part"
hsetprop ${scobj_hpath}/magnet/state nxalias "${name}_magnet_state"
if {[string equal -nocase "${simulation_flag}" "false"]} {
${sct_controller} poll ${scobj_hpath}/magnet/state 1
hsetprop ${scobj_hpath}/magnet/state simulated false
} else {
::scobj::oxford10tlv::sics_log 9 "simulation_flag=${simulation_flag} => No poll/write for oxford10tlv"
hsetprop ${scobj_hpath}/magnet/state simulated true
}
hsetprop ${scobj_hpath}/magnet data "true"
hsetprop ${scobj_hpath}/magnet klass "@none"
hsetprop ${scobj_hpath}/magnet type "part"
ansto_makesctdrive ${name}_magnet_setpoint ${scobj_hpath}/magnet/setpoint ${scobj_hpath}/magnet/field ${sct_controller}
hsetprop ${scobj_hpath} driver oxford10tlv
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::oxford10tlv::add_driver {name device_class simulation_flag ip_address tcp_port id datype interval} {
set catch_status [ catch {
::scobj::oxford10tlv::sics_log 9 "::scobj::oxford10tlv::add_driver ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${datype} ${interval}"
if {[string equal -nocase "${simulation_flag}" "false"]} {
if {[string equal -nocase "aqadapter" "${ip_address}"]} {
::scobj::oxford10tlv::sics_log 9 "makesctcontroller sct_${name} aqadapter ${tcp_port}"
makesctcontroller sct_${name} aqadapter ${tcp_port}
} else {
::scobj::oxford10tlv::sics_log 9 "makesctcontroller sct_${name} std ${ip_address}:${tcp_port}"
makesctcontroller sct_${name} std ${ip_address}:${tcp_port}
}
} else {
::scobj::oxford10tlv::sics_log 9 "simulation_flag=${simulation_flag} => Null sctcontroller for oxford10tlv"
::scobj::oxford10tlv::sics_log 9 "makesctcontroller sct_${name} aqadapter NULL"
makesctcontroller sct_${name} aqadapter NULL
}
::scobj::oxford10tlv::sics_log 1 "::scobj::oxford10tlv::mkDriver sct_${name} ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${datype} ${interval}"
::scobj::oxford10tlv::mkDriver sct_${name} ${name} ${device_class} ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${datype} ${interval}
} catch_message ]
handle_exception ${catch_status} ${catch_message}
}
namespace eval ::scobj::oxford10tlv {
namespace export debug_threshold
namespace export debug_log
namespace export sics_log
namespace export mkDriver
namespace export add_driver
}
proc add_oxford10tlv {name ip_address tcp_port id datype interval} {
set simulation_flag "[string tolower [SplitReply [environment_simulation]]]"
::scobj::oxford10tlv::add_driver ${name} "environment" ${simulation_flag} ${ip_address} ${tcp_port} ${id} ${datype} ${interval}
}
clientput "file evaluation of sct_oxford10tlv.tcl"
::scobj::oxford10tlv::sics_log 9 "file evaluation of sct_oxford10tlv.tcl"
proc ::scobj::oxford10tlv::read_config {} {
set catch_status [ catch {
set ns "::scobj::oxford10tlv"
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"] "oxford10tlv"] } {
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]
foreach arg {id datype interval} {
if {[dict exists $u $arg]} {
lappend arg_list "[dict get $u $arg]"
} elseif {[dict exists $v $arg]} {
lappend arg_list "[dict get $v $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::oxford10tlv::read_config
} else {
::scobj::oxford10tlv::sics_log 5 "No config dict"
}

4
site_ansto/instrument/config/environment/magneticField/tsi_smc.sct
View File

@ -22,7 +22,7 @@ driver tsi_smc = {
permlink = 'B.SP01';
writeable = 1;
write_function = setGauss;
lowerlimit = 0; upperlimit = 500.0; tolerance = 10;
lowerlimit = 0; upperlimit = 15000.0; tolerance = 10;
property settle_time = 5;
mutable = true;
property klass = 'sensor';
@ -49,7 +49,7 @@ driver tsi_smc = {
priv = user;
type = text;
var Rate = { type = float; write_command = "A"; };
var Lower = { type = float; write_command = "L"; lowerlimit = 0; upperlimit = 2; property 'units' = "A"; };
var Lower = { type = float; write_command = "L"; lowerlimit = 0; upperlimit = 60; property 'units' = "A"; };
var Ramp = { type = int; write_command = "R"; allowed = "0,1"; lowerlimit = 0; upperlimit = 1; };
var Pause = { type = int; write_command = "P"; allowed = "0,1"; lowerlimit = 0; upperlimit = 1; };
};

4
site_ansto/instrument/config/environment/magneticField/tsi_smc_sct.tcl
View File

@ -298,7 +298,7 @@ proc ::scobj::tsi_smc::mkDriver { sct_controller name device_class simulation_fl
hsetprop ${scobj_hpath}/setpoint mutable true
hsetprop ${scobj_hpath}/setpoint nxsave true
hsetprop ${scobj_hpath}/setpoint lowerlimit 0
hsetprop ${scobj_hpath}/setpoint upperlimit 500.0
hsetprop ${scobj_hpath}/setpoint upperlimit 15000.0
hsetprop ${scobj_hpath}/setpoint tolerance 10
hsetprop ${scobj_hpath}/setpoint permlink data_set "B[format "%02d" ${id}]SP01"
hsetprop ${scobj_hpath}/setpoint @description "B[format "%02d" ${id}]SP01"
@ -475,7 +475,7 @@ proc ::scobj::tsi_smc::mkDriver { sct_controller name device_class simulation_fl
hsetprop ${scobj_hpath}/b/Lower mutable true
hsetprop ${scobj_hpath}/b/Lower nxsave true
hsetprop ${scobj_hpath}/b/Lower lowerlimit 0
hsetprop ${scobj_hpath}/b/Lower upperlimit 2
hsetprop ${scobj_hpath}/b/Lower upperlimit 60
hsetprop ${scobj_hpath}/b/Lower oldval 0.0
hsetprop ${scobj_hpath}/b/Lower klass "parameter"
hsetprop ${scobj_hpath}/b/Lower sdsinfo "::nexus::scobj::sdsinfo"

2
site_ansto/instrument/config/environment/temperature/julabo_lh45.sct
View File

@ -22,7 +22,7 @@ driver julabo_lh45_gen = {
permlink = 'T.SP01';
writeable = 1; write_function = setPoint; write_command = 'out_sp_00';
driveable = sensor/'value';
lowerlimit = 10; upperlimit = 90; tolerance = '${tol}';
lowerlimit = -20; upperlimit = 90; tolerance = '${tol}';
}
var overtemp_warnlimit = {
read_command = 'in_sp_03';

2
site_ansto/instrument/config/environment/temperature/julabo_lh45_gen_sct.tcl
View File

@ -485,7 +485,7 @@ proc ::scobj::julabo_lh45_gen::mkDriver { sct_controller name device_class simul
hsetprop ${scobj_hpath}/setpoint data true
hsetprop ${scobj_hpath}/setpoint mutable true
hsetprop ${scobj_hpath}/setpoint nxsave true
hsetprop ${scobj_hpath}/setpoint lowerlimit 10
hsetprop ${scobj_hpath}/setpoint lowerlimit -20
hsetprop ${scobj_hpath}/setpoint upperlimit 90
hsetprop ${scobj_hpath}/setpoint tolerance ${tol}
hsetprop ${scobj_hpath}/setpoint permlink data_set "T[format "%02d" ${id}]SP01"

85
site_ansto/instrument/config/environment/temperature/sct_julabo_lh45.tcl
View File

@ -439,3 +439,88 @@ proc add_julabo_lh45 { name IP port {sensor "bath"} {_tol 5.0} {CID 1} {CTYPE T}
}
makesctemon $name /sics/$name/emon/monmode /sics/$name/emon/isintol /sics/$name/emon/errhandler
}
namespace eval ::scobj::julabo_lh45 {
set debug_threshold 5
}
proc ::scobj::julabo_lh45::sics_log {debug_level debug_string} {
set catch_status [ catch {
set debug_threshold ${::scobj::julabo_lh45::debug_threshold}
if {${debug_level} >= ${debug_threshold}} {
sicslog "::scobj::julabo_lh45::${debug_string}"
}
} catch_message ]
}
clientput "file evaluation of sct_julabo_lh45.tcl"
::scobj::julabo_lh45::sics_log 9 "file evaluation of sct_julabo_lh45.tcl"
proc ::scobj::julabo_lh45::read_config {} {
set catch_status [ catch {
set ns "::scobj::julabo_lh45"
dict for {k v} $::config_dict {
if { [dict exists $v "implementation"] } {
if { !([dict exists $v "name"] && [dict exists $v "enabled"]) } {
continue
}
set name [dict get $v name]
set enabled [string tolower [dict get $v "enabled"]]
set implementation [dict get $v "implementation"]
if { !([dict exists $::config_dict $implementation]) } {
continue
}
set v [dict get $::config_dict $implementation]
if { !([dict exists $v "driver"]) } {
continue
}
if { [string equal -nocase [dict get $v "driver"] "julabo_lh45"] } {
if { [string equal -nocase $enabled "true" ] || [string equal -nocase $enabled "always"] } {
if { ![string equal -nocase [SplitReply [environment_simulation]] "false"] } {
set asyncqueue "null"
${ns}::sics_log 9 "[environment_simulation] => using null asyncqueue"
} elseif { [dict exists $v "asyncqueue"] } {
set asyncqueue [dict get $v "asyncqueue"]
} else {
if { [dict exists $v "asyncprotocol"] } {
set asyncprotocol [dict get $v "asyncprotocol"]
} else {
set asyncprotocol ${name}_protocol
MakeAsyncProtocol ${asyncprotocol}
if { [dict exists $v "terminator"] } {
${asyncprotocol} sendterminator "[dict get $v "terminator"]"
${asyncprotocol} replyterminator "[dict get $v "terminator"]"
}
}
set asyncqueue ${name}_queue
set IP [dict get $v ip]
set PORT [dict get $v port]
MakeAsyncQueue ${asyncqueue} ${asyncprotocol} ${IP} ${PORT}
if { [dict exists $v "timeout"] } {
${asyncqueue} timeout "[dict get $v "timeout"]"
}
}
set arg_list [list]
foreach arg {ctrl_sensor tol id type} {
if {[dict exists $v $arg]} {
lappend arg_list "[dict get $v $arg]"
} else {
${ns}::sics_log 9 "Missing configuration value $arg"
error "Missing configuration value $arg"
}
}
add_julabo_lh45 ${name} "aqadapter" ${asyncqueue} {*}$arg_list
}
}
}
}
} catch_message ]
handle_exception ${catch_status} ${catch_message}
}
if { [info exists ::config_dict] } {
::scobj::julabo_lh45::read_config
} else {
::scobj::julabo_lh45::sics_log 5 "No config dict"
}

2
site_ansto/instrument/config/environment/temperature/sct_lakeshore_370.tcl
View File

@ -50,7 +50,7 @@ namespace eval ::scobj::[set vendor]_[set device] {
proc debug_log {debug_level arg_string} {
# write a timestamped string message to a log file for debugging
set debug_threshold 0
set debug_threshold 5
if {$debug_level >= $debug_threshold} {
set fd [open "[set [namespace current]::log_file]" "a"]
set line "[clock format [clock seconds] -format "%T"] $arg_string"

20
site_ansto/instrument/config/hmm/hmm_configuration_common_1.tcl
View File

@ -1471,6 +1471,26 @@ sicslist setatt ::histogram_memory::ratemap_xy_total klass detector
sicslist setatt ::histogram_memory::ratemap_xy_total long_name total_maprate
sicslist setatt ::histogram_memory::ratemap_xy_total mutable true
# Returns 0 If all trips acknowledged, -n if n trips unacknowledged, +n if too many acks?
::utility::macro::getset float ::histogram_memory::reset_trip {args} {
set num_trips [ SplitReply [hmm configure detector_protect_num_trip] ]
set num_acks [ SplitReply [hmm configure detector_protect_num_trip_ack] ]
set trip_cnt_diff [expr {$num_acks - $num_trips}]
if {$args == ""} {
return "reset_trip = $trip_cnt_diff"
} else {
if {$trip_cnt_diff != 0} {
hmm configure fat_detector_protect_num_trip_ack $num_trips
hmm astop
wait 2
hmm init
}
}
}
sicslist setatt ::histogram_memory::reset_trip klass detector
sicslist setatt ::histogram_memory::reset_trip long_name reset_trip
sicslist setatt ::histogram_memory::reset_trip data false
##
# @brief Update the beam monitors when the histmem has finished counting.
proc ::histogram_memory::countend_event {} {

29
site_ansto/instrument/hipd/config/commands/commands.tcl
View File

@ -158,13 +158,16 @@ proc RadCollScanRange {motor start step fin oscno} {
newfile HISTOGRAM_XY
while {$i_bool==0} {
drive $motor $currentmot
$motor send SH`
oct oscillate_count $oscno
oct oscillate start
hmm countblock
save $i
set currentmot [expr {$currentmot + $step}]
if {($step > 0) && ($currentmot > $fin)} {set i_bool 1}
if {($step < 0) && ($currentmot < $fin)} {set i_bool 1}
if {($i_bool == 0)} {run $motor $currentmot}
save $i
incr i
}
}
@ -173,8 +176,13 @@ publish RadCollScanRange user
#RadCollScanBi
proc RadCollScanBi {motor start step fin oscno motdir} {
set i_bool 0
set spx -12500
set spstep [expr {$spx * $step * $motdir}]
histmem stop
histmem mode unlimited
if {$motdir == 1} {
set currentmot $start
set i 0
@ -182,9 +190,10 @@ proc RadCollScanBi {motor start step fin oscno motdir} {
set currentmot $fin
set i [expr {int(($fin-$start)/$step)}]
}
drive $motor $currentmot
newfile HISTOGRAM_XY
while {$i_bool==0} {
# drive $motor $currentmot
oct oscillate_count $oscno
oct oscillate start
hmm countblock
@ -192,14 +201,24 @@ proc RadCollScanBi {motor start step fin oscno motdir} {
if {($motdir > 0)} {
set currentmot [expr {$currentmot + $step}]
if {$currentmot > $fin} {set i_bool 1}
incr i
} else {
set currentmot [expr {$currentmot - $step}]
if {$currentmot < $start} {set i_bool 1}
incr i -1
}
run $motor $currentmot
if {($i_bool == 0)} {run $motor $currentmot}
save $i
if {($motdir > 0)} {incr i 1} else {incr i -1}
# if {($i_bool == 0)} {
# $motor send SH`
# $motor send PR` $spstep
# $motor send BG`
#
# }
# save $i
}
}

15
site_ansto/instrument/hipd/config/commands/eulerscan.tcl
View File

@ -1,7 +1,22 @@
# Euler cradle scan commands for texture runs
# AJS Dec 2010
proc EulerScan {mstart mstep mend oscno} {
ephi speed 5
ephi accel 5
ephi decel 5
echi speed 2
set motdir 1
drive echi 0 ephi $mstart
foreach chival {0 15 30 45 60 75 90} {
drive echi $chival
RadCollScanBi ephi $mstart $mstep $mend $oscno $motdir
set motdir [expr {$motdir * -1}]
}
drive echi 0 ephi $mstart
}
publish EulerScan user
# continous scan for EPHI- the euler cradle phi stage (innermost axis)
# note make sure controller 2 has the PHISCAN code in it

2
site_ansto/instrument/hipd/config/hmm/hmm_configuration.tcl
View File

@ -28,7 +28,7 @@ proc ::histogram_memory::init_OAT_TABLE {args} {
hmm configure fat_frame_source INTERNAL
# set resolution "double_x"
# set resolution "double_x"
switch $resolution {
"hires" {

81
site_ansto/instrument/hipd/config/motors/motor_configuration.tcl
View File

@ -26,7 +26,7 @@ set mx_Home 8390583
#set mom_Home 9274794
##set mom_Home 8391038
#set mom_Home 8147038
set mom_Home 7736816
set mom_Home 7979102
set mtth_Home 19927837
#set mphi_Home 7613516
#set mphi_Home 27847793
@ -34,6 +34,7 @@ set mphi_Home 8384818
#set mchi_Home 9050090
#set mchi_Home 25561619
set mchi_Home 8389526
#set mchi_Home 6847710
#set my_Home 6767221
set my_Home 8378212
set som_Home 17214054
@ -343,7 +344,7 @@ Motor $sample_stage_rotate $motor_driver_type [params \
asyncqueue mc2\
axis E\
units degrees\
hardlowerlim -71\
hardlowerlim -121\
hardupperlim 116\
maxSpeed 5\
maxAccel 3\
@ -363,8 +364,10 @@ Motor stth $motor_driver_type [params \
asyncqueue mc2\
axis F\
units degrees\
hardlowerlim 15.8\
hardlowerlim 13\
hardupperlim 29.7\
softlowerlim 13.4\
softupperlim 29.6\
maxSpeed 0.5\
maxAccel 0.1\
maxDecel 0.1\
@ -374,7 +377,7 @@ Motor stth $motor_driver_type [params \
bias_bits 25\
bias_bias 932070\
cntsPerX -93207]
stth softlowerlim 15.9
stth softlowerlim 13.4
stth softupperlim 29.6
stth home 28.481113
#stth home 18.981113
@ -414,28 +417,34 @@ oct long_name oct
############################
#
# Monochromator Focusing (HOPG)
#Motor mf1 $motor_driver_type [params \
# asyncqueue mc3\
# axis A\
# units degrees\
# hardlowerlim xxxx\
# hardupperlim xxxx\
# maxSpeed xxxx\
# maxAccel xxxx\
# maxDecel xxxx\
# stepsPerX xxxx\
# absEnc 1\
# absEncHome $mf1_Home\
# cntsPerX xxxx]
#setHomeandRange -motor mf1 -home 0 -lowrange 0 -uprange 360
#mf1 speed 1
#mf1 movecount $move_count
#mf1 precision 0.01
#mf1 part monochromator
#mf1 long_name mf1
set mf_config 1
switch $mf_config {
1 {
# Monochromator Focusing (HOPG)
Motor mf1 $motor_driver_type [params \
asyncqueue mc3\
axis A\
units degrees\
hardlowerlim -0.1\
hardupperlim 1.1\
maxSpeed 0.1\
maxAccel 0.1\
maxDecel 0.1\
stepsPerX 22000\
absEnc 1\
absEncHome 3965\
cntsPerX -3500]
setHomeandRange -motor mf1 -home 0 -lowrange 0 -uprange 1
mf1 speed 0.02
# mf1 movecount $move_count
mf1 precision 0.005
mf1 part monochromator
mf1 long_name mf1
}
# Monochromator Focusing (Ge)
## ffr 31/7/2012
## absEncHome was found to be 16777217 on 31/7/2012 when the
## encoder clocked over to 114 counts to give a posn
@ -444,26 +453,32 @@ oct long_name oct
## and has a 24bit range (ie max cnt=16777216)
## I set a bias of 10000 counts with absenchome = 10000
## so that SICS can drive the axis to the allowed limits.
Motor mf2 $motor_driver_type [params \
2 {
Motor mf2 $motor_driver_type [params \
asyncqueue mc3\
axis A\
units degrees\
hardlowerlim -2\
hardupperlim 2\
hardlowerlim -0.1\
hardupperlim 1.1\
maxSpeed 0.1\
maxAccel 0.1\
maxDecel 0.1\
stepsPerX 22000\
absEnc 1\
absEncHome 42768\
absEncHome 10000\
bias_bits 24\
bias_bias 10000\
cntsPerX -3500]
setHomeandRange -motor mf2 -home 0 -lowrange 0 -uprange 2
mf2 speed 0.02
mf2 precision 0.005
mf2 part monochromator
mf2 long_name mf2
setHomeandRange -motor mf2 -home 0 -lowrange 0 -uprange 1
mf2 speed 0.02
mf2 precision 0.005
mf2 part monochromator
mf2 long_name mf2
}
}
# Slit 1, right
Motor ss1r $motor_driver_type [params \

2
site_ansto/instrument/hipd/util/sics_config.ini
View File

@ -324,7 +324,6 @@ driver = "west_6100"
imptype = temperature
ip = 10.157.205.24
port = 502
timeout = 2000
[vf2_west4100]
asyncprotocol = modbus_ap
@ -334,5 +333,4 @@ driver = "west_6100"
imptype = temperature
ip = 10.157.205.25
port = 502
timeout = 2000

4
site_ansto/instrument/hipd/wombat_configuration.tcl
View File

@ -31,6 +31,7 @@ fileeval $cfPath(environment)/huber_pilot_sct.tcl
fileeval $cfPath(environment)/isotech_ps_sct.tcl
fileeval $cfPath(environment)/temperature/sct_eurotherm_2000.tcl
fileeval $cfPath(environment)/temperature/eurotherm_m2000_sct.tcl
fileeval $cfPath(environment)/temperature/eurotherm_3200_sct.tcl
fileeval $cfPath(environment)/sct_keithley_2700.tcl
fileeval $cfPath(environment)/keithley_m2700_sct.tcl
fileeval $cfPath(environment)/temperature/lakeshore_218_sct.tcl
@ -61,13 +62,16 @@ fileeval $cfPath(commands)/pulser.tcl
fileeval $cfPath(commands)/hvcommands.tcl
fileeval $cfPath(commands)/vactex.tcl
fileeval $cfPath(commands)/eulerscan.tcl
fileeval $cfPath(commands)/cfcommands.tcl
fileeval $cfPath(anticollider)/anticollider.tcl
fileeval $cfPath(beamline)/sct_he3_polanal.tcl
fileeval $cfPath(hmm)/hmm_rapid.tcl
source gumxml.tcl
# Wombat only change to hvcommands' scaleval variable
SetVoltScale 2000.0
# The Alice Thing
# Qlink : 9600, 8 data, 1 stop, No Parity, None Flow
# LS340 : 9600, 7 data, 1 stop, Odd Parity, None Flow

3
site_ansto/instrument/hrpd/config/motors/motor_configuration.tcl
View File

@ -24,7 +24,8 @@ set my_Home 8389613
#set mx_Home 7580366
set mx_Home 8392083
#set mom_Home 13442930
set mom_Home 8218065
#set mom_Home 8218065
set mom_Home 8295887
set mtth_Home 11534660
set pcx_Home 6330515
set pcr_Home 21650101

4
site_ansto/instrument/kookaburra/config/anticollider/acscript.txt
View File

@ -7,3 +7,7 @@ forbid {-inf 200} for m2y when m2om in {10 170}
# Following two rules allow recovery if m2om position has crept above 10 or below 170
forbid {11 inf} for m2om whenall {m2y in {-inf 200} m2om in {10 11}}
forbid {-inf 169} for m2om whenall {m2y in {-inf 200} m2om in {169 170}}
# Protect long Cd tunnel
forbid {-5.65 inf} for m2x when m2om in {170 182}
forbid {55.43 inf} for m2x when m2om in {-2 10}

21
site_ansto/instrument/kookaburra/config/anticollider/anticollider.tcl
View File

@ -12,3 +12,24 @@ proc ::anticollider::enable {args} {
}
::anticollider::loadscript acscript.txt
# Default enable or disable anticollision for all axes
# TODO: Provide a list of motors to enable or disable
proc anticollider {args} {
set usage "Usage: anticollider (enable | disable)"
if {$args == "enable"} {
# TODO change protect_detector to just 'protect'
::anticollider::protect_detector "true"
} elseif {$args == "disable"} {
::anticollider::protect_detector "false"
} elseif {$args == "help"} {
clientput $usage
} else {
if {[SplitReply [::anticollider::protect_detector]] == "false"} {
clientput "Anticollision disabled on all axes"
} else {
clientput "Anticollision enabled on all axes"
}
}
}
publish anticollider user

12
site_ansto/instrument/kookaburra/config/motors/motor_configuration.tcl
View File

@ -235,7 +235,7 @@ Motor m1chi $motor_driver_type [params \
cntsPerX [expr 131072*100.0/68.681]\
nopowersave 1]
m1chi precision 0.001
m1chi speed 0.200
m1chi speed 0.137362
m1chi part crystal
m1chi long_name m1chi
m1chi softlowerlim -2
@ -435,7 +435,7 @@ Motor samz $motor_driver_type [params \
stepsPerX [expr 25000.0 * 100 / 10.0]\
cntsPerX 819.2\
absEnc 1\
absEncHome 72607]
absEncHome 75330]
samz part sample
samz long_name samz
samz softlowerlim 0
@ -590,7 +590,7 @@ Motor m2chi $motor_driver_type [params \
cntsPerX [expr 131072*100.0/68.681]\
nopowersave 1]
m2chi precision 0.001
m2chi speed 0.200
m2chi speed 0.137362
m2chi part crystal
m2chi long_name m2chi
m2chi softlowerlim -2
@ -610,7 +610,7 @@ Motor m2om $motor_driver_type [params \
port pmc3-kookaburra\
axis F\
units degrees\
hardlowerlim 0\
hardlowerlim -2\
hardupperlim 182\
maxSpeed [expr 300000.0/$m2omSetRate]\
maxAccel [expr 25000.0/$m2omSetRate]\
@ -673,7 +673,7 @@ Motor m2y $motor_driver_type [params \
axis H\
units mm\
hardlowerlim -4.35\
hardupperlim 357.9\
hardupperlim 400\
maxSpeed [expr 100000.0/$m2ySetRate]\
maxAccel [expr 25000.0/$m2ySetRate]\
maxDecel [expr 25000.0/$m2ySetRate]\
@ -685,7 +685,7 @@ m2y speed 0.5
m2y part crystal
m2y long_name m2y
m2y softlowerlim -4.3
m2y softupperlim 355
m2y softupperlim 399
m2y home 0

2
site_ansto/instrument/kookaburra/config/scan/scan.tcl
View File

@ -32,7 +32,7 @@ proc thresholdscan {minVoltage maxVoltage stepVoltage minBMThreshold manBMThresh
clientput "Start scanning loop now"
for {set vol $minVoltage} {$vol <= $maxVoltage} {incr vol $stepVoltage} {
emHV1 $vol
# emHV1 $vol
set curCount ""
for {set thres $minBMThreshold} {$thres <= $manBMThreshold} {incr thres $stepBMThreshold} {
clientput "set thredshold to $thres"

3
site_ansto/instrument/kookaburra/kookaburra_configuration.tcl
View File

@ -45,6 +45,8 @@ fileeval $cfPath(environment)/temperature/mercury_valve_sct.tcl
fileeval $cfPath(environment)/sct_protek_common.tcl
fileeval $cfPath(environment)/protekmm_sct.tcl
fileeval $cfPath(environment)/temperature/julabo_lh45_gen_sct.tcl
fileeval $cfPath(environment)/sct_rheometer.tcl
fileeval $cfPath(environment)/sct_antonparr_MCR500.tcl
fileeval $cfPath(counter)/sct_bm.tcl
fileeval $cfPath(hmm)/hmm_configuration.tcl
fileeval $cfPath(nexus)/nxscripts.tcl
@ -54,6 +56,7 @@ fileeval $cfPath(commands)/commands.tcl
fileeval $cfPath(anticollider)/anticollider.tcl
fileeval $cfPath(parameters)/parameters.tcl
source gumxml.tcl
::utility::mkVar ::anticollider::protect_detector text manager protect_detector false detector true false

5
site_ansto/instrument/pelican/pelican_configuration.tcl
View File

@ -112,3 +112,8 @@ server_init
# WARNING: Do not add any code below server_init, if you do SICS may fail to initialise properly.
# You can add extra-configuration code in ../extraconfig.tcl
# Update chopper speed and phase if a stop or idle command is issued.
sicspoll add /instrument/fermi_chopper/mchs hdb 5
sicspoll add /instrument/fermi_chopper/mchp hdb 5
sicspoll add /instrument/fermi_chopper/schs hdb 5
sicspoll add /instrument/fermi_chopper/schp hdb 5

1
site_ansto/instrument/qld/MANIFEST.TXT Normal file → Executable file
View File

@ -4,6 +4,5 @@ hipadaba_configuration.tcl
hpaths.tcl
koala.hdd
troubleshoot_setup.tcl
extraconfig.tcl
InstXML.xml
sics_simulation.tcl

1
site_ansto/instrument/reflectometer/MANIFEST.TXT Normal file → Executable file
View File

@ -2,7 +2,6 @@ runsics_def.py
platypus_configuration.tcl
sics_ports.tcl
script_validator_ports.tcl
extraconfig.tcl
config
util
hostport_config.tcl

4
site_ansto/instrument/reflectometer/config/hmm/detector.tcl
View File

@ -14,10 +14,14 @@ evfactory new dhv1 nhq200 acq 1
dhv1 tolerance 5
dhv1 rate 25
dhv1 upper 3000
dhv1 max 3000
dhv1 upperlimit 3000
#dhv1 lock
evfactory new dhv2 nhq200 acq 2
dhv2 tolerance 5
dhv2 rate 25
dhv2 upper 1500
dhv1 max 1500
dhv1 upperlimit 1500
#dhv2 lock
}

2
site_ansto/instrument/reflectometer/platypus_configuration.tcl
View File

@ -33,6 +33,7 @@ fileeval $cfPath(environment)/mvp_valve_sct.tcl
fileeval $cfPath(environment)/sct_protek_common.tcl
fileeval $cfPath(environment)/protekmm_sct.tcl
fileeval $cfPath(environment)/omron_hldc_sct.tcl
fileeval $cfPath(environment)/keysight_N8740A_sct.tcl
fileeval $cfPath(environment)/magneticField/sct_bruker_BEC1.tcl
fileeval $cfPath(environment)/magneticField/bruker_sct.tcl
fileeval $cfPath(environment)/temperature/sct_lakeshore_336.tcl
@ -48,6 +49,7 @@ fileeval $cfPath(chopper)/chopper.tcl
fileeval $cfPath(commands)/commands.tcl
fileeval $cfPath(anticollider)/anticollider.tcl
fileeval $cfPath(beamline)/polanal.tcl
fileeval $cfPath(beamline)/he3_polanal_sct.tcl
fileeval $cfPath(commands)/pulser.tcl
fileeval $cfPath(commands)/hvcommands.tcl

2
site_ansto/instrument/reflectometer/sics_simulation.tcl
View File

@ -4,7 +4,7 @@
# icsval column = settings when running on the Instrument Control Server (ie SICS_SIMULATION not defined)
# fakedev column = settings for test platforms (ie SICS_SIMULATION=fakedev)
foreach {simflag icsval fakedev} {
opal_simulation true true
opal_simulation false true
detector_simulation false true
hmm_simulation false true
environment_simulation false true

1
site_ansto/instrument/rsd/MANIFEST.TXT Normal file → Executable file
View File

@ -2,7 +2,6 @@ runsics_def.py
sics_ports.tcl
script_validator_ports.tcl
kowari_configuration.tcl
extraconfig.tcl
config
util
hostport_config.tcl

1
site_ansto/instrument/sans/MANIFEST.TXT Normal file → Executable file
View File

@ -2,7 +2,6 @@ runsics_def.py
quokka_configuration.tcl
sics_ports.tcl
script_validator_ports.tcl
extraconfig.tcl
config
util
hostport_config.tcl

1
site_ansto/instrument/sans/config/environment/sct_rheometer.tcl
View File

@ -100,4 +100,5 @@ proc add_rheo {rhControl tol settle} {
hfactory /sics/$rhControl/settletime plain user float
hset /sics/$rhControl/settletime $settle
hsetprop /sics/$rhControl timecheck 0
hsetprop /sics/$rhControl callBack "rhCallBack /sics/$rhControl"
}

4
site_ansto/instrument/sans/config/motors/motor_configuration.tcl
View File

@ -718,7 +718,7 @@ Motor apx $motor_driver_type [params \
axis E\
units mm\
hardlowerlim -260\
hardupperlim 5\
hardupperlim 45\
maxSpeed 5\
maxAccel 5\
maxDecel 5\
@ -730,7 +730,7 @@ apx part collimator
apx long_name apx
apx home 0
apx softlowerlim -255
apx softupperlim 5
apx softupperlim 45
apx speed 5
# Sample aperture y

6
site_ansto/instrument/sans/quokka_configuration.tcl
View File

@ -61,12 +61,16 @@ fileeval $cfPath(hmm)/detector.tcl
fileeval $cfPath(scan)/scan.tcl
fileeval $cfPath(commands)/commands.tcl
fileeval $cfPath(anticollider)/anticollider.tcl
fileeval $cfPath(environment)/temperature/sct_julabo_lh45.tcl
fileeval $cfPath(environment)/temperature/sct_julabo_lh45_gen.tcl
fileeval $cfPath(environment)/temperature/sct_qlink.tcl
fileeval $cfPath(environment)/magneticField/tsi_smc_sct.tcl
fileeval $cfPath(environment)/temperature/sct_oxford_itc.tcl
fileeval $cfPath(environment)/magneticField/oxford_labview.tcl
fileeval $cfPath(environment)/magneticField/sct_oxford10tlv.tcl
fileeval $cfPath(environment)/magneticField/sct_oxford12tlv.tcl
fileeval $cfPath(environment)/magneticField/sct_bruker_BEC1.tcl
fileeval $cfPath(environment)/magneticField/sct_bruker.tcl
fileeval $cfPath(beamline)/sct_he3_polanal.tcl
fileeval $cfPath(environment)/environment.tcl
fileeval $cfPath(environment)/sct_rheometer.tcl
fileeval $cfPath(environment)/sct_antonparr_MCR500.tcl

166
site_ansto/instrument/tas/config/motors/motor_configuration.tcl
View File

@ -104,25 +104,58 @@ if { [ info exists ::config_dict ] } {
set axis_config 0
} elseif {$implementation == "12tmagnet_sample_insert"} {
set axis_config 1
} elseif {$implementation == "eulerian_cradle"} {
set axis_config 2
} else {
set axis_config 0
}
}
if { [ dict exists $::config_dict m2s2 implementation ] } {
set implementation [ dict get $::config_dict m2s2 implementation ]
if {$implementation == "normal_m2s2"} {
set m2_speed 0.4
set m2_accel 0.04
set m2_decel 0.04
set s2_speed 0.8
set s2_accel 0.2
set s2_decel 0.2
} elseif {$implementation == "extended_m2s2"} {
set m2_speed 0.1
set m2_accel 0.025
set m2_decel 0.025
set s2_speed 0.4
set s2_accel 0.1
set s2_decel 0.1
} else {
set m2_speed 0.4
set m2_accel 0.04
set m2_decel 0.04
set s2_speed 0.8
set s2_accel 0.2
set s2_decel 0.2
}
}
}
switch $axis_config {
0 {
set use_normal_config "true"
set use_s1_stage "true"
set tilt_motor_driver_type $motor_driver_type
fileeval $cfPath(motors)/tilt_configuration.tcl
}
1 {
set magmot s1
set magmot_aq "mc2"
set magmot_axis "A"
set use_normal_config "false"
set use_s1_stage "false"
set tilt_motor_driver_type asim
fileeval $cfPath(motors)/tilt_configuration.tcl
fileeval $cfPath(motors)/magnet_configuration.tcl
}
2 {
set use_s1_stage "true"
fileeval $cfPath(motors)/euler_configuration.tcl
}
}
@ -250,9 +283,9 @@ m2 motOffDelay 0
m2 backlash_offset -0.5
m2 creep_offset 0.1
m2 creep_precision 0.0
m2 speed 0.4
m2 accel 0.04
m2 decel 0.04
m2 speed $m2_speed
m2 accel $m2_accel
m2 decel $m2_decel
# mc1: Detector Rotate
Motor a2 $motor_driver_type [params \
@ -292,100 +325,8 @@ a2 decel 0.2
############################
#
# mc2: Sample Tilt 1
Motor sgu $tilt_motor_driver_type [params \
asyncqueue mc2\
host mc2-taipan\
port pmc2-taipan\
axis A\
units degrees\
hardlowerlim -13\
hardupperlim 16.5\
maxSpeed 2\
maxAccel 1\
maxDecel 1\
stepsPerX 25000\
absEnc 1\
absEncHome 7745478\
cntsPerX 8192]
sgu part sample
sgu long_name sgu
sgu softlowerlim -13
sgu softupperlim 16.5
sgu home 0
sgu backlash_offset -0.2
# mc2: Sample Tilt 2
Motor sgl $tilt_motor_driver_type [params \
asyncqueue mc2\
host mc2-taipan\
port pmc2-taipan\
axis B\
units degrees\
hardlowerlim -16.5\
hardupperlim 17.5\
maxSpeed 2\
maxAccel 1\
maxDecel 1\
stepsPerX 25000\
absEnc 1\
absEncHome 7499135\
cntsPerX 8192]
sgl part sample
sgl long_name sgl
sgl softlowerlim -16.5
sgl softupperlim 17.5
sgl home 0
sgl backlash_offset -0.2
# mc2: Sample Up Tanslation
Motor stu $motor_driver_type [params \
asyncqueue mc2\
host mc2-taipan\
port pmc2-taipan\
axis C\
units mm\
hardlowerlim -15\
hardupperlim 15\
maxSpeed 2\
maxAccel 1\
maxDecel 1\
stepsPerX -25000\
absEnc 1\
absEncHome 7392933\
cntsPerX -8192]
stu part sample
stu long_name stu
stu softlowerlim -15
stu softupperlim 15
stu home 0.0
stu backlash_offset -0.2
# mc2: Sample Lower Tanslation
Motor stl $motor_driver_type [params \
asyncqueue mc2\
host mc2-taipan\
port pmc2-taipan\
axis D\
units mm\
hardlowerlim -15\
hardupperlim 15\
maxSpeed 2\
maxAccel 1\
maxDecel 1\
stepsPerX 25000\
absEnc 1\
absEncHome 7582773\
cntsPerX 8192]
stl part sample
stl long_name stl
stl softlowerlim -15
stl softupperlim 15
stl home 0.0
stl backlash_offset -0.2
# mc2: Sample Rotate
if {$use_normal_config == "true"} {
if {$use_s1_stage == "true"} {
Motor s1 $motor_driver_type [params \
asyncqueue mc2\
host mc2-taipan\
@ -409,6 +350,7 @@ if {$use_normal_config == "true"} {
s1 backlash_offset -0.2
}
# mc2: Analyser Detector Rotate -- Sample Scattering Angle
# absEncHome 20728908\ at -50
Motor s2 $motor_driver_type [params \
@ -440,9 +382,9 @@ s2 backlash_offset 0.5
s2 blockage_thresh 1
s2 creep_offset 0.015
s2 creep_precision 0.005
s2 speed 0.8
s2 accel 0.2
s2 decel 0.2
s2 speed $s2_speed
s2 accel $s2_accel
s2 decel $s2_decel
# mc2: Analyser Horizontal Focus
Motor ahfocus $motor_driver_type [params \
@ -520,9 +462,10 @@ mvfocus long_name mvfocus
mvfocus softlowerlim 0
mvfocus softupperlim 300
mvfocus home 0.0
mvfocus Blockage_Thresh 2
mvfocus Blockage_Thresh 4
mvfocus Blockage_Check_Interval 2
mvfocus creep_offset 0.2
mvfocus backlash_offset -4
# mc3: Monochromator Horizontal Focus
Motor mhfocus $motor_driver_type [params \
asyncqueue mc3\
@ -531,25 +474,26 @@ Motor mhfocus $motor_driver_type [params \
axis B\
units degrees\
precision 0.2\
hardlowerlim -80\
hardupperlim 240\
hardlowerlim -10\
hardupperlim 280\
maxSpeed 3.6\
maxAccel 1.728\
maxDecel 1.728\
stepsPerX [expr -25000.0 * 50.0 / 360.0]\
stepsPerX [expr 25000.0 * 50.0 / 360.0]\
absEnc 1\
bias_bits 12\
bias_bias 1540\
absEncHome 2788\
cntsPerX [expr -4096.0 / 360.0]]
bias_bias 1300\
absEncHome 243\
cntsPerX [expr 4096.0 / 360.0]]
mhfocus part crystal
mhfocus long_name mhfocus
mhfocus softlowerlim -75
mhfocus softupperlim 235
mhfocus softlowerlim -10
mhfocus softupperlim 280
mhfocus home 0
mhfocus Blockage_Thresh 2
mhfocus Blockage_Thresh 4
mhfocus Blockage_Check_Interval 2
mhfocus creep_offset 0.2
mhfocus backlash_offset -4
# mc3: Monochromator Rotate
Motor m1 $motor_driver_type [params \

92
site_ansto/instrument/tas/config/motors/tilt_configuration.tcl Normal file
View File

@ -0,0 +1,92 @@
# mc2: Sample Tilt 1
Motor sgu $tilt_motor_driver_type [params \
asyncqueue mc2\
host mc2-taipan\
port pmc2-taipan\
axis A\
units degrees\
hardlowerlim -13\
hardupperlim 16.5\
maxSpeed 2\
maxAccel 1\
maxDecel 1\
stepsPerX 25000\
absEnc 1\
absEncHome 7745478\
cntsPerX 8192]
sgu part sample
sgu long_name sgu
sgu softlowerlim -13
sgu softupperlim 16.5
sgu home 0
sgu backlash_offset -0.2
# mc2: Sample Tilt 2
Motor sgl $tilt_motor_driver_type [params \
asyncqueue mc2\
host mc2-taipan\
port pmc2-taipan\
axis B\
units degrees\
hardlowerlim -16.5\
hardupperlim 17.5\
maxSpeed 2\
maxAccel 1\
maxDecel 1\
stepsPerX 25000\
absEnc 1\
absEncHome 7499135\
cntsPerX 8192]
sgl part sample
sgl long_name sgl
sgl softlowerlim -16.5
sgl softupperlim 17.5
sgl home 0
sgl backlash_offset -0.2
# mc2: Sample Up Tanslation
Motor stu $motor_driver_type [params \
asyncqueue mc2\
host mc2-taipan\
port pmc2-taipan\
axis C\
units mm\
hardlowerlim -15\
hardupperlim 15\
maxSpeed 2\
maxAccel 1\
maxDecel 1\
stepsPerX -25000\
absEnc 1\
absEncHome 7392933\
cntsPerX -8192]
stu part sample
stu long_name stu
stu softlowerlim -15
stu softupperlim 15
stu home 0.0
stu backlash_offset -0.2
# mc2: Sample Lower Tanslation
Motor stl $motor_driver_type [params \
asyncqueue mc2\
host mc2-taipan\
port pmc2-taipan\
axis D\
units mm\
hardlowerlim -15\
hardupperlim 15\
maxSpeed 2\
maxAccel 1\
maxDecel 1\
stepsPerX 25000\
absEnc 1\
absEncHome 7582773\
cntsPerX 8192]
stl part sample
stl long_name stl
stl softlowerlim -15
stl softupperlim 15
stl home 0.0
stl backlash_offset -0.2

46
site_ansto/instrument/tas/taipan_configuration.tcl
View File

@ -40,18 +40,22 @@ fileeval $cfPath(environment)/agilent_33220A_sct.tcl
fileeval $cfPath(environment)/sct_protek_common.tcl
fileeval $cfPath(environment)/protekmm_sct.tcl
fileeval $cfPath(environment)/temperature/sct_eurotherm_2000.tcl
fileeval $cfPath(environment)/temperature/sct_eurotherm_3200.tcl
fileeval $cfPath(environment)/temperature/sct_julabo_lh45.tcl
fileeval $cfPath(environment)/temperature/sct_lakeshore_336.tcl
fileeval $cfPath(environment)/temperature/ls336_sct.tcl
fileeval $cfPath(environment)/temperature/sct_lakeshore_340.tcl
fileeval $cfPath(environment)/temperature/ls340_sct.tcl
fileeval $cfPath(environment)/temperature/sct_lakeshore_370.tcl
fileeval $cfPath(environment)/temperature/sct_lakeshore_m370.tcl
fileeval $cfPath(environment)/temperature/sct_oxford_itc.tcl
fileeval $cfPath(environment)/temperature/oxford_mercury_sct.tcl
fileeval $cfPath(environment)/temperature/west400.tcl
fileeval $cfPath(environment)/temperature/sct_west_6100.tcl
fileeval $cfPath(environment)/he3/sct_he3.tcl
fileeval $cfPath(environment)/magneticField/oxford_labview.tcl
fileeval $cfPath(environment)/magneticField/oxford12tlv_sct.tcl
fileeval $cfPath(environment)/he3/sct_he3.tcl
fileeval $cfPath(beamline)/he3_polanal_sct.tcl
fileeval config/load_setup.tcl
fileeval log.tcl
publish logbook spy
@ -60,18 +64,36 @@ source gumxml.tcl
::utility::mkVar ::anticollider::protect_detector text manager protect_detector false detector true false
::anticollider::protect_detector "true"
if { [ dict exists $::config_dict sample_stage implementation ] } {
set sample_stage [ dict get $::config_dict sample_stage implementation ]
} else {
set sample_stage "normal_sample_stage"
}
switch $sample_stage {
"eulerian_cradle" {
# s1-> eom, sgu -> ephi, sgl -> echi
set OMEGA s1
set PHI ephi
set CHI echi
}
"normal_sample_stage" - default {
set OMEGA s1
set PHI sgu
set CHI sgl
}
}
# init for the tasUB
#make mcv mch acv ach into mvfocus mhfocus avfocus ahfocus when it works
puts "doing tasub"
MakeTasUB tasub m1 m2 mvfocus mhfocus s1 s2 sgu sgl a1 a2 avfocus ahfocus
MakeTasUB tasub m1 m2 mvfocus mhfocus $OMEGA s2 $PHI $CHI a1 a2 avfocus ahfocus
tasub mono dd 3.35416
tasub ana dd 3.35416
# NOTE Autofocussing parameters persist in status.tcl
# You must set them in extraconfig.tcl to override this behaviour
# NOTE Autofocussing parameters (vbn, hbn) persist in status.tcl
# To override this behaviour you can set them in extraconfig.tcl
tasub mono vb1 102.2
tasub mono vb2 1.78
tasub mono hb1 184.42
tasub mono hb2 -60.1
tasub mono hb1 18.28
tasub mono hb2 60.1
tasub mono hb3 0.951
tasub ana vb1 115
tasub ana vb2 2.13
@ -90,6 +112,16 @@ server_init
###########################################
# WARNING: Do not add any code below server_init, if you do SICS may fail to initialise properly.
puts "Making hkl command"
MakeMono mono PG m1 m2
mono dd 3.35416
MakeWaveLength lambda mono
MakeEnergy energy mono
#MakeSingleX singlex
#MakeHKL s2 $OMEGA $PHI $CHI
#MakeHKLMot hkl
#MakeUBcalc ubcalc hkl
# Provide tasmot notifications to GumTree when real motors move
proc m2tasupdate {} {
tasub update
@ -125,7 +157,7 @@ proc a2tasupdate {} {
publish a2tasupdate user
scriptcallback connect m2 MOTEND m2tasupdate
scriptcallback connect s1 MOTEND s1s2tasupdate
scriptcallback connect $OMEGA MOTEND s1s2tasupdate
scriptcallback connect s2 MOTEND s1s2tasupdate
scriptcallback connect a2 MOTEND a2tasupdate