#%TITLE% linkam.mac
#%NAME%
# LINKAM.MAC
#%CATEGORY%
#%DESCRIPTION%
#
#%EXAMPLE%
#%DL%
#%DT%XXXsetup%DD%
#%SETUP%
#%UL%
#%LI%
#%XUL%
global LINKAM_PAR[]
# LINKAM_PAR["device"]
# LINKAM_PAR["on"]
# LINKAM_PAR["temp"]
# LINKAM_PAR["cnt_mne"]
# LINKAM_PAR[""]
# LINKAM_PAR[""]
def linkam_setup '{
global LINKAM_PAR[]
local _nb_param
_nb_param = $#
if (_nb_param == 1) {
LINKAM_PAR["device"] = "$1"
}
else if(_nb_param > 1 && _nb_param <= 3){
LINKAM_PAR["device"] = "$1"
LINKAM_PAR["cnt_mne"] = "$2"
LINKAM_PAR["scale_factor"] = "$3"
_cmd = sprintf( "linkam_gettemp %s \n", LINKAM_PAR["cnt_mne"])
cdef("user_getcounts", _cmd, LINKAM_PAR["cnt_mne"], 0x02)
linkam_on
}
else {
print "Usage: $0 <device_name> [<counter_mnemonic> [<scale_factor>] ]"
exit
}
setup_tail("linkam_")
}'
def linkam_unsetup '{
linkam_off
if (LINKAM_PAR["cnt_mne"] != 0){
counter_par(LINKAM_PAR["cnt_mne"], "disable" , 1)
}
cdef("user_getcounts", "", LINKAM_PAR["cnt_mne"], "delete")
unglobal LINKAM_PAR
}'
def linkam_on '{
LINKAM_PAR["on"] = 1
counter_par(LINKAM_PAR["cnt_mne"], "disable" , 0)
printf( "LINKAM : pseudo counter \"%s\" is now ON\n", LINKAM_PAR["cnt_mne"])
}'
def linkam_off '{
if (LINKAM_PAR["cnt_mne"] != 0){
LINKAM_PAR["on"] = 0
S[cnt_num(LINKAM_PAR["cnt_mne"])] = 0
counter_par(LINKAM_PAR["cnt_mne"], "disable" , 1)
printf( "LINKAM : pseudo counter \"%s\" is now OFF\n", LINKAM_PAR["cnt_mne"])
}
}'
def linkam_status '{
print "LINKAM : STATUS : pseudo counter : ", LINKAM_PAR["on"] ? "ON" : "OFF"
print "LINKAM : STATUS : Cell :", _linkam_status()
}'
#%IU% <pseudo_counter_mnemonic>
#%MDESC%
# Reads the Linkam temperature and stores it in the corresponding
# global variable.
#
def linkam_gettemp '{
local _sf _mne
_mne = "$1"
if(cnt_num(_mne) > -1){
_sf = LINKAM_PAR["scale_factor"] ? LINKAM_PAR["scale_factor"] : 1
S[cnt_num(_mne)] = _linkam_get_temperature() * _sf
}
else{
print " LINKAM : ERROR : " _mne " does not exists"
}
}'
######################################################################
##################### ####################
##################### User level linkam control ####################
##################### ####################
######################################################################
#%UU%
#%MDESC%
#
def linkam_save_status '{
local my_status
if( $# != 0 ) {
printf("usage: %s (prints status to datafile)\n", "$0")
exit
}
my_status = _linkam_status()
fprintf(DATAFILE,"#C Linkam Temperature is %.2f C\n", _linkam_get_temperature())
if(substr(my_status,1,7) == "Holding") {
fprintf(DATAFILE,"#C Linkam is holding\n")
}
else {
fprintf(DATAFILE,"#C Linkam is %s to %.2f at %.2f C/s\n", \
my_status, linkam_get_setpoint(), _linkam_get_rate())
}
}'
#%UU% [param = setpoint = target temperature = limit (in degrees C)]
#%MDESC%
#
def linkam_set_temperature '{
if( $# != 1) {
printf("usage: %s setpoint\n", "$0")
exit
}
if($1 < -100 || $1 > 600 ) {
printf("Temperature %f out of limits\n", $1)
exit
}
_linkam_set_temperature( $1 )
}'
#%UU%
#%MDESC%
#
def linkam_get_temperature '{
if( $# != 0) {
printf("usage: %s\n", "$0")
exit
}
printf("Current Temperature is %f C\n", _linkam_get_temperature())
}'
#%UU% [param = ramp rate in degrees per minute]
#%MDESC%
#
def linkam_set_rate '{
if( $# != 1) {
printf("usage: %s <rate>\n", "$0")
exit
}
_linkam_set_rate( $1 )
}'
#%UU%
#%MDESC%
#
def linkam_get_rate '{
if( $# != 0) {
printf("usage: %s\n", "$0")
exit
}
printf("Current Rate is %f C/min\n", _linkam_get_rate())
}'
#%UU%
#%MDESC%
#
def linkam_get_status '{
if( $# != 0) {
printf("usage: %s\n", "$0")
exit
}
printf("Status is \'%s\' \n", _linkam_status())
}'
#%UU%
#%MDESC%
#
def linkam_get_setpoint '{
if( $# != 0) {
printf("usage: %s\n", "$0")
exit
}
printf("Setpoint is \'%s\' \n", _linkam_get_setpoint())
}'
#%UU% [1st param = setpoint, 2nd if given = waiting time in sec to reach it]
#%MDESC%
#
def linkam_stabilise '{
# go to a temperature (= limit) and assure to be holding at limit
# by reading out status and temperature.
if( $# < 1) {
printf("usage: %s setpoint <max waiting time in seconds>\n", "$0")
exit
}
if($1 < -100 || $1 > 600 ) {
printf("Temperature %f out of limits\n", $1)
exit
}
if ($# == 1) {
wait_time = 300 # 5 minutes
printf("Wait time not given; 5 minutes set\n")
} else {
wait_time = $2
}
_linkam_set_temperature ( $1 )
for(tries=0;tries < wait_time; tries++){
my_status=_linkam_status()
printf("Temperature is %6.1f, Linkam is %s \r", _linkam_get_temperature(), my_status)
if(substr(my_status,1,7) == "Holding") {
printf("\n")
break
}
sleep(1)
}
}'
#%UU% [param = waiting time in a loop]
#%MDESC%
#
def linkam_watch '{
while(1){
my_status=_linkam_status()
printf("%s: Temperature is %6.1fC, Linkam is %s ", \
date(), _linkam_get_temperature(), _linkam_status())
if(substr(my_status,1,7) != "Holding") {
printf("at %4.1f C/min\n", _linkam_get_rate())
} else {
printf(" \r")
}
if($# > 0 && $1 > 0 ){
sleep($1)
}
else {
sleep(1)
}
}
}'
#%UU%
#%MDESC% Checking if linkam is in Holding state
#
def linkam_isholding() '{
local my_status
my_status=_linkam_status()
if(substr(my_status,1,7) != "Holding") {
return 0
} else {
return 1
}
}'
#%UU% [1st param = high T, 2nd param = low T]
#%MDESC%
#
def linkam_pulse '{
local _nb_param
_nb_param = $#
if(_nb_param != 2){
printf("usage: %s T_hot T_cool\n", "$0")
exit
}
linkam_set_rate 200
linkam_stabilise $1
linkam_stabilise $2
}'
#%UU% [param]
#%MDESC%
#
def linkam_cool '{
linkam_set_rate 200
linkam_set_temperature 25
linkam_watch
}'
#%UU%
#%MDESC%
#
def cool '{
# to be typed rapidly
linkam_cool
}'
#%UU%
#%MDESC%
#
def linkam_info '{
print "-----------===== linkam infos =====---------"
linkam_get_temperature
linkam_get_status
linkam_get_rate
print "--------------------------------------------"
}'
#%UU%
#%MDESC%
#
def linkam_pumpauto '{
print "-----------===== linkam pump set to auto mode =====---------"
_linkam_set_pump_auto
}'
#%UU%
#%MDESC%
#
#def linkam_pumpmanual '{
# print "-----------===== linkam pump set to manual mode =====---------"
# print "-----------===== Please use linkam_set_pump_speed 0...30 =====---------"
# _linkam_set_pump_manual
#}'
#%UU% [param = pump speed (0 --> 30), 0 = pump off]
#%MDESC%
#
#def linkam_set_pump_speed '{
# local _nb_param
# print "-----------===== linkam set pump speed for manual mode =====--------"
#
# _nb_param = $#
#
# if(_nb_param != 1){
# printf("usage: %s speed [0-30]\n", "$0")
# exit
# }
# if (($1 < 0) || ($1 > 30)) {
# printf("%s: Pump speed %d is out of range [0-30]\n", "$0", $1)
# exit
# }
#
# print "-----------===== linkam pump set to manual mode =====---------"
# _linkam_set_pump_manual
#
# printf("-----------===== linkam set pump speed to %d =====---------\n",$1)
# _linkam_set_pump_speed $1
#}'
def linkam_stop '{
# Important: do not apply next 2, in order to keep pump in automtic mode
#_linkam_set_pump_manual
#_linkam_set_pump_speed 0
_linkam_stop
}'
def linkam_hold '{
_linkam_hold
}'
######################################################################
##################### #####################
##################### Low level linkam control #####################
##################### #####################
######################################################################
def _linkam_set_temperature( linkam_setpoint ) '{
esrf_io(LINKAM_PAR["device"],"DevLinkamSetLimit",linkam_setpoint)
# Need a sleep of 80ms according Linkam support
sleep(0.1)
esrf_io(LINKAM_PAR["device"],"DevLinkamStart")
}'
def _linkam_get_setpoint() '{
return(esrf_io(LINKAM_PAR["device"],"DevLinkamGetLimit"))
}'
def _linkam_get_temperature() '{
return(esrf_io(LINKAM_PAR["device"],"DevLinkamGetTemperature"))
}'
def _linkam_set_rate( linkam_rate ) '{
esrf_io(LINKAM_PAR["device"],"DevLinkamSetRate",linkam_rate)
}'
def _linkam_get_rate() '{
return(esrf_io(LINKAM_PAR["device"],"DevLinkamGetRate"))
}'
def linkam_dsc_clear '{
esrf_io(LINKAM_PAR["device"],"DevLinkamDscClearBuffer")
#printf("Linkam DSC buffer cleared\n")
}'
def linkam_get_dsc_temperature() '{
local _dsc _old_temp _old_dsc _status
_dsc[0] = -1
_dsc[1] = -1
linkam_dsc_clear
_status = esrf_io(LINKAM_PAR["device"],"DevLinkamGetDscTemperature",_dsc)
_dsc[1] = _dsc[1] & 0xffff
while (_dsc[1] == 32767) {
_status = esrf_io(LINKAM_PAR["device"],"DevLinkamGetDscTemperature",_dsc)
}
#printf("%04x %d\n",_dsc[1] , _dsc[1] & 0xffff)
LINKAM_PAR["temp"] = _dsc[0]
LINKAM_PAR["dsc"] = _dsc[1]
return
}'
def _linkam_status() '{
local linkam_string
linkam_string = esrf_io(LINKAM_PAR["device"],"DevStatus")
# taking away \n in the end
return(substr(linkam_string,1,length(linkam_string)-1))
}'
def _linkam_set_pump_auto '{
ret = esrf_io(LINKAM_PAR["device"],"DevLinkamPumpAutomatic")
if (ret != 0) {
printf("Error setting linkam pump to automatic mode\n")
}
}'
def _linkam_set_pump_manual '{
ret = esrf_io(LINKAM_PAR["device"],"DevLinkamPumpManual")
if (ret != 0) {
printf("Error setting linkam pump to manual mode\n")
}
}'
def _linkam_set_pump_speed '{
ret = esrf_io(LINKAM_PAR["device"],"DevLinkamSetPumpSpeed",$1)
if (ret != 0) {
printf("Error setting linkam pump speed to %d for manual mode\n", $1)
}
}'
def _linkam_stop '{
ret = esrf_io(LINKAM_PAR["device"],"DevLinkamStop")
if (ret != 0) {
printf("Error stopping linkam\n")
}
}'
def _linkam_hold '{
ret = esrf_io(LINKAM_PAR["device"],"DevLinkamHold")
if (ret != 0) {
printf("Error setting linkam to hold state\n")
}
}'
def _linkam_getmodel() '{
local model_string
model_string = esrf_io(LINKAM_PAR["device"],"DevLinkamGetModel")
return(model_string)
}'
|